From 1e4dae59b38f6aa9ebd761b1181c09118ecd912a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 01:32:32 +0100 Subject: [PATCH 1/8] Extend column --- meta/src/meta/grammar.y | 45 +- meta/src/meta/target.py | 3 + meta/src/meta/yacc_action_parser.py | 16 +- proto/relationalai/lqp/v1/logic.proto | 4 +- sdks/go/src/lqp/v1/fragments.pb.go | 10 +- sdks/go/src/lqp/v1/logic.pb.go | 299 +- sdks/go/src/lqp/v1/transactions.pb.go | 8 +- sdks/go/src/parser.go | 3900 ++++++++------- sdks/go/src/pretty.go | 3900 ++++++++------- .../LogicalQueryProtocol.jl/src/equality.jl | 6 +- .../gen/relationalai/lqp/v1/fragments_pb.jl | 2 +- .../src/gen/relationalai/lqp/v1/logic_pb.jl | 20 +- .../relationalai/lqp/v1/transactions_pb.jl | 2 +- .../LogicalQueryProtocol.jl/src/parser.jl | 3207 ++++++------ .../LogicalQueryProtocol.jl/src/pretty.jl | 3936 +++++++-------- .../test/equality_tests.jl | 14 +- sdks/python/src/lqp/gen/parser.py | 3294 +++++++------ sdks/python/src/lqp/gen/pretty.py | 4343 +++++++++-------- sdks/python/src/lqp/proto/v1/fragments_pb2.py | 4 +- sdks/python/src/lqp/proto/v1/logic_pb2.py | 86 +- sdks/python/src/lqp/proto/v1/logic_pb2.pyi | 8 +- .../src/lqp/proto/v1/transactions_pb2.py | 4 +- tests/bin/cdc.bin | Bin 0 -> 664 bytes tests/lqp/cdc.lqp | 36 + tests/pretty/cdc.lqp | 37 + tests/pretty_debug/cdc.lqp | 48 + 26 files changed, 11992 insertions(+), 11240 deletions(-) create mode 100644 tests/bin/cdc.bin create mode 100644 tests/lqp/cdc.lqp create mode 100644 tests/pretty/cdc.lqp create mode 100644 tests/pretty_debug/cdc.lqp diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index d4d7f01c..b4fab3e9 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -72,6 +72,8 @@ %nonterm context transactions.Context %nonterm csv_asof String %nonterm csv_column logic.CSVColumn +%nonterm csv_column_path Sequence[String] +%nonterm csv_column_tail Tuple[Optional[logic.RelationId], Sequence[logic.Type]] %nonterm csv_columns Sequence[logic.CSVColumn] %nonterm csv_config logic.CSVConfig %nonterm csv_data logic.CSVData @@ -980,13 +982,33 @@ csv_config construct: $$ = construct_csv_config($3) deconstruct: $3: Sequence[Tuple[String, logic.Value]] = deconstruct_csv_config($$) +csv_column_path + : STRING + construct: $$ = [$1] + deconstruct if builtin.length($$) == 1: + $1: String = $$[0] + | "[" STRING* "]" + construct: $$ = $2 + deconstruct if builtin.length($$) != 1: + $2: Sequence[String] = $$ + +csv_column_tail + : relation_id "[" type* "]" + construct: $$ = builtin.tuple(builtin.some($1), $3) + deconstruct if $$[0] is not None: + $1: logic.RelationId = $$[0] + $3: Sequence[logic.Type] = $$[1] + | "[" type* "]" + construct: $$ = builtin.tuple(None, $2) + deconstruct: + $2: Sequence[logic.Type] = $$[1] + csv_column - : "(" "column" STRING relation_id "[" type* "]" ")" - construct: $$ = logic.CSVColumn(column_name=$3, target_id=$4, types=$6) + : "(" "column" csv_column_path csv_column_tail? ")" + construct: $$ = construct_csv_column($3, $4) deconstruct: - $3: String = $$.column_name - $4: logic.RelationId = $$.target_id - $6: Sequence[logic.Type] = $$.types + $3: Sequence[String] = $$.column_path + $4: Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]] = deconstruct_csv_column_tail($$) undefine : "(" "undefine" fragment_id ")" @@ -1385,6 +1407,19 @@ def deconstruct_export_csv_config(msg: transactions.ExportCSVConfig) -> List[Tup return builtin.list_sort(result) +def construct_csv_column(path: Sequence[String], tail: Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]) -> logic.CSVColumn: + if tail is not None: + t: Tuple[Optional[logic.RelationId], Sequence[logic.Type]] = builtin.unwrap_option(tail) + return logic.CSVColumn(column_path=path, target_id=t[0], types=t[1]) + return logic.CSVColumn(column_path=path, target_id=None, types=list[logic.Type]()) + + +def deconstruct_csv_column_tail(col: logic.CSVColumn) -> Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]: + if builtin.has_proto_field(col, 'target_id') or not builtin.is_empty(col.types): + return builtin.some(builtin.tuple(col.target_id, col.types)) + return None + + def deconstruct_relation_id_string(msg: logic.RelationId) -> String: name: Optional[String] = builtin.relation_id_to_string(msg) return builtin.unwrap_option(name) diff --git a/meta/src/meta/target.py b/meta/src/meta/target.py index fc0db432..d8653cd7 100644 --- a/meta/src/meta/target.py +++ b/meta/src/meta/target.py @@ -345,6 +345,9 @@ def __post_init__(self): def target_type(self) -> "TargetType": if isinstance(self.func, (ParseNonterminal, PrintNonterminal)): return self.func.target_type() + # Special handling for tuple builtin: construct TupleType from argument types + if isinstance(self.func, Builtin) and self.func.name == "tuple": + return TupleType(tuple(arg.target_type() for arg in self.args)) func_type = self.func.target_type() if isinstance(func_type, FunctionType): # Match parameter types against argument types to build type variable mapping diff --git a/meta/src/meta/yacc_action_parser.py b/meta/src/meta/yacc_action_parser.py index 1d448e09..33dc765c 100644 --- a/meta/src/meta/yacc_action_parser.py +++ b/meta/src/meta/yacc_action_parser.py @@ -169,15 +169,15 @@ def _infer_type( elif isinstance(expr, ListExpr): return ListType(expr.element_type) elif isinstance(expr, GetElement): - # Infer tuple element type - tuple_type = _infer_type(expr.tuple_expr, line, ctx) - if isinstance(tuple_type, TupleType) and 0 <= expr.index < len( - tuple_type.elements + # Infer element type from tuple or sequence/list indexing + container_type = _infer_type(expr.tuple_expr, line, ctx) + if isinstance(container_type, TupleType) and 0 <= expr.index < len( + container_type.elements ): - return tuple_type.elements[expr.index] - raise YaccGrammarError( - f"Cannot infer type of tuple element access: {expr}", line - ) + return container_type.elements[expr.index] + if isinstance(container_type, (SequenceType, ListType)): + return container_type.element_type + raise YaccGrammarError(f"Cannot infer type of element access: {expr}", line) elif isinstance(expr, GetField): # GetField has field_type from proto schema lookup (or Unknown if not found) return expr.field_type diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto index a64c4ef5..cc8a4c0d 100644 --- a/proto/relationalai/lqp/v1/logic.proto +++ b/proto/relationalai/lqp/v1/logic.proto @@ -312,8 +312,8 @@ message CSVConfig { } message CSVColumn { - string column_name = 1; // Name in CSV file - RelationId target_id = 2; // Target relation + repeated string column_path = 1; // Column identifier path (was: string column_name) + optional RelationId target_id = 2; // Target relation (now explicit optional) repeated Type types = 3; // Relation signature (key types + value types) } diff --git a/sdks/go/src/lqp/v1/fragments.pb.go b/sdks/go/src/lqp/v1/fragments.pb.go index d1c926e4..40051f74 100644 --- a/sdks/go/src/lqp/v1/fragments.pb.go +++ b/sdks/go/src/lqp/v1/fragments.pb.go @@ -205,10 +205,12 @@ var file_relationalai_lqp_v1_fragments_proto_rawDesc = string([]byte{ 0x0a, 0x0a, 0x6f, 0x72, 0x69, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x72, 0x69, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x1c, 0x0a, 0x0a, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x42, 0x1f, 0x5a, 0x1d, 0x6c, - 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x33, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x42, 0x43, 0x5a, 0x41, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, + 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, }) var ( diff --git a/sdks/go/src/lqp/v1/logic.pb.go b/sdks/go/src/lqp/v1/logic.pb.go index df23d7e5..e4f92254 100644 --- a/sdks/go/src/lqp/v1/logic.pb.go +++ b/sdks/go/src/lqp/v1/logic.pb.go @@ -3156,8 +3156,8 @@ func (x *CSVConfig) GetCompression() string { type CSVColumn struct { state protoimpl.MessageState `protogen:"open.v1"` - ColumnName string `protobuf:"bytes,1,opt,name=column_name,json=columnName,proto3" json:"column_name,omitempty"` // Name in CSV file - TargetId *RelationId `protobuf:"bytes,2,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"` // Target relation + ColumnPath []string `protobuf:"bytes,1,rep,name=column_path,json=columnPath,proto3" json:"column_path,omitempty"` // Column identifier path (was: string column_name) + TargetId *RelationId `protobuf:"bytes,2,opt,name=target_id,json=targetId,proto3,oneof" json:"target_id,omitempty"` // Target relation (now explicit optional) Types []*Type `protobuf:"bytes,3,rep,name=types,proto3" json:"types,omitempty"` // Relation signature (key types + value types) unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -3193,11 +3193,11 @@ func (*CSVColumn) Descriptor() ([]byte, []int) { return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{46} } -func (x *CSVColumn) GetColumnName() string { +func (x *CSVColumn) GetColumnPath() []string { if x != nil { - return x.ColumnName + return x.ColumnPath } - return "" + return nil } func (x *CSVColumn) GetTargetId() *RelationId { @@ -4921,153 +4921,157 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{ 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x22, 0x9b, 0x01, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, - 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, + 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, + 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x50, 0x61, 0x74, 0x68, + 0x12, 0x41, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x49, 0x64, 0x12, 0x2f, - 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, - 0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 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, 0x89, 0x06, - 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, 0x66, 0x69, - 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, - 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x73, 0x74, 0x72, - 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, - 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, - 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, - 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, - 0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, - 0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x66, 0x6c, 0x6f, 0x61, - 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 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, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, - 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x75, 0x69, 0x6e, - 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 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, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, - 0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x06, 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, 0x49, 0x6e, 0x74, 0x31, - 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, - 0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 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, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x08, 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, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, - 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, - 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, + 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x49, 0x64, + 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, + 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x12, 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, 0x89, 0x06, 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, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, + 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, + 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x39, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 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, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, + 0x00, 0x52, 0x09, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, + 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 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, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, - 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x0a, 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, - 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x64, - 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x62, 0x6f, - 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0b, 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, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, - 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 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, 0xd1, 0x04, 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, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, + 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x06, 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, 0x49, + 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, + 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x65, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 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, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, + 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 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, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, + 0x00, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x45, 0x0a, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x09, 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, 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, + 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69, 0x73, 0x73, 0x69, + 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, + 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 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, 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, 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, 0x1f, 0x5a, 0x1d, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6c, - 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, + 0x52, 0x0b, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, + 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0b, 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, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, + 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, + 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, + 0xd1, 0x04, 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, 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 ( @@ -5340,6 +5344,7 @@ func file_relationalai_lqp_v1_logic_proto_init() { (*BeTreeLocator_RootPageid)(nil), (*BeTreeLocator_InlineData)(nil), } + file_relationalai_lqp_v1_logic_proto_msgTypes[46].OneofWrappers = []any{} file_relationalai_lqp_v1_logic_proto_msgTypes[48].OneofWrappers = []any{ (*Type_UnspecifiedType)(nil), (*Type_StringType)(nil), diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index a1d58575..1b15522d 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -1365,9 +1365,11 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03, - 0x42, 0x1f, 0x5a, 0x1d, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, - 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, + 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, + 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, }) var ( diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index 32010315..ad58a496 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -524,150 +524,150 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t1322 interface{} + var _t1359 interface{} if (value != nil && hasProtoField(value, "int_value")) { return int32(value.GetIntValue()) } - _ = _t1322 + _ = _t1359 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t1323 interface{} + var _t1360 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t1323 + _ = _t1360 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t1324 interface{} + var _t1361 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t1324 + _ = _t1361 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t1325 interface{} + var _t1362 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t1325 + _ = _t1362 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t1326 interface{} + var _t1363 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t1326 + _ = _t1363 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t1327 interface{} + var _t1364 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t1327 + _ = _t1364 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t1328 interface{} + var _t1365 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t1328 + _ = _t1365 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t1329 interface{} + var _t1366 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t1329 + _ = _t1366 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t1330 interface{} + var _t1367 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t1330 + _ = _t1367 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t1331 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t1331 - _t1332 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t1332 - _t1333 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t1333 - _t1334 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t1334 - _t1335 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t1335 - _t1336 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t1336 - _t1337 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t1337 - _t1338 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t1338 - _t1339 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t1339 - _t1340 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t1340 - _t1341 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") - compression := _t1341 - _t1342 := &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} - return _t1342 + _t1368 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t1368 + _t1369 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t1369 + _t1370 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t1370 + _t1371 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t1371 + _t1372 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t1372 + _t1373 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t1373 + _t1374 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t1374 + _t1375 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t1375 + _t1376 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t1376 + _t1377 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t1377 + _t1378 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") + compression := _t1378 + _t1379 := &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} + return _t1379 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t1343 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t1343 - _t1344 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t1344 - _t1345 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t1345 - _t1346 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t1346 - _t1347 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t1347 - _t1348 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t1348 - _t1349 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t1349 - _t1350 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t1350 - _t1351 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t1351 - _t1352 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t1380 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t1380 + _t1381 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t1381 + _t1382 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t1382 + _t1383 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t1383 + _t1384 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t1384 + _t1385 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t1385 + _t1386 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t1386 + _t1387 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t1387 + _t1388 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t1388 + _t1389 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t1352.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t1389.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t1352.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t1389.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t1352 - _t1353 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t1353 + relation_locator := _t1389 + _t1390 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t1390 } func (p *Parser) default_configure() *pb.Configure { - _t1354 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t1354 - _t1355 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t1355 + _t1391 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t1391 + _t1392 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t1392 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -689,32 +689,44 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t1356 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t1356 - _t1357 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t1357 - _t1358 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t1358 + _t1393 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t1393 + _t1394 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t1394 + _t1395 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t1395 } func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t1359 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t1359 - _t1360 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t1360 - _t1361 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t1361 - _t1362 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t1362 - _t1363 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t1363 - _t1364 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t1364 - _t1365 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t1365 - _t1366 := &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 _t1366 + _t1396 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t1396 + _t1397 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t1397 + _t1398 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t1398 + _t1399 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t1399 + _t1400 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t1400 + _t1401 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t1401 + _t1402 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t1402 + _t1403 := &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 _t1403 +} + +func (p *Parser) construct_csv_column(path []string, tail []interface{}) *pb.CSVColumn { + var _t1404 interface{} + if tail != nil { + t := tail + _t1405 := &pb.CSVColumn{ColumnPath: path, TargetId: t[0].(*pb.RelationId), Types: t[1].([]*pb.Type)} + return _t1405 + } + _ = _t1404 + _t1406 := &pb.CSVColumn{ColumnPath: path, TargetId: nil, Types: []*pb.Type{}} + return _t1406 } // --- Parse functions --- @@ -722,3022 +734,3116 @@ func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, c func (p *Parser) parse_transaction() *pb.Transaction { p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t712 *pb.Configure + var _t736 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t713 := p.parse_configure() - _t712 = _t713 + _t737 := p.parse_configure() + _t736 = _t737 } - configure356 := _t712 - var _t714 *pb.Sync + configure368 := _t736 + var _t738 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t715 := p.parse_sync() - _t714 = _t715 + _t739 := p.parse_sync() + _t738 = _t739 } - sync357 := _t714 - xs358 := []*pb.Epoch{} - cond359 := p.matchLookaheadLiteral("(", 0) - for cond359 { - _t716 := p.parse_epoch() - item360 := _t716 - xs358 = append(xs358, item360) - cond359 = p.matchLookaheadLiteral("(", 0) + sync369 := _t738 + xs370 := []*pb.Epoch{} + cond371 := p.matchLookaheadLiteral("(", 0) + for cond371 { + _t740 := p.parse_epoch() + item372 := _t740 + xs370 = append(xs370, item372) + cond371 = p.matchLookaheadLiteral("(", 0) } - epochs361 := xs358 + epochs373 := xs370 p.consumeLiteral(")") - _t717 := p.default_configure() - _t718 := configure356 - if configure356 == nil { - _t718 = _t717 + _t741 := p.default_configure() + _t742 := configure368 + if configure368 == nil { + _t742 = _t741 } - _t719 := &pb.Transaction{Epochs: epochs361, Configure: _t718, Sync: sync357} - return _t719 + _t743 := &pb.Transaction{Epochs: epochs373, Configure: _t742, Sync: sync369} + return _t743 } func (p *Parser) parse_configure() *pb.Configure { p.consumeLiteral("(") p.consumeLiteral("configure") - _t720 := p.parse_config_dict() - config_dict362 := _t720 + _t744 := p.parse_config_dict() + config_dict374 := _t744 p.consumeLiteral(")") - _t721 := p.construct_configure(config_dict362) - return _t721 + _t745 := p.construct_configure(config_dict374) + return _t745 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs363 := [][]interface{}{} - cond364 := p.matchLookaheadLiteral(":", 0) - for cond364 { - _t722 := p.parse_config_key_value() - item365 := _t722 - xs363 = append(xs363, item365) - cond364 = p.matchLookaheadLiteral(":", 0) - } - config_key_values366 := xs363 + xs375 := [][]interface{}{} + cond376 := p.matchLookaheadLiteral(":", 0) + for cond376 { + _t746 := p.parse_config_key_value() + item377 := _t746 + xs375 = append(xs375, item377) + cond376 = p.matchLookaheadLiteral(":", 0) + } + config_key_values378 := xs375 p.consumeLiteral("}") - return config_key_values366 + return config_key_values378 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol367 := p.consumeTerminal("SYMBOL").Value.str - _t723 := p.parse_value() - value368 := _t723 - return []interface{}{symbol367, value368} + symbol379 := p.consumeTerminal("SYMBOL").Value.str + _t747 := p.parse_value() + value380 := _t747 + return []interface{}{symbol379, value380} } func (p *Parser) parse_value() *pb.Value { - var _t724 int64 + var _t748 int64 if p.matchLookaheadLiteral("true", 0) { - _t724 = 9 + _t748 = 9 } else { - var _t725 int64 + var _t749 int64 if p.matchLookaheadLiteral("missing", 0) { - _t725 = 8 + _t749 = 8 } else { - var _t726 int64 + var _t750 int64 if p.matchLookaheadLiteral("false", 0) { - _t726 = 9 + _t750 = 9 } else { - var _t727 int64 + var _t751 int64 if p.matchLookaheadLiteral("(", 0) { - var _t728 int64 + var _t752 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t728 = 1 + _t752 = 1 } else { - var _t729 int64 + var _t753 int64 if p.matchLookaheadLiteral("date", 1) { - _t729 = 0 + _t753 = 0 } else { - _t729 = -1 + _t753 = -1 } - _t728 = _t729 + _t752 = _t753 } - _t727 = _t728 + _t751 = _t752 } else { - var _t730 int64 + var _t754 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t730 = 5 + _t754 = 5 } else { - var _t731 int64 + var _t755 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t731 = 2 + _t755 = 2 } else { - var _t732 int64 + var _t756 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t732 = 6 + _t756 = 6 } else { - var _t733 int64 + var _t757 int64 if p.matchLookaheadTerminal("INT", 0) { - _t733 = 3 + _t757 = 3 } else { - var _t734 int64 + var _t758 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t734 = 4 + _t758 = 4 } else { - var _t735 int64 + var _t759 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t735 = 7 + _t759 = 7 } else { - _t735 = -1 + _t759 = -1 } - _t734 = _t735 + _t758 = _t759 } - _t733 = _t734 + _t757 = _t758 } - _t732 = _t733 + _t756 = _t757 } - _t731 = _t732 + _t755 = _t756 } - _t730 = _t731 + _t754 = _t755 } - _t727 = _t730 + _t751 = _t754 } - _t726 = _t727 + _t750 = _t751 } - _t725 = _t726 + _t749 = _t750 } - _t724 = _t725 - } - prediction369 := _t724 - var _t736 *pb.Value - if prediction369 == 9 { - _t737 := p.parse_boolean_value() - boolean_value378 := _t737 - _t738 := &pb.Value{} - _t738.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value378} - _t736 = _t738 + _t748 = _t749 + } + prediction381 := _t748 + var _t760 *pb.Value + if prediction381 == 9 { + _t761 := p.parse_boolean_value() + boolean_value390 := _t761 + _t762 := &pb.Value{} + _t762.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value390} + _t760 = _t762 } else { - var _t739 *pb.Value - if prediction369 == 8 { + var _t763 *pb.Value + if prediction381 == 8 { p.consumeLiteral("missing") - _t740 := &pb.MissingValue{} - _t741 := &pb.Value{} - _t741.Value = &pb.Value_MissingValue{MissingValue: _t740} - _t739 = _t741 + _t764 := &pb.MissingValue{} + _t765 := &pb.Value{} + _t765.Value = &pb.Value_MissingValue{MissingValue: _t764} + _t763 = _t765 } else { - var _t742 *pb.Value - if prediction369 == 7 { - decimal377 := p.consumeTerminal("DECIMAL").Value.decimal - _t743 := &pb.Value{} - _t743.Value = &pb.Value_DecimalValue{DecimalValue: decimal377} - _t742 = _t743 + var _t766 *pb.Value + if prediction381 == 7 { + decimal389 := p.consumeTerminal("DECIMAL").Value.decimal + _t767 := &pb.Value{} + _t767.Value = &pb.Value_DecimalValue{DecimalValue: decimal389} + _t766 = _t767 } else { - var _t744 *pb.Value - if prediction369 == 6 { - int128376 := p.consumeTerminal("INT128").Value.int128 - _t745 := &pb.Value{} - _t745.Value = &pb.Value_Int128Value{Int128Value: int128376} - _t744 = _t745 + var _t768 *pb.Value + if prediction381 == 6 { + int128388 := p.consumeTerminal("INT128").Value.int128 + _t769 := &pb.Value{} + _t769.Value = &pb.Value_Int128Value{Int128Value: int128388} + _t768 = _t769 } else { - var _t746 *pb.Value - if prediction369 == 5 { - uint128375 := p.consumeTerminal("UINT128").Value.uint128 - _t747 := &pb.Value{} - _t747.Value = &pb.Value_Uint128Value{Uint128Value: uint128375} - _t746 = _t747 + var _t770 *pb.Value + if prediction381 == 5 { + uint128387 := p.consumeTerminal("UINT128").Value.uint128 + _t771 := &pb.Value{} + _t771.Value = &pb.Value_Uint128Value{Uint128Value: uint128387} + _t770 = _t771 } else { - var _t748 *pb.Value - if prediction369 == 4 { - float374 := p.consumeTerminal("FLOAT").Value.f64 - _t749 := &pb.Value{} - _t749.Value = &pb.Value_FloatValue{FloatValue: float374} - _t748 = _t749 + var _t772 *pb.Value + if prediction381 == 4 { + float386 := p.consumeTerminal("FLOAT").Value.f64 + _t773 := &pb.Value{} + _t773.Value = &pb.Value_FloatValue{FloatValue: float386} + _t772 = _t773 } else { - var _t750 *pb.Value - if prediction369 == 3 { - int373 := p.consumeTerminal("INT").Value.i64 - _t751 := &pb.Value{} - _t751.Value = &pb.Value_IntValue{IntValue: int373} - _t750 = _t751 + var _t774 *pb.Value + if prediction381 == 3 { + int385 := p.consumeTerminal("INT").Value.i64 + _t775 := &pb.Value{} + _t775.Value = &pb.Value_IntValue{IntValue: int385} + _t774 = _t775 } else { - var _t752 *pb.Value - if prediction369 == 2 { - string372 := p.consumeTerminal("STRING").Value.str - _t753 := &pb.Value{} - _t753.Value = &pb.Value_StringValue{StringValue: string372} - _t752 = _t753 + var _t776 *pb.Value + if prediction381 == 2 { + string384 := p.consumeTerminal("STRING").Value.str + _t777 := &pb.Value{} + _t777.Value = &pb.Value_StringValue{StringValue: string384} + _t776 = _t777 } else { - var _t754 *pb.Value - if prediction369 == 1 { - _t755 := p.parse_datetime() - datetime371 := _t755 - _t756 := &pb.Value{} - _t756.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime371} - _t754 = _t756 + var _t778 *pb.Value + if prediction381 == 1 { + _t779 := p.parse_datetime() + datetime383 := _t779 + _t780 := &pb.Value{} + _t780.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime383} + _t778 = _t780 } else { - var _t757 *pb.Value - if prediction369 == 0 { - _t758 := p.parse_date() - date370 := _t758 - _t759 := &pb.Value{} - _t759.Value = &pb.Value_DateValue{DateValue: date370} - _t757 = _t759 + var _t781 *pb.Value + if prediction381 == 0 { + _t782 := p.parse_date() + date382 := _t782 + _t783 := &pb.Value{} + _t783.Value = &pb.Value_DateValue{DateValue: date382} + _t781 = _t783 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t754 = _t757 + _t778 = _t781 } - _t752 = _t754 + _t776 = _t778 } - _t750 = _t752 + _t774 = _t776 } - _t748 = _t750 + _t772 = _t774 } - _t746 = _t748 + _t770 = _t772 } - _t744 = _t746 + _t768 = _t770 } - _t742 = _t744 + _t766 = _t768 } - _t739 = _t742 + _t763 = _t766 } - _t736 = _t739 + _t760 = _t763 } - return _t736 + return _t760 } func (p *Parser) parse_date() *pb.DateValue { p.consumeLiteral("(") p.consumeLiteral("date") - int379 := p.consumeTerminal("INT").Value.i64 - int_3380 := p.consumeTerminal("INT").Value.i64 - int_4381 := p.consumeTerminal("INT").Value.i64 + int391 := p.consumeTerminal("INT").Value.i64 + int_3392 := p.consumeTerminal("INT").Value.i64 + int_4393 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t760 := &pb.DateValue{Year: int32(int379), Month: int32(int_3380), Day: int32(int_4381)} - return _t760 + _t784 := &pb.DateValue{Year: int32(int391), Month: int32(int_3392), Day: int32(int_4393)} + return _t784 } func (p *Parser) parse_datetime() *pb.DateTimeValue { p.consumeLiteral("(") p.consumeLiteral("datetime") - int382 := p.consumeTerminal("INT").Value.i64 - int_3383 := p.consumeTerminal("INT").Value.i64 - int_4384 := p.consumeTerminal("INT").Value.i64 - int_5385 := p.consumeTerminal("INT").Value.i64 - int_6386 := p.consumeTerminal("INT").Value.i64 - int_7387 := p.consumeTerminal("INT").Value.i64 - var _t761 *int64 + int394 := p.consumeTerminal("INT").Value.i64 + int_3395 := p.consumeTerminal("INT").Value.i64 + int_4396 := p.consumeTerminal("INT").Value.i64 + int_5397 := p.consumeTerminal("INT").Value.i64 + int_6398 := p.consumeTerminal("INT").Value.i64 + int_7399 := p.consumeTerminal("INT").Value.i64 + var _t785 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t761 = ptr(p.consumeTerminal("INT").Value.i64) + _t785 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8388 := _t761 + int_8400 := _t785 p.consumeLiteral(")") - _t762 := &pb.DateTimeValue{Year: int32(int382), Month: int32(int_3383), Day: int32(int_4384), Hour: int32(int_5385), Minute: int32(int_6386), Second: int32(int_7387), Microsecond: int32(deref(int_8388, 0))} - return _t762 + _t786 := &pb.DateTimeValue{Year: int32(int394), Month: int32(int_3395), Day: int32(int_4396), Hour: int32(int_5397), Minute: int32(int_6398), Second: int32(int_7399), Microsecond: int32(deref(int_8400, 0))} + return _t786 } func (p *Parser) parse_boolean_value() bool { - var _t763 int64 + var _t787 int64 if p.matchLookaheadLiteral("true", 0) { - _t763 = 0 + _t787 = 0 } else { - var _t764 int64 + var _t788 int64 if p.matchLookaheadLiteral("false", 0) { - _t764 = 1 + _t788 = 1 } else { - _t764 = -1 + _t788 = -1 } - _t763 = _t764 + _t787 = _t788 } - prediction389 := _t763 - var _t765 bool - if prediction389 == 1 { + prediction401 := _t787 + var _t789 bool + if prediction401 == 1 { p.consumeLiteral("false") - _t765 = false + _t789 = false } else { - var _t766 bool - if prediction389 == 0 { + var _t790 bool + if prediction401 == 0 { p.consumeLiteral("true") - _t766 = true + _t790 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t765 = _t766 + _t789 = _t790 } - return _t765 + return _t789 } func (p *Parser) parse_sync() *pb.Sync { p.consumeLiteral("(") p.consumeLiteral("sync") - xs390 := []*pb.FragmentId{} - cond391 := p.matchLookaheadLiteral(":", 0) - for cond391 { - _t767 := p.parse_fragment_id() - item392 := _t767 - xs390 = append(xs390, item392) - cond391 = p.matchLookaheadLiteral(":", 0) + xs402 := []*pb.FragmentId{} + cond403 := p.matchLookaheadLiteral(":", 0) + for cond403 { + _t791 := p.parse_fragment_id() + item404 := _t791 + xs402 = append(xs402, item404) + cond403 = p.matchLookaheadLiteral(":", 0) } - fragment_ids393 := xs390 + fragment_ids405 := xs402 p.consumeLiteral(")") - _t768 := &pb.Sync{Fragments: fragment_ids393} - return _t768 + _t792 := &pb.Sync{Fragments: fragment_ids405} + return _t792 } func (p *Parser) parse_fragment_id() *pb.FragmentId { p.consumeLiteral(":") - symbol394 := p.consumeTerminal("SYMBOL").Value.str - return &pb.FragmentId{Id: []byte(symbol394)} + symbol406 := p.consumeTerminal("SYMBOL").Value.str + return &pb.FragmentId{Id: []byte(symbol406)} } func (p *Parser) parse_epoch() *pb.Epoch { p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t769 []*pb.Write + var _t793 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t770 := p.parse_epoch_writes() - _t769 = _t770 + _t794 := p.parse_epoch_writes() + _t793 = _t794 } - epoch_writes395 := _t769 - var _t771 []*pb.Read + epoch_writes407 := _t793 + var _t795 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t772 := p.parse_epoch_reads() - _t771 = _t772 + _t796 := p.parse_epoch_reads() + _t795 = _t796 } - epoch_reads396 := _t771 + epoch_reads408 := _t795 p.consumeLiteral(")") - _t773 := epoch_writes395 - if epoch_writes395 == nil { - _t773 = []*pb.Write{} + _t797 := epoch_writes407 + if epoch_writes407 == nil { + _t797 = []*pb.Write{} } - _t774 := epoch_reads396 - if epoch_reads396 == nil { - _t774 = []*pb.Read{} + _t798 := epoch_reads408 + if epoch_reads408 == nil { + _t798 = []*pb.Read{} } - _t775 := &pb.Epoch{Writes: _t773, Reads: _t774} - return _t775 + _t799 := &pb.Epoch{Writes: _t797, Reads: _t798} + return _t799 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs397 := []*pb.Write{} - cond398 := p.matchLookaheadLiteral("(", 0) - for cond398 { - _t776 := p.parse_write() - item399 := _t776 - xs397 = append(xs397, item399) - cond398 = p.matchLookaheadLiteral("(", 0) + xs409 := []*pb.Write{} + cond410 := p.matchLookaheadLiteral("(", 0) + for cond410 { + _t800 := p.parse_write() + item411 := _t800 + xs409 = append(xs409, item411) + cond410 = p.matchLookaheadLiteral("(", 0) } - writes400 := xs397 + writes412 := xs409 p.consumeLiteral(")") - return writes400 + return writes412 } func (p *Parser) parse_write() *pb.Write { - var _t777 int64 + var _t801 int64 if p.matchLookaheadLiteral("(", 0) { - var _t778 int64 + var _t802 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t778 = 1 + _t802 = 1 } else { - var _t779 int64 + var _t803 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t779 = 3 + _t803 = 3 } else { - var _t780 int64 + var _t804 int64 if p.matchLookaheadLiteral("define", 1) { - _t780 = 0 + _t804 = 0 } else { - var _t781 int64 + var _t805 int64 if p.matchLookaheadLiteral("context", 1) { - _t781 = 2 + _t805 = 2 } else { - _t781 = -1 + _t805 = -1 } - _t780 = _t781 + _t804 = _t805 } - _t779 = _t780 + _t803 = _t804 } - _t778 = _t779 + _t802 = _t803 } - _t777 = _t778 + _t801 = _t802 } else { - _t777 = -1 - } - prediction401 := _t777 - var _t782 *pb.Write - if prediction401 == 3 { - _t783 := p.parse_snapshot() - snapshot405 := _t783 - _t784 := &pb.Write{} - _t784.WriteType = &pb.Write_Snapshot{Snapshot: snapshot405} - _t782 = _t784 + _t801 = -1 + } + prediction413 := _t801 + var _t806 *pb.Write + if prediction413 == 3 { + _t807 := p.parse_snapshot() + snapshot417 := _t807 + _t808 := &pb.Write{} + _t808.WriteType = &pb.Write_Snapshot{Snapshot: snapshot417} + _t806 = _t808 } else { - var _t785 *pb.Write - if prediction401 == 2 { - _t786 := p.parse_context() - context404 := _t786 - _t787 := &pb.Write{} - _t787.WriteType = &pb.Write_Context{Context: context404} - _t785 = _t787 + var _t809 *pb.Write + if prediction413 == 2 { + _t810 := p.parse_context() + context416 := _t810 + _t811 := &pb.Write{} + _t811.WriteType = &pb.Write_Context{Context: context416} + _t809 = _t811 } else { - var _t788 *pb.Write - if prediction401 == 1 { - _t789 := p.parse_undefine() - undefine403 := _t789 - _t790 := &pb.Write{} - _t790.WriteType = &pb.Write_Undefine{Undefine: undefine403} - _t788 = _t790 + var _t812 *pb.Write + if prediction413 == 1 { + _t813 := p.parse_undefine() + undefine415 := _t813 + _t814 := &pb.Write{} + _t814.WriteType = &pb.Write_Undefine{Undefine: undefine415} + _t812 = _t814 } else { - var _t791 *pb.Write - if prediction401 == 0 { - _t792 := p.parse_define() - define402 := _t792 - _t793 := &pb.Write{} - _t793.WriteType = &pb.Write_Define{Define: define402} - _t791 = _t793 + var _t815 *pb.Write + if prediction413 == 0 { + _t816 := p.parse_define() + define414 := _t816 + _t817 := &pb.Write{} + _t817.WriteType = &pb.Write_Define{Define: define414} + _t815 = _t817 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t788 = _t791 + _t812 = _t815 } - _t785 = _t788 + _t809 = _t812 } - _t782 = _t785 + _t806 = _t809 } - return _t782 + return _t806 } func (p *Parser) parse_define() *pb.Define { p.consumeLiteral("(") p.consumeLiteral("define") - _t794 := p.parse_fragment() - fragment406 := _t794 + _t818 := p.parse_fragment() + fragment418 := _t818 p.consumeLiteral(")") - _t795 := &pb.Define{Fragment: fragment406} - return _t795 + _t819 := &pb.Define{Fragment: fragment418} + return _t819 } func (p *Parser) parse_fragment() *pb.Fragment { p.consumeLiteral("(") p.consumeLiteral("fragment") - _t796 := p.parse_new_fragment_id() - new_fragment_id407 := _t796 - xs408 := []*pb.Declaration{} - cond409 := p.matchLookaheadLiteral("(", 0) - for cond409 { - _t797 := p.parse_declaration() - item410 := _t797 - xs408 = append(xs408, item410) - cond409 = p.matchLookaheadLiteral("(", 0) + _t820 := p.parse_new_fragment_id() + new_fragment_id419 := _t820 + xs420 := []*pb.Declaration{} + cond421 := p.matchLookaheadLiteral("(", 0) + for cond421 { + _t821 := p.parse_declaration() + item422 := _t821 + xs420 = append(xs420, item422) + cond421 = p.matchLookaheadLiteral("(", 0) } - declarations411 := xs408 + declarations423 := xs420 p.consumeLiteral(")") - return p.constructFragment(new_fragment_id407, declarations411) + return p.constructFragment(new_fragment_id419, declarations423) } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - _t798 := p.parse_fragment_id() - fragment_id412 := _t798 - p.startFragment(fragment_id412) - return fragment_id412 + _t822 := p.parse_fragment_id() + fragment_id424 := _t822 + p.startFragment(fragment_id424) + return fragment_id424 } func (p *Parser) parse_declaration() *pb.Declaration { - var _t799 int64 + var _t823 int64 if p.matchLookaheadLiteral("(", 0) { - var _t800 int64 + var _t824 int64 if p.matchLookaheadLiteral("rel_edb", 1) { - _t800 = 3 + _t824 = 3 } else { - var _t801 int64 + var _t825 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t801 = 2 + _t825 = 2 } else { - var _t802 int64 + var _t826 int64 if p.matchLookaheadLiteral("def", 1) { - _t802 = 0 + _t826 = 0 } else { - var _t803 int64 + var _t827 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t803 = 3 + _t827 = 3 } else { - var _t804 int64 + var _t828 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t804 = 3 + _t828 = 3 } else { - var _t805 int64 + var _t829 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t805 = 1 + _t829 = 1 } else { - _t805 = -1 + _t829 = -1 } - _t804 = _t805 + _t828 = _t829 } - _t803 = _t804 + _t827 = _t828 } - _t802 = _t803 + _t826 = _t827 } - _t801 = _t802 + _t825 = _t826 } - _t800 = _t801 + _t824 = _t825 } - _t799 = _t800 + _t823 = _t824 } else { - _t799 = -1 - } - prediction413 := _t799 - var _t806 *pb.Declaration - if prediction413 == 3 { - _t807 := p.parse_data() - data417 := _t807 - _t808 := &pb.Declaration{} - _t808.DeclarationType = &pb.Declaration_Data{Data: data417} - _t806 = _t808 + _t823 = -1 + } + prediction425 := _t823 + var _t830 *pb.Declaration + if prediction425 == 3 { + _t831 := p.parse_data() + data429 := _t831 + _t832 := &pb.Declaration{} + _t832.DeclarationType = &pb.Declaration_Data{Data: data429} + _t830 = _t832 } else { - var _t809 *pb.Declaration - if prediction413 == 2 { - _t810 := p.parse_constraint() - constraint416 := _t810 - _t811 := &pb.Declaration{} - _t811.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint416} - _t809 = _t811 + var _t833 *pb.Declaration + if prediction425 == 2 { + _t834 := p.parse_constraint() + constraint428 := _t834 + _t835 := &pb.Declaration{} + _t835.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint428} + _t833 = _t835 } else { - var _t812 *pb.Declaration - if prediction413 == 1 { - _t813 := p.parse_algorithm() - algorithm415 := _t813 - _t814 := &pb.Declaration{} - _t814.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm415} - _t812 = _t814 + var _t836 *pb.Declaration + if prediction425 == 1 { + _t837 := p.parse_algorithm() + algorithm427 := _t837 + _t838 := &pb.Declaration{} + _t838.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm427} + _t836 = _t838 } else { - var _t815 *pb.Declaration - if prediction413 == 0 { - _t816 := p.parse_def() - def414 := _t816 - _t817 := &pb.Declaration{} - _t817.DeclarationType = &pb.Declaration_Def{Def: def414} - _t815 = _t817 + var _t839 *pb.Declaration + if prediction425 == 0 { + _t840 := p.parse_def() + def426 := _t840 + _t841 := &pb.Declaration{} + _t841.DeclarationType = &pb.Declaration_Def{Def: def426} + _t839 = _t841 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t812 = _t815 + _t836 = _t839 } - _t809 = _t812 + _t833 = _t836 } - _t806 = _t809 + _t830 = _t833 } - return _t806 + return _t830 } func (p *Parser) parse_def() *pb.Def { p.consumeLiteral("(") p.consumeLiteral("def") - _t818 := p.parse_relation_id() - relation_id418 := _t818 - _t819 := p.parse_abstraction() - abstraction419 := _t819 - var _t820 []*pb.Attribute + _t842 := p.parse_relation_id() + relation_id430 := _t842 + _t843 := p.parse_abstraction() + abstraction431 := _t843 + var _t844 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t821 := p.parse_attrs() - _t820 = _t821 + _t845 := p.parse_attrs() + _t844 = _t845 } - attrs420 := _t820 + attrs432 := _t844 p.consumeLiteral(")") - _t822 := attrs420 - if attrs420 == nil { - _t822 = []*pb.Attribute{} + _t846 := attrs432 + if attrs432 == nil { + _t846 = []*pb.Attribute{} } - _t823 := &pb.Def{Name: relation_id418, Body: abstraction419, Attrs: _t822} - return _t823 + _t847 := &pb.Def{Name: relation_id430, Body: abstraction431, Attrs: _t846} + return _t847 } func (p *Parser) parse_relation_id() *pb.RelationId { - var _t824 int64 + var _t848 int64 if p.matchLookaheadLiteral(":", 0) { - _t824 = 0 + _t848 = 0 } else { - var _t825 int64 + var _t849 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t825 = 1 + _t849 = 1 } else { - _t825 = -1 + _t849 = -1 } - _t824 = _t825 - } - prediction421 := _t824 - var _t826 *pb.RelationId - if prediction421 == 1 { - uint128423 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128423 - _t826 = &pb.RelationId{IdLow: uint128423.Low, IdHigh: uint128423.High} + _t848 = _t849 + } + prediction433 := _t848 + var _t850 *pb.RelationId + if prediction433 == 1 { + uint128435 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128435 + _t850 = &pb.RelationId{IdLow: uint128435.Low, IdHigh: uint128435.High} } else { - var _t827 *pb.RelationId - if prediction421 == 0 { + var _t851 *pb.RelationId + if prediction433 == 0 { p.consumeLiteral(":") - symbol422 := p.consumeTerminal("SYMBOL").Value.str - _t827 = p.relationIdFromString(symbol422) + symbol434 := p.consumeTerminal("SYMBOL").Value.str + _t851 = p.relationIdFromString(symbol434) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t826 = _t827 + _t850 = _t851 } - return _t826 + return _t850 } func (p *Parser) parse_abstraction() *pb.Abstraction { p.consumeLiteral("(") - _t828 := p.parse_bindings() - bindings424 := _t828 - _t829 := p.parse_formula() - formula425 := _t829 + _t852 := p.parse_bindings() + bindings436 := _t852 + _t853 := p.parse_formula() + formula437 := _t853 p.consumeLiteral(")") - _t830 := &pb.Abstraction{Vars: listConcat(bindings424[0].([]*pb.Binding), bindings424[1].([]*pb.Binding)), Value: formula425} - return _t830 + _t854 := &pb.Abstraction{Vars: listConcat(bindings436[0].([]*pb.Binding), bindings436[1].([]*pb.Binding)), Value: formula437} + return _t854 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs426 := []*pb.Binding{} - cond427 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond427 { - _t831 := p.parse_binding() - item428 := _t831 - xs426 = append(xs426, item428) - cond427 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings429 := xs426 - var _t832 []*pb.Binding + xs438 := []*pb.Binding{} + cond439 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond439 { + _t855 := p.parse_binding() + item440 := _t855 + xs438 = append(xs438, item440) + cond439 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings441 := xs438 + var _t856 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t833 := p.parse_value_bindings() - _t832 = _t833 + _t857 := p.parse_value_bindings() + _t856 = _t857 } - value_bindings430 := _t832 + value_bindings442 := _t856 p.consumeLiteral("]") - _t834 := value_bindings430 - if value_bindings430 == nil { - _t834 = []*pb.Binding{} + _t858 := value_bindings442 + if value_bindings442 == nil { + _t858 = []*pb.Binding{} } - return []interface{}{bindings429, _t834} + return []interface{}{bindings441, _t858} } func (p *Parser) parse_binding() *pb.Binding { - symbol431 := p.consumeTerminal("SYMBOL").Value.str + symbol443 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t835 := p.parse_type() - type432 := _t835 - _t836 := &pb.Var{Name: symbol431} - _t837 := &pb.Binding{Var: _t836, Type: type432} - return _t837 + _t859 := p.parse_type() + type444 := _t859 + _t860 := &pb.Var{Name: symbol443} + _t861 := &pb.Binding{Var: _t860, Type: type444} + return _t861 } func (p *Parser) parse_type() *pb.Type { - var _t838 int64 + var _t862 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t838 = 0 + _t862 = 0 } else { - var _t839 int64 + var _t863 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t839 = 4 + _t863 = 4 } else { - var _t840 int64 + var _t864 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t840 = 1 + _t864 = 1 } else { - var _t841 int64 + var _t865 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t841 = 8 + _t865 = 8 } else { - var _t842 int64 + var _t866 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t842 = 5 + _t866 = 5 } else { - var _t843 int64 + var _t867 int64 if p.matchLookaheadLiteral("INT", 0) { - _t843 = 2 + _t867 = 2 } else { - var _t844 int64 + var _t868 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t844 = 3 + _t868 = 3 } else { - var _t845 int64 + var _t869 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t845 = 7 + _t869 = 7 } else { - var _t846 int64 + var _t870 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t846 = 6 + _t870 = 6 } else { - var _t847 int64 + var _t871 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t847 = 10 + _t871 = 10 } else { - var _t848 int64 + var _t872 int64 if p.matchLookaheadLiteral("(", 0) { - _t848 = 9 + _t872 = 9 } else { - _t848 = -1 + _t872 = -1 } - _t847 = _t848 + _t871 = _t872 } - _t846 = _t847 + _t870 = _t871 } - _t845 = _t846 + _t869 = _t870 } - _t844 = _t845 + _t868 = _t869 } - _t843 = _t844 + _t867 = _t868 } - _t842 = _t843 + _t866 = _t867 } - _t841 = _t842 + _t865 = _t866 } - _t840 = _t841 + _t864 = _t865 } - _t839 = _t840 + _t863 = _t864 } - _t838 = _t839 - } - prediction433 := _t838 - var _t849 *pb.Type - if prediction433 == 10 { - _t850 := p.parse_boolean_type() - boolean_type444 := _t850 - _t851 := &pb.Type{} - _t851.Type = &pb.Type_BooleanType{BooleanType: boolean_type444} - _t849 = _t851 + _t862 = _t863 + } + prediction445 := _t862 + var _t873 *pb.Type + if prediction445 == 10 { + _t874 := p.parse_boolean_type() + boolean_type456 := _t874 + _t875 := &pb.Type{} + _t875.Type = &pb.Type_BooleanType{BooleanType: boolean_type456} + _t873 = _t875 } else { - var _t852 *pb.Type - if prediction433 == 9 { - _t853 := p.parse_decimal_type() - decimal_type443 := _t853 - _t854 := &pb.Type{} - _t854.Type = &pb.Type_DecimalType{DecimalType: decimal_type443} - _t852 = _t854 + var _t876 *pb.Type + if prediction445 == 9 { + _t877 := p.parse_decimal_type() + decimal_type455 := _t877 + _t878 := &pb.Type{} + _t878.Type = &pb.Type_DecimalType{DecimalType: decimal_type455} + _t876 = _t878 } else { - var _t855 *pb.Type - if prediction433 == 8 { - _t856 := p.parse_missing_type() - missing_type442 := _t856 - _t857 := &pb.Type{} - _t857.Type = &pb.Type_MissingType{MissingType: missing_type442} - _t855 = _t857 + var _t879 *pb.Type + if prediction445 == 8 { + _t880 := p.parse_missing_type() + missing_type454 := _t880 + _t881 := &pb.Type{} + _t881.Type = &pb.Type_MissingType{MissingType: missing_type454} + _t879 = _t881 } else { - var _t858 *pb.Type - if prediction433 == 7 { - _t859 := p.parse_datetime_type() - datetime_type441 := _t859 - _t860 := &pb.Type{} - _t860.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type441} - _t858 = _t860 + var _t882 *pb.Type + if prediction445 == 7 { + _t883 := p.parse_datetime_type() + datetime_type453 := _t883 + _t884 := &pb.Type{} + _t884.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type453} + _t882 = _t884 } else { - var _t861 *pb.Type - if prediction433 == 6 { - _t862 := p.parse_date_type() - date_type440 := _t862 - _t863 := &pb.Type{} - _t863.Type = &pb.Type_DateType{DateType: date_type440} - _t861 = _t863 + var _t885 *pb.Type + if prediction445 == 6 { + _t886 := p.parse_date_type() + date_type452 := _t886 + _t887 := &pb.Type{} + _t887.Type = &pb.Type_DateType{DateType: date_type452} + _t885 = _t887 } else { - var _t864 *pb.Type - if prediction433 == 5 { - _t865 := p.parse_int128_type() - int128_type439 := _t865 - _t866 := &pb.Type{} - _t866.Type = &pb.Type_Int128Type{Int128Type: int128_type439} - _t864 = _t866 + var _t888 *pb.Type + if prediction445 == 5 { + _t889 := p.parse_int128_type() + int128_type451 := _t889 + _t890 := &pb.Type{} + _t890.Type = &pb.Type_Int128Type{Int128Type: int128_type451} + _t888 = _t890 } else { - var _t867 *pb.Type - if prediction433 == 4 { - _t868 := p.parse_uint128_type() - uint128_type438 := _t868 - _t869 := &pb.Type{} - _t869.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type438} - _t867 = _t869 + var _t891 *pb.Type + if prediction445 == 4 { + _t892 := p.parse_uint128_type() + uint128_type450 := _t892 + _t893 := &pb.Type{} + _t893.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type450} + _t891 = _t893 } else { - var _t870 *pb.Type - if prediction433 == 3 { - _t871 := p.parse_float_type() - float_type437 := _t871 - _t872 := &pb.Type{} - _t872.Type = &pb.Type_FloatType{FloatType: float_type437} - _t870 = _t872 + var _t894 *pb.Type + if prediction445 == 3 { + _t895 := p.parse_float_type() + float_type449 := _t895 + _t896 := &pb.Type{} + _t896.Type = &pb.Type_FloatType{FloatType: float_type449} + _t894 = _t896 } else { - var _t873 *pb.Type - if prediction433 == 2 { - _t874 := p.parse_int_type() - int_type436 := _t874 - _t875 := &pb.Type{} - _t875.Type = &pb.Type_IntType{IntType: int_type436} - _t873 = _t875 + var _t897 *pb.Type + if prediction445 == 2 { + _t898 := p.parse_int_type() + int_type448 := _t898 + _t899 := &pb.Type{} + _t899.Type = &pb.Type_IntType{IntType: int_type448} + _t897 = _t899 } else { - var _t876 *pb.Type - if prediction433 == 1 { - _t877 := p.parse_string_type() - string_type435 := _t877 - _t878 := &pb.Type{} - _t878.Type = &pb.Type_StringType{StringType: string_type435} - _t876 = _t878 + var _t900 *pb.Type + if prediction445 == 1 { + _t901 := p.parse_string_type() + string_type447 := _t901 + _t902 := &pb.Type{} + _t902.Type = &pb.Type_StringType{StringType: string_type447} + _t900 = _t902 } else { - var _t879 *pb.Type - if prediction433 == 0 { - _t880 := p.parse_unspecified_type() - unspecified_type434 := _t880 - _t881 := &pb.Type{} - _t881.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type434} - _t879 = _t881 + var _t903 *pb.Type + if prediction445 == 0 { + _t904 := p.parse_unspecified_type() + unspecified_type446 := _t904 + _t905 := &pb.Type{} + _t905.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type446} + _t903 = _t905 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t876 = _t879 + _t900 = _t903 } - _t873 = _t876 + _t897 = _t900 } - _t870 = _t873 + _t894 = _t897 } - _t867 = _t870 + _t891 = _t894 } - _t864 = _t867 + _t888 = _t891 } - _t861 = _t864 + _t885 = _t888 } - _t858 = _t861 + _t882 = _t885 } - _t855 = _t858 + _t879 = _t882 } - _t852 = _t855 + _t876 = _t879 } - _t849 = _t852 + _t873 = _t876 } - return _t849 + return _t873 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { p.consumeLiteral("UNKNOWN") - _t882 := &pb.UnspecifiedType{} - return _t882 + _t906 := &pb.UnspecifiedType{} + return _t906 } func (p *Parser) parse_string_type() *pb.StringType { p.consumeLiteral("STRING") - _t883 := &pb.StringType{} - return _t883 + _t907 := &pb.StringType{} + return _t907 } func (p *Parser) parse_int_type() *pb.IntType { p.consumeLiteral("INT") - _t884 := &pb.IntType{} - return _t884 + _t908 := &pb.IntType{} + return _t908 } func (p *Parser) parse_float_type() *pb.FloatType { p.consumeLiteral("FLOAT") - _t885 := &pb.FloatType{} - return _t885 + _t909 := &pb.FloatType{} + return _t909 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { p.consumeLiteral("UINT128") - _t886 := &pb.UInt128Type{} - return _t886 + _t910 := &pb.UInt128Type{} + return _t910 } func (p *Parser) parse_int128_type() *pb.Int128Type { p.consumeLiteral("INT128") - _t887 := &pb.Int128Type{} - return _t887 + _t911 := &pb.Int128Type{} + return _t911 } func (p *Parser) parse_date_type() *pb.DateType { p.consumeLiteral("DATE") - _t888 := &pb.DateType{} - return _t888 + _t912 := &pb.DateType{} + return _t912 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { p.consumeLiteral("DATETIME") - _t889 := &pb.DateTimeType{} - return _t889 + _t913 := &pb.DateTimeType{} + return _t913 } func (p *Parser) parse_missing_type() *pb.MissingType { p.consumeLiteral("MISSING") - _t890 := &pb.MissingType{} - return _t890 + _t914 := &pb.MissingType{} + return _t914 } func (p *Parser) parse_decimal_type() *pb.DecimalType { p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int445 := p.consumeTerminal("INT").Value.i64 - int_3446 := p.consumeTerminal("INT").Value.i64 + int457 := p.consumeTerminal("INT").Value.i64 + int_3458 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t891 := &pb.DecimalType{Precision: int32(int445), Scale: int32(int_3446)} - return _t891 + _t915 := &pb.DecimalType{Precision: int32(int457), Scale: int32(int_3458)} + return _t915 } func (p *Parser) parse_boolean_type() *pb.BooleanType { p.consumeLiteral("BOOLEAN") - _t892 := &pb.BooleanType{} - return _t892 + _t916 := &pb.BooleanType{} + return _t916 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs447 := []*pb.Binding{} - cond448 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond448 { - _t893 := p.parse_binding() - item449 := _t893 - xs447 = append(xs447, item449) - cond448 = p.matchLookaheadTerminal("SYMBOL", 0) + xs459 := []*pb.Binding{} + cond460 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond460 { + _t917 := p.parse_binding() + item461 := _t917 + xs459 = append(xs459, item461) + cond460 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings450 := xs447 - return bindings450 + bindings462 := xs459 + return bindings462 } func (p *Parser) parse_formula() *pb.Formula { - var _t894 int64 + var _t918 int64 if p.matchLookaheadLiteral("(", 0) { - var _t895 int64 + var _t919 int64 if p.matchLookaheadLiteral("true", 1) { - _t895 = 0 + _t919 = 0 } else { - var _t896 int64 + var _t920 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t896 = 11 + _t920 = 11 } else { - var _t897 int64 + var _t921 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t897 = 3 + _t921 = 3 } else { - var _t898 int64 + var _t922 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t898 = 10 + _t922 = 10 } else { - var _t899 int64 + var _t923 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t899 = 9 + _t923 = 9 } else { - var _t900 int64 + var _t924 int64 if p.matchLookaheadLiteral("or", 1) { - _t900 = 5 + _t924 = 5 } else { - var _t901 int64 + var _t925 int64 if p.matchLookaheadLiteral("not", 1) { - _t901 = 6 + _t925 = 6 } else { - var _t902 int64 + var _t926 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t902 = 7 + _t926 = 7 } else { - var _t903 int64 + var _t927 int64 if p.matchLookaheadLiteral("false", 1) { - _t903 = 1 + _t927 = 1 } else { - var _t904 int64 + var _t928 int64 if p.matchLookaheadLiteral("exists", 1) { - _t904 = 2 + _t928 = 2 } else { - var _t905 int64 + var _t929 int64 if p.matchLookaheadLiteral("cast", 1) { - _t905 = 12 + _t929 = 12 } else { - var _t906 int64 + var _t930 int64 if p.matchLookaheadLiteral("atom", 1) { - _t906 = 8 + _t930 = 8 } else { - var _t907 int64 + var _t931 int64 if p.matchLookaheadLiteral("and", 1) { - _t907 = 4 + _t931 = 4 } else { - var _t908 int64 + var _t932 int64 if p.matchLookaheadLiteral(">=", 1) { - _t908 = 10 + _t932 = 10 } else { - var _t909 int64 + var _t933 int64 if p.matchLookaheadLiteral(">", 1) { - _t909 = 10 + _t933 = 10 } else { - var _t910 int64 + var _t934 int64 if p.matchLookaheadLiteral("=", 1) { - _t910 = 10 + _t934 = 10 } else { - var _t911 int64 + var _t935 int64 if p.matchLookaheadLiteral("<=", 1) { - _t911 = 10 + _t935 = 10 } else { - var _t912 int64 + var _t936 int64 if p.matchLookaheadLiteral("<", 1) { - _t912 = 10 + _t936 = 10 } else { - var _t913 int64 + var _t937 int64 if p.matchLookaheadLiteral("/", 1) { - _t913 = 10 + _t937 = 10 } else { - var _t914 int64 + var _t938 int64 if p.matchLookaheadLiteral("-", 1) { - _t914 = 10 + _t938 = 10 } else { - var _t915 int64 + var _t939 int64 if p.matchLookaheadLiteral("+", 1) { - _t915 = 10 + _t939 = 10 } else { - var _t916 int64 + var _t940 int64 if p.matchLookaheadLiteral("*", 1) { - _t916 = 10 + _t940 = 10 } else { - _t916 = -1 + _t940 = -1 } - _t915 = _t916 + _t939 = _t940 } - _t914 = _t915 + _t938 = _t939 } - _t913 = _t914 + _t937 = _t938 } - _t912 = _t913 + _t936 = _t937 } - _t911 = _t912 + _t935 = _t936 } - _t910 = _t911 + _t934 = _t935 } - _t909 = _t910 + _t933 = _t934 } - _t908 = _t909 + _t932 = _t933 } - _t907 = _t908 + _t931 = _t932 } - _t906 = _t907 + _t930 = _t931 } - _t905 = _t906 + _t929 = _t930 } - _t904 = _t905 + _t928 = _t929 } - _t903 = _t904 + _t927 = _t928 } - _t902 = _t903 + _t926 = _t927 } - _t901 = _t902 + _t925 = _t926 } - _t900 = _t901 + _t924 = _t925 } - _t899 = _t900 + _t923 = _t924 } - _t898 = _t899 + _t922 = _t923 } - _t897 = _t898 + _t921 = _t922 } - _t896 = _t897 + _t920 = _t921 } - _t895 = _t896 + _t919 = _t920 } - _t894 = _t895 + _t918 = _t919 } else { - _t894 = -1 - } - prediction451 := _t894 - var _t917 *pb.Formula - if prediction451 == 12 { - _t918 := p.parse_cast() - cast464 := _t918 - _t919 := &pb.Formula{} - _t919.FormulaType = &pb.Formula_Cast{Cast: cast464} - _t917 = _t919 + _t918 = -1 + } + prediction463 := _t918 + var _t941 *pb.Formula + if prediction463 == 12 { + _t942 := p.parse_cast() + cast476 := _t942 + _t943 := &pb.Formula{} + _t943.FormulaType = &pb.Formula_Cast{Cast: cast476} + _t941 = _t943 } else { - var _t920 *pb.Formula - if prediction451 == 11 { - _t921 := p.parse_rel_atom() - rel_atom463 := _t921 - _t922 := &pb.Formula{} - _t922.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom463} - _t920 = _t922 + var _t944 *pb.Formula + if prediction463 == 11 { + _t945 := p.parse_rel_atom() + rel_atom475 := _t945 + _t946 := &pb.Formula{} + _t946.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom475} + _t944 = _t946 } else { - var _t923 *pb.Formula - if prediction451 == 10 { - _t924 := p.parse_primitive() - primitive462 := _t924 - _t925 := &pb.Formula{} - _t925.FormulaType = &pb.Formula_Primitive{Primitive: primitive462} - _t923 = _t925 + var _t947 *pb.Formula + if prediction463 == 10 { + _t948 := p.parse_primitive() + primitive474 := _t948 + _t949 := &pb.Formula{} + _t949.FormulaType = &pb.Formula_Primitive{Primitive: primitive474} + _t947 = _t949 } else { - var _t926 *pb.Formula - if prediction451 == 9 { - _t927 := p.parse_pragma() - pragma461 := _t927 - _t928 := &pb.Formula{} - _t928.FormulaType = &pb.Formula_Pragma{Pragma: pragma461} - _t926 = _t928 + var _t950 *pb.Formula + if prediction463 == 9 { + _t951 := p.parse_pragma() + pragma473 := _t951 + _t952 := &pb.Formula{} + _t952.FormulaType = &pb.Formula_Pragma{Pragma: pragma473} + _t950 = _t952 } else { - var _t929 *pb.Formula - if prediction451 == 8 { - _t930 := p.parse_atom() - atom460 := _t930 - _t931 := &pb.Formula{} - _t931.FormulaType = &pb.Formula_Atom{Atom: atom460} - _t929 = _t931 + var _t953 *pb.Formula + if prediction463 == 8 { + _t954 := p.parse_atom() + atom472 := _t954 + _t955 := &pb.Formula{} + _t955.FormulaType = &pb.Formula_Atom{Atom: atom472} + _t953 = _t955 } else { - var _t932 *pb.Formula - if prediction451 == 7 { - _t933 := p.parse_ffi() - ffi459 := _t933 - _t934 := &pb.Formula{} - _t934.FormulaType = &pb.Formula_Ffi{Ffi: ffi459} - _t932 = _t934 + var _t956 *pb.Formula + if prediction463 == 7 { + _t957 := p.parse_ffi() + ffi471 := _t957 + _t958 := &pb.Formula{} + _t958.FormulaType = &pb.Formula_Ffi{Ffi: ffi471} + _t956 = _t958 } else { - var _t935 *pb.Formula - if prediction451 == 6 { - _t936 := p.parse_not() - not458 := _t936 - _t937 := &pb.Formula{} - _t937.FormulaType = &pb.Formula_Not{Not: not458} - _t935 = _t937 + var _t959 *pb.Formula + if prediction463 == 6 { + _t960 := p.parse_not() + not470 := _t960 + _t961 := &pb.Formula{} + _t961.FormulaType = &pb.Formula_Not{Not: not470} + _t959 = _t961 } else { - var _t938 *pb.Formula - if prediction451 == 5 { - _t939 := p.parse_disjunction() - disjunction457 := _t939 - _t940 := &pb.Formula{} - _t940.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction457} - _t938 = _t940 + var _t962 *pb.Formula + if prediction463 == 5 { + _t963 := p.parse_disjunction() + disjunction469 := _t963 + _t964 := &pb.Formula{} + _t964.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction469} + _t962 = _t964 } else { - var _t941 *pb.Formula - if prediction451 == 4 { - _t942 := p.parse_conjunction() - conjunction456 := _t942 - _t943 := &pb.Formula{} - _t943.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction456} - _t941 = _t943 + var _t965 *pb.Formula + if prediction463 == 4 { + _t966 := p.parse_conjunction() + conjunction468 := _t966 + _t967 := &pb.Formula{} + _t967.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction468} + _t965 = _t967 } else { - var _t944 *pb.Formula - if prediction451 == 3 { - _t945 := p.parse_reduce() - reduce455 := _t945 - _t946 := &pb.Formula{} - _t946.FormulaType = &pb.Formula_Reduce{Reduce: reduce455} - _t944 = _t946 + var _t968 *pb.Formula + if prediction463 == 3 { + _t969 := p.parse_reduce() + reduce467 := _t969 + _t970 := &pb.Formula{} + _t970.FormulaType = &pb.Formula_Reduce{Reduce: reduce467} + _t968 = _t970 } else { - var _t947 *pb.Formula - if prediction451 == 2 { - _t948 := p.parse_exists() - exists454 := _t948 - _t949 := &pb.Formula{} - _t949.FormulaType = &pb.Formula_Exists{Exists: exists454} - _t947 = _t949 + var _t971 *pb.Formula + if prediction463 == 2 { + _t972 := p.parse_exists() + exists466 := _t972 + _t973 := &pb.Formula{} + _t973.FormulaType = &pb.Formula_Exists{Exists: exists466} + _t971 = _t973 } else { - var _t950 *pb.Formula - if prediction451 == 1 { - _t951 := p.parse_false() - false453 := _t951 - _t952 := &pb.Formula{} - _t952.FormulaType = &pb.Formula_Disjunction{Disjunction: false453} - _t950 = _t952 + var _t974 *pb.Formula + if prediction463 == 1 { + _t975 := p.parse_false() + false465 := _t975 + _t976 := &pb.Formula{} + _t976.FormulaType = &pb.Formula_Disjunction{Disjunction: false465} + _t974 = _t976 } else { - var _t953 *pb.Formula - if prediction451 == 0 { - _t954 := p.parse_true() - true452 := _t954 - _t955 := &pb.Formula{} - _t955.FormulaType = &pb.Formula_Conjunction{Conjunction: true452} - _t953 = _t955 + var _t977 *pb.Formula + if prediction463 == 0 { + _t978 := p.parse_true() + true464 := _t978 + _t979 := &pb.Formula{} + _t979.FormulaType = &pb.Formula_Conjunction{Conjunction: true464} + _t977 = _t979 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t950 = _t953 + _t974 = _t977 } - _t947 = _t950 + _t971 = _t974 } - _t944 = _t947 + _t968 = _t971 } - _t941 = _t944 + _t965 = _t968 } - _t938 = _t941 + _t962 = _t965 } - _t935 = _t938 + _t959 = _t962 } - _t932 = _t935 + _t956 = _t959 } - _t929 = _t932 + _t953 = _t956 } - _t926 = _t929 + _t950 = _t953 } - _t923 = _t926 + _t947 = _t950 } - _t920 = _t923 + _t944 = _t947 } - _t917 = _t920 + _t941 = _t944 } - return _t917 + return _t941 } func (p *Parser) parse_true() *pb.Conjunction { p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t956 := &pb.Conjunction{Args: []*pb.Formula{}} - return _t956 + _t980 := &pb.Conjunction{Args: []*pb.Formula{}} + return _t980 } func (p *Parser) parse_false() *pb.Disjunction { p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t957 := &pb.Disjunction{Args: []*pb.Formula{}} - return _t957 + _t981 := &pb.Disjunction{Args: []*pb.Formula{}} + return _t981 } func (p *Parser) parse_exists() *pb.Exists { p.consumeLiteral("(") p.consumeLiteral("exists") - _t958 := p.parse_bindings() - bindings465 := _t958 - _t959 := p.parse_formula() - formula466 := _t959 + _t982 := p.parse_bindings() + bindings477 := _t982 + _t983 := p.parse_formula() + formula478 := _t983 p.consumeLiteral(")") - _t960 := &pb.Abstraction{Vars: listConcat(bindings465[0].([]*pb.Binding), bindings465[1].([]*pb.Binding)), Value: formula466} - _t961 := &pb.Exists{Body: _t960} - return _t961 + _t984 := &pb.Abstraction{Vars: listConcat(bindings477[0].([]*pb.Binding), bindings477[1].([]*pb.Binding)), Value: formula478} + _t985 := &pb.Exists{Body: _t984} + return _t985 } func (p *Parser) parse_reduce() *pb.Reduce { p.consumeLiteral("(") p.consumeLiteral("reduce") - _t962 := p.parse_abstraction() - abstraction467 := _t962 - _t963 := p.parse_abstraction() - abstraction_3468 := _t963 - _t964 := p.parse_terms() - terms469 := _t964 - p.consumeLiteral(")") - _t965 := &pb.Reduce{Op: abstraction467, Body: abstraction_3468, Terms: terms469} - return _t965 + _t986 := p.parse_abstraction() + abstraction479 := _t986 + _t987 := p.parse_abstraction() + abstraction_3480 := _t987 + _t988 := p.parse_terms() + terms481 := _t988 + p.consumeLiteral(")") + _t989 := &pb.Reduce{Op: abstraction479, Body: abstraction_3480, Terms: terms481} + return _t989 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs470 := []*pb.Term{} - cond471 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond471 { - _t966 := p.parse_term() - item472 := _t966 - xs470 = append(xs470, item472) - cond471 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + xs482 := []*pb.Term{} + cond483 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond483 { + _t990 := p.parse_term() + item484 := _t990 + xs482 = append(xs482, item484) + cond483 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - terms473 := xs470 + terms485 := xs482 p.consumeLiteral(")") - return terms473 + return terms485 } func (p *Parser) parse_term() *pb.Term { - var _t967 int64 + var _t991 int64 if p.matchLookaheadLiteral("true", 0) { - _t967 = 1 + _t991 = 1 } else { - var _t968 int64 + var _t992 int64 if p.matchLookaheadLiteral("missing", 0) { - _t968 = 1 + _t992 = 1 } else { - var _t969 int64 + var _t993 int64 if p.matchLookaheadLiteral("false", 0) { - _t969 = 1 + _t993 = 1 } else { - var _t970 int64 + var _t994 int64 if p.matchLookaheadLiteral("(", 0) { - _t970 = 1 + _t994 = 1 } else { - var _t971 int64 + var _t995 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t971 = 1 + _t995 = 1 } else { - var _t972 int64 + var _t996 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t972 = 0 + _t996 = 0 } else { - var _t973 int64 + var _t997 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t973 = 1 + _t997 = 1 } else { - var _t974 int64 + var _t998 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t974 = 1 + _t998 = 1 } else { - var _t975 int64 + var _t999 int64 if p.matchLookaheadTerminal("INT", 0) { - _t975 = 1 + _t999 = 1 } else { - var _t976 int64 + var _t1000 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t976 = 1 + _t1000 = 1 } else { - var _t977 int64 + var _t1001 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t977 = 1 + _t1001 = 1 } else { - _t977 = -1 + _t1001 = -1 } - _t976 = _t977 + _t1000 = _t1001 } - _t975 = _t976 + _t999 = _t1000 } - _t974 = _t975 + _t998 = _t999 } - _t973 = _t974 + _t997 = _t998 } - _t972 = _t973 + _t996 = _t997 } - _t971 = _t972 + _t995 = _t996 } - _t970 = _t971 + _t994 = _t995 } - _t969 = _t970 + _t993 = _t994 } - _t968 = _t969 + _t992 = _t993 } - _t967 = _t968 - } - prediction474 := _t967 - var _t978 *pb.Term - if prediction474 == 1 { - _t979 := p.parse_constant() - constant476 := _t979 - _t980 := &pb.Term{} - _t980.TermType = &pb.Term_Constant{Constant: constant476} - _t978 = _t980 + _t991 = _t992 + } + prediction486 := _t991 + var _t1002 *pb.Term + if prediction486 == 1 { + _t1003 := p.parse_constant() + constant488 := _t1003 + _t1004 := &pb.Term{} + _t1004.TermType = &pb.Term_Constant{Constant: constant488} + _t1002 = _t1004 } else { - var _t981 *pb.Term - if prediction474 == 0 { - _t982 := p.parse_var() - var475 := _t982 - _t983 := &pb.Term{} - _t983.TermType = &pb.Term_Var{Var: var475} - _t981 = _t983 + var _t1005 *pb.Term + if prediction486 == 0 { + _t1006 := p.parse_var() + var487 := _t1006 + _t1007 := &pb.Term{} + _t1007.TermType = &pb.Term_Var{Var: var487} + _t1005 = _t1007 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t978 = _t981 + _t1002 = _t1005 } - return _t978 + return _t1002 } func (p *Parser) parse_var() *pb.Var { - symbol477 := p.consumeTerminal("SYMBOL").Value.str - _t984 := &pb.Var{Name: symbol477} - return _t984 + symbol489 := p.consumeTerminal("SYMBOL").Value.str + _t1008 := &pb.Var{Name: symbol489} + return _t1008 } func (p *Parser) parse_constant() *pb.Value { - _t985 := p.parse_value() - value478 := _t985 - return value478 + _t1009 := p.parse_value() + value490 := _t1009 + return value490 } func (p *Parser) parse_conjunction() *pb.Conjunction { p.consumeLiteral("(") p.consumeLiteral("and") - xs479 := []*pb.Formula{} - cond480 := p.matchLookaheadLiteral("(", 0) - for cond480 { - _t986 := p.parse_formula() - item481 := _t986 - xs479 = append(xs479, item481) - cond480 = p.matchLookaheadLiteral("(", 0) + xs491 := []*pb.Formula{} + cond492 := p.matchLookaheadLiteral("(", 0) + for cond492 { + _t1010 := p.parse_formula() + item493 := _t1010 + xs491 = append(xs491, item493) + cond492 = p.matchLookaheadLiteral("(", 0) } - formulas482 := xs479 + formulas494 := xs491 p.consumeLiteral(")") - _t987 := &pb.Conjunction{Args: formulas482} - return _t987 + _t1011 := &pb.Conjunction{Args: formulas494} + return _t1011 } func (p *Parser) parse_disjunction() *pb.Disjunction { p.consumeLiteral("(") p.consumeLiteral("or") - xs483 := []*pb.Formula{} - cond484 := p.matchLookaheadLiteral("(", 0) - for cond484 { - _t988 := p.parse_formula() - item485 := _t988 - xs483 = append(xs483, item485) - cond484 = p.matchLookaheadLiteral("(", 0) + xs495 := []*pb.Formula{} + cond496 := p.matchLookaheadLiteral("(", 0) + for cond496 { + _t1012 := p.parse_formula() + item497 := _t1012 + xs495 = append(xs495, item497) + cond496 = p.matchLookaheadLiteral("(", 0) } - formulas486 := xs483 + formulas498 := xs495 p.consumeLiteral(")") - _t989 := &pb.Disjunction{Args: formulas486} - return _t989 + _t1013 := &pb.Disjunction{Args: formulas498} + return _t1013 } func (p *Parser) parse_not() *pb.Not { p.consumeLiteral("(") p.consumeLiteral("not") - _t990 := p.parse_formula() - formula487 := _t990 + _t1014 := p.parse_formula() + formula499 := _t1014 p.consumeLiteral(")") - _t991 := &pb.Not{Arg: formula487} - return _t991 + _t1015 := &pb.Not{Arg: formula499} + return _t1015 } func (p *Parser) parse_ffi() *pb.FFI { p.consumeLiteral("(") p.consumeLiteral("ffi") - _t992 := p.parse_name() - name488 := _t992 - _t993 := p.parse_ffi_args() - ffi_args489 := _t993 - _t994 := p.parse_terms() - terms490 := _t994 + _t1016 := p.parse_name() + name500 := _t1016 + _t1017 := p.parse_ffi_args() + ffi_args501 := _t1017 + _t1018 := p.parse_terms() + terms502 := _t1018 p.consumeLiteral(")") - _t995 := &pb.FFI{Name: name488, Args: ffi_args489, Terms: terms490} - return _t995 + _t1019 := &pb.FFI{Name: name500, Args: ffi_args501, Terms: terms502} + return _t1019 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol491 := p.consumeTerminal("SYMBOL").Value.str - return symbol491 + symbol503 := p.consumeTerminal("SYMBOL").Value.str + return symbol503 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs492 := []*pb.Abstraction{} - cond493 := p.matchLookaheadLiteral("(", 0) - for cond493 { - _t996 := p.parse_abstraction() - item494 := _t996 - xs492 = append(xs492, item494) - cond493 = p.matchLookaheadLiteral("(", 0) + xs504 := []*pb.Abstraction{} + cond505 := p.matchLookaheadLiteral("(", 0) + for cond505 { + _t1020 := p.parse_abstraction() + item506 := _t1020 + xs504 = append(xs504, item506) + cond505 = p.matchLookaheadLiteral("(", 0) } - abstractions495 := xs492 + abstractions507 := xs504 p.consumeLiteral(")") - return abstractions495 + return abstractions507 } func (p *Parser) parse_atom() *pb.Atom { p.consumeLiteral("(") p.consumeLiteral("atom") - _t997 := p.parse_relation_id() - relation_id496 := _t997 - xs497 := []*pb.Term{} - cond498 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond498 { - _t998 := p.parse_term() - item499 := _t998 - xs497 = append(xs497, item499) - cond498 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1021 := p.parse_relation_id() + relation_id508 := _t1021 + xs509 := []*pb.Term{} + cond510 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond510 { + _t1022 := p.parse_term() + item511 := _t1022 + xs509 = append(xs509, item511) + cond510 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - terms500 := xs497 + terms512 := xs509 p.consumeLiteral(")") - _t999 := &pb.Atom{Name: relation_id496, Terms: terms500} - return _t999 + _t1023 := &pb.Atom{Name: relation_id508, Terms: terms512} + return _t1023 } func (p *Parser) parse_pragma() *pb.Pragma { p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1000 := p.parse_name() - name501 := _t1000 - xs502 := []*pb.Term{} - cond503 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond503 { - _t1001 := p.parse_term() - item504 := _t1001 - xs502 = append(xs502, item504) - cond503 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - } - terms505 := xs502 - p.consumeLiteral(")") - _t1002 := &pb.Pragma{Name: name501, Terms: terms505} - return _t1002 + _t1024 := p.parse_name() + name513 := _t1024 + xs514 := []*pb.Term{} + cond515 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond515 { + _t1025 := p.parse_term() + item516 := _t1025 + xs514 = append(xs514, item516) + cond515 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + } + terms517 := xs514 + p.consumeLiteral(")") + _t1026 := &pb.Pragma{Name: name513, Terms: terms517} + return _t1026 } func (p *Parser) parse_primitive() *pb.Primitive { - var _t1003 int64 + var _t1027 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1004 int64 + var _t1028 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1004 = 9 + _t1028 = 9 } else { - var _t1005 int64 + var _t1029 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1005 = 4 + _t1029 = 4 } else { - var _t1006 int64 + var _t1030 int64 if p.matchLookaheadLiteral(">", 1) { - _t1006 = 3 + _t1030 = 3 } else { - var _t1007 int64 + var _t1031 int64 if p.matchLookaheadLiteral("=", 1) { - _t1007 = 0 + _t1031 = 0 } else { - var _t1008 int64 + var _t1032 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1008 = 2 + _t1032 = 2 } else { - var _t1009 int64 + var _t1033 int64 if p.matchLookaheadLiteral("<", 1) { - _t1009 = 1 + _t1033 = 1 } else { - var _t1010 int64 + var _t1034 int64 if p.matchLookaheadLiteral("/", 1) { - _t1010 = 8 + _t1034 = 8 } else { - var _t1011 int64 + var _t1035 int64 if p.matchLookaheadLiteral("-", 1) { - _t1011 = 6 + _t1035 = 6 } else { - var _t1012 int64 + var _t1036 int64 if p.matchLookaheadLiteral("+", 1) { - _t1012 = 5 + _t1036 = 5 } else { - var _t1013 int64 + var _t1037 int64 if p.matchLookaheadLiteral("*", 1) { - _t1013 = 7 + _t1037 = 7 } else { - _t1013 = -1 + _t1037 = -1 } - _t1012 = _t1013 + _t1036 = _t1037 } - _t1011 = _t1012 + _t1035 = _t1036 } - _t1010 = _t1011 + _t1034 = _t1035 } - _t1009 = _t1010 + _t1033 = _t1034 } - _t1008 = _t1009 + _t1032 = _t1033 } - _t1007 = _t1008 + _t1031 = _t1032 } - _t1006 = _t1007 + _t1030 = _t1031 } - _t1005 = _t1006 + _t1029 = _t1030 } - _t1004 = _t1005 + _t1028 = _t1029 } - _t1003 = _t1004 + _t1027 = _t1028 } else { - _t1003 = -1 + _t1027 = -1 } - prediction506 := _t1003 - var _t1014 *pb.Primitive - if prediction506 == 9 { + prediction518 := _t1027 + var _t1038 *pb.Primitive + if prediction518 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1015 := p.parse_name() - name516 := _t1015 - xs517 := []*pb.RelTerm{} - cond518 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond518 { - _t1016 := p.parse_rel_term() - item519 := _t1016 - xs517 = append(xs517, item519) - cond518 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1039 := p.parse_name() + name528 := _t1039 + xs529 := []*pb.RelTerm{} + cond530 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond530 { + _t1040 := p.parse_rel_term() + item531 := _t1040 + xs529 = append(xs529, item531) + cond530 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - rel_terms520 := xs517 + rel_terms532 := xs529 p.consumeLiteral(")") - _t1017 := &pb.Primitive{Name: name516, Terms: rel_terms520} - _t1014 = _t1017 + _t1041 := &pb.Primitive{Name: name528, Terms: rel_terms532} + _t1038 = _t1041 } else { - var _t1018 *pb.Primitive - if prediction506 == 8 { - _t1019 := p.parse_divide() - divide515 := _t1019 - _t1018 = divide515 + var _t1042 *pb.Primitive + if prediction518 == 8 { + _t1043 := p.parse_divide() + divide527 := _t1043 + _t1042 = divide527 } else { - var _t1020 *pb.Primitive - if prediction506 == 7 { - _t1021 := p.parse_multiply() - multiply514 := _t1021 - _t1020 = multiply514 + var _t1044 *pb.Primitive + if prediction518 == 7 { + _t1045 := p.parse_multiply() + multiply526 := _t1045 + _t1044 = multiply526 } else { - var _t1022 *pb.Primitive - if prediction506 == 6 { - _t1023 := p.parse_minus() - minus513 := _t1023 - _t1022 = minus513 + var _t1046 *pb.Primitive + if prediction518 == 6 { + _t1047 := p.parse_minus() + minus525 := _t1047 + _t1046 = minus525 } else { - var _t1024 *pb.Primitive - if prediction506 == 5 { - _t1025 := p.parse_add() - add512 := _t1025 - _t1024 = add512 + var _t1048 *pb.Primitive + if prediction518 == 5 { + _t1049 := p.parse_add() + add524 := _t1049 + _t1048 = add524 } else { - var _t1026 *pb.Primitive - if prediction506 == 4 { - _t1027 := p.parse_gt_eq() - gt_eq511 := _t1027 - _t1026 = gt_eq511 + var _t1050 *pb.Primitive + if prediction518 == 4 { + _t1051 := p.parse_gt_eq() + gt_eq523 := _t1051 + _t1050 = gt_eq523 } else { - var _t1028 *pb.Primitive - if prediction506 == 3 { - _t1029 := p.parse_gt() - gt510 := _t1029 - _t1028 = gt510 + var _t1052 *pb.Primitive + if prediction518 == 3 { + _t1053 := p.parse_gt() + gt522 := _t1053 + _t1052 = gt522 } else { - var _t1030 *pb.Primitive - if prediction506 == 2 { - _t1031 := p.parse_lt_eq() - lt_eq509 := _t1031 - _t1030 = lt_eq509 + var _t1054 *pb.Primitive + if prediction518 == 2 { + _t1055 := p.parse_lt_eq() + lt_eq521 := _t1055 + _t1054 = lt_eq521 } else { - var _t1032 *pb.Primitive - if prediction506 == 1 { - _t1033 := p.parse_lt() - lt508 := _t1033 - _t1032 = lt508 + var _t1056 *pb.Primitive + if prediction518 == 1 { + _t1057 := p.parse_lt() + lt520 := _t1057 + _t1056 = lt520 } else { - var _t1034 *pb.Primitive - if prediction506 == 0 { - _t1035 := p.parse_eq() - eq507 := _t1035 - _t1034 = eq507 + var _t1058 *pb.Primitive + if prediction518 == 0 { + _t1059 := p.parse_eq() + eq519 := _t1059 + _t1058 = eq519 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1032 = _t1034 + _t1056 = _t1058 } - _t1030 = _t1032 + _t1054 = _t1056 } - _t1028 = _t1030 + _t1052 = _t1054 } - _t1026 = _t1028 + _t1050 = _t1052 } - _t1024 = _t1026 + _t1048 = _t1050 } - _t1022 = _t1024 + _t1046 = _t1048 } - _t1020 = _t1022 + _t1044 = _t1046 } - _t1018 = _t1020 + _t1042 = _t1044 } - _t1014 = _t1018 + _t1038 = _t1042 } - return _t1014 + return _t1038 } func (p *Parser) parse_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("=") - _t1036 := p.parse_term() - term521 := _t1036 - _t1037 := p.parse_term() - term_3522 := _t1037 + _t1060 := p.parse_term() + term533 := _t1060 + _t1061 := p.parse_term() + term_3534 := _t1061 p.consumeLiteral(")") - _t1038 := &pb.RelTerm{} - _t1038.RelTermType = &pb.RelTerm_Term{Term: term521} - _t1039 := &pb.RelTerm{} - _t1039.RelTermType = &pb.RelTerm_Term{Term: term_3522} - _t1040 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1038, _t1039}} - return _t1040 + _t1062 := &pb.RelTerm{} + _t1062.RelTermType = &pb.RelTerm_Term{Term: term533} + _t1063 := &pb.RelTerm{} + _t1063.RelTermType = &pb.RelTerm_Term{Term: term_3534} + _t1064 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1062, _t1063}} + return _t1064 } func (p *Parser) parse_lt() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("<") - _t1041 := p.parse_term() - term523 := _t1041 - _t1042 := p.parse_term() - term_3524 := _t1042 + _t1065 := p.parse_term() + term535 := _t1065 + _t1066 := p.parse_term() + term_3536 := _t1066 p.consumeLiteral(")") - _t1043 := &pb.RelTerm{} - _t1043.RelTermType = &pb.RelTerm_Term{Term: term523} - _t1044 := &pb.RelTerm{} - _t1044.RelTermType = &pb.RelTerm_Term{Term: term_3524} - _t1045 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1043, _t1044}} - return _t1045 + _t1067 := &pb.RelTerm{} + _t1067.RelTermType = &pb.RelTerm_Term{Term: term535} + _t1068 := &pb.RelTerm{} + _t1068.RelTermType = &pb.RelTerm_Term{Term: term_3536} + _t1069 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1067, _t1068}} + return _t1069 } func (p *Parser) parse_lt_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("<=") - _t1046 := p.parse_term() - term525 := _t1046 - _t1047 := p.parse_term() - term_3526 := _t1047 + _t1070 := p.parse_term() + term537 := _t1070 + _t1071 := p.parse_term() + term_3538 := _t1071 p.consumeLiteral(")") - _t1048 := &pb.RelTerm{} - _t1048.RelTermType = &pb.RelTerm_Term{Term: term525} - _t1049 := &pb.RelTerm{} - _t1049.RelTermType = &pb.RelTerm_Term{Term: term_3526} - _t1050 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1048, _t1049}} - return _t1050 + _t1072 := &pb.RelTerm{} + _t1072.RelTermType = &pb.RelTerm_Term{Term: term537} + _t1073 := &pb.RelTerm{} + _t1073.RelTermType = &pb.RelTerm_Term{Term: term_3538} + _t1074 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1072, _t1073}} + return _t1074 } func (p *Parser) parse_gt() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral(">") - _t1051 := p.parse_term() - term527 := _t1051 - _t1052 := p.parse_term() - term_3528 := _t1052 + _t1075 := p.parse_term() + term539 := _t1075 + _t1076 := p.parse_term() + term_3540 := _t1076 p.consumeLiteral(")") - _t1053 := &pb.RelTerm{} - _t1053.RelTermType = &pb.RelTerm_Term{Term: term527} - _t1054 := &pb.RelTerm{} - _t1054.RelTermType = &pb.RelTerm_Term{Term: term_3528} - _t1055 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1053, _t1054}} - return _t1055 + _t1077 := &pb.RelTerm{} + _t1077.RelTermType = &pb.RelTerm_Term{Term: term539} + _t1078 := &pb.RelTerm{} + _t1078.RelTermType = &pb.RelTerm_Term{Term: term_3540} + _t1079 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1077, _t1078}} + return _t1079 } func (p *Parser) parse_gt_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral(">=") - _t1056 := p.parse_term() - term529 := _t1056 - _t1057 := p.parse_term() - term_3530 := _t1057 + _t1080 := p.parse_term() + term541 := _t1080 + _t1081 := p.parse_term() + term_3542 := _t1081 p.consumeLiteral(")") - _t1058 := &pb.RelTerm{} - _t1058.RelTermType = &pb.RelTerm_Term{Term: term529} - _t1059 := &pb.RelTerm{} - _t1059.RelTermType = &pb.RelTerm_Term{Term: term_3530} - _t1060 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1058, _t1059}} - return _t1060 + _t1082 := &pb.RelTerm{} + _t1082.RelTermType = &pb.RelTerm_Term{Term: term541} + _t1083 := &pb.RelTerm{} + _t1083.RelTermType = &pb.RelTerm_Term{Term: term_3542} + _t1084 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1082, _t1083}} + return _t1084 } func (p *Parser) parse_add() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("+") - _t1061 := p.parse_term() - term531 := _t1061 - _t1062 := p.parse_term() - term_3532 := _t1062 - _t1063 := p.parse_term() - term_4533 := _t1063 - p.consumeLiteral(")") - _t1064 := &pb.RelTerm{} - _t1064.RelTermType = &pb.RelTerm_Term{Term: term531} - _t1065 := &pb.RelTerm{} - _t1065.RelTermType = &pb.RelTerm_Term{Term: term_3532} - _t1066 := &pb.RelTerm{} - _t1066.RelTermType = &pb.RelTerm_Term{Term: term_4533} - _t1067 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1064, _t1065, _t1066}} - return _t1067 + _t1085 := p.parse_term() + term543 := _t1085 + _t1086 := p.parse_term() + term_3544 := _t1086 + _t1087 := p.parse_term() + term_4545 := _t1087 + p.consumeLiteral(")") + _t1088 := &pb.RelTerm{} + _t1088.RelTermType = &pb.RelTerm_Term{Term: term543} + _t1089 := &pb.RelTerm{} + _t1089.RelTermType = &pb.RelTerm_Term{Term: term_3544} + _t1090 := &pb.RelTerm{} + _t1090.RelTermType = &pb.RelTerm_Term{Term: term_4545} + _t1091 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1088, _t1089, _t1090}} + return _t1091 } func (p *Parser) parse_minus() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("-") - _t1068 := p.parse_term() - term534 := _t1068 - _t1069 := p.parse_term() - term_3535 := _t1069 - _t1070 := p.parse_term() - term_4536 := _t1070 - p.consumeLiteral(")") - _t1071 := &pb.RelTerm{} - _t1071.RelTermType = &pb.RelTerm_Term{Term: term534} - _t1072 := &pb.RelTerm{} - _t1072.RelTermType = &pb.RelTerm_Term{Term: term_3535} - _t1073 := &pb.RelTerm{} - _t1073.RelTermType = &pb.RelTerm_Term{Term: term_4536} - _t1074 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1071, _t1072, _t1073}} - return _t1074 + _t1092 := p.parse_term() + term546 := _t1092 + _t1093 := p.parse_term() + term_3547 := _t1093 + _t1094 := p.parse_term() + term_4548 := _t1094 + p.consumeLiteral(")") + _t1095 := &pb.RelTerm{} + _t1095.RelTermType = &pb.RelTerm_Term{Term: term546} + _t1096 := &pb.RelTerm{} + _t1096.RelTermType = &pb.RelTerm_Term{Term: term_3547} + _t1097 := &pb.RelTerm{} + _t1097.RelTermType = &pb.RelTerm_Term{Term: term_4548} + _t1098 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1095, _t1096, _t1097}} + return _t1098 } func (p *Parser) parse_multiply() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("*") - _t1075 := p.parse_term() - term537 := _t1075 - _t1076 := p.parse_term() - term_3538 := _t1076 - _t1077 := p.parse_term() - term_4539 := _t1077 - p.consumeLiteral(")") - _t1078 := &pb.RelTerm{} - _t1078.RelTermType = &pb.RelTerm_Term{Term: term537} - _t1079 := &pb.RelTerm{} - _t1079.RelTermType = &pb.RelTerm_Term{Term: term_3538} - _t1080 := &pb.RelTerm{} - _t1080.RelTermType = &pb.RelTerm_Term{Term: term_4539} - _t1081 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1078, _t1079, _t1080}} - return _t1081 + _t1099 := p.parse_term() + term549 := _t1099 + _t1100 := p.parse_term() + term_3550 := _t1100 + _t1101 := p.parse_term() + term_4551 := _t1101 + p.consumeLiteral(")") + _t1102 := &pb.RelTerm{} + _t1102.RelTermType = &pb.RelTerm_Term{Term: term549} + _t1103 := &pb.RelTerm{} + _t1103.RelTermType = &pb.RelTerm_Term{Term: term_3550} + _t1104 := &pb.RelTerm{} + _t1104.RelTermType = &pb.RelTerm_Term{Term: term_4551} + _t1105 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1102, _t1103, _t1104}} + return _t1105 } func (p *Parser) parse_divide() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("/") - _t1082 := p.parse_term() - term540 := _t1082 - _t1083 := p.parse_term() - term_3541 := _t1083 - _t1084 := p.parse_term() - term_4542 := _t1084 - p.consumeLiteral(")") - _t1085 := &pb.RelTerm{} - _t1085.RelTermType = &pb.RelTerm_Term{Term: term540} - _t1086 := &pb.RelTerm{} - _t1086.RelTermType = &pb.RelTerm_Term{Term: term_3541} - _t1087 := &pb.RelTerm{} - _t1087.RelTermType = &pb.RelTerm_Term{Term: term_4542} - _t1088 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1085, _t1086, _t1087}} - return _t1088 + _t1106 := p.parse_term() + term552 := _t1106 + _t1107 := p.parse_term() + term_3553 := _t1107 + _t1108 := p.parse_term() + term_4554 := _t1108 + p.consumeLiteral(")") + _t1109 := &pb.RelTerm{} + _t1109.RelTermType = &pb.RelTerm_Term{Term: term552} + _t1110 := &pb.RelTerm{} + _t1110.RelTermType = &pb.RelTerm_Term{Term: term_3553} + _t1111 := &pb.RelTerm{} + _t1111.RelTermType = &pb.RelTerm_Term{Term: term_4554} + _t1112 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1109, _t1110, _t1111}} + return _t1112 } func (p *Parser) parse_rel_term() *pb.RelTerm { - var _t1089 int64 + var _t1113 int64 if p.matchLookaheadLiteral("true", 0) { - _t1089 = 1 + _t1113 = 1 } else { - var _t1090 int64 + var _t1114 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1090 = 1 + _t1114 = 1 } else { - var _t1091 int64 + var _t1115 int64 if p.matchLookaheadLiteral("false", 0) { - _t1091 = 1 + _t1115 = 1 } else { - var _t1092 int64 + var _t1116 int64 if p.matchLookaheadLiteral("(", 0) { - _t1092 = 1 + _t1116 = 1 } else { - var _t1093 int64 + var _t1117 int64 if p.matchLookaheadLiteral("#", 0) { - _t1093 = 0 + _t1117 = 0 } else { - var _t1094 int64 + var _t1118 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1094 = 1 + _t1118 = 1 } else { - var _t1095 int64 + var _t1119 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1095 = 1 + _t1119 = 1 } else { - var _t1096 int64 + var _t1120 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1096 = 1 + _t1120 = 1 } else { - var _t1097 int64 + var _t1121 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1097 = 1 + _t1121 = 1 } else { - var _t1098 int64 + var _t1122 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1098 = 1 + _t1122 = 1 } else { - var _t1099 int64 + var _t1123 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1099 = 1 + _t1123 = 1 } else { - var _t1100 int64 + var _t1124 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1100 = 1 + _t1124 = 1 } else { - _t1100 = -1 + _t1124 = -1 } - _t1099 = _t1100 + _t1123 = _t1124 } - _t1098 = _t1099 + _t1122 = _t1123 } - _t1097 = _t1098 + _t1121 = _t1122 } - _t1096 = _t1097 + _t1120 = _t1121 } - _t1095 = _t1096 + _t1119 = _t1120 } - _t1094 = _t1095 + _t1118 = _t1119 } - _t1093 = _t1094 + _t1117 = _t1118 } - _t1092 = _t1093 + _t1116 = _t1117 } - _t1091 = _t1092 + _t1115 = _t1116 } - _t1090 = _t1091 + _t1114 = _t1115 } - _t1089 = _t1090 - } - prediction543 := _t1089 - var _t1101 *pb.RelTerm - if prediction543 == 1 { - _t1102 := p.parse_term() - term545 := _t1102 - _t1103 := &pb.RelTerm{} - _t1103.RelTermType = &pb.RelTerm_Term{Term: term545} - _t1101 = _t1103 + _t1113 = _t1114 + } + prediction555 := _t1113 + var _t1125 *pb.RelTerm + if prediction555 == 1 { + _t1126 := p.parse_term() + term557 := _t1126 + _t1127 := &pb.RelTerm{} + _t1127.RelTermType = &pb.RelTerm_Term{Term: term557} + _t1125 = _t1127 } else { - var _t1104 *pb.RelTerm - if prediction543 == 0 { - _t1105 := p.parse_specialized_value() - specialized_value544 := _t1105 - _t1106 := &pb.RelTerm{} - _t1106.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value544} - _t1104 = _t1106 + var _t1128 *pb.RelTerm + if prediction555 == 0 { + _t1129 := p.parse_specialized_value() + specialized_value556 := _t1129 + _t1130 := &pb.RelTerm{} + _t1130.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value556} + _t1128 = _t1130 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1101 = _t1104 + _t1125 = _t1128 } - return _t1101 + return _t1125 } func (p *Parser) parse_specialized_value() *pb.Value { p.consumeLiteral("#") - _t1107 := p.parse_value() - value546 := _t1107 - return value546 + _t1131 := p.parse_value() + value558 := _t1131 + return value558 } func (p *Parser) parse_rel_atom() *pb.RelAtom { p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1108 := p.parse_name() - name547 := _t1108 - xs548 := []*pb.RelTerm{} - cond549 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond549 { - _t1109 := p.parse_rel_term() - item550 := _t1109 - xs548 = append(xs548, item550) - cond549 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1132 := p.parse_name() + name559 := _t1132 + xs560 := []*pb.RelTerm{} + cond561 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond561 { + _t1133 := p.parse_rel_term() + item562 := _t1133 + xs560 = append(xs560, item562) + cond561 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - rel_terms551 := xs548 + rel_terms563 := xs560 p.consumeLiteral(")") - _t1110 := &pb.RelAtom{Name: name547, Terms: rel_terms551} - return _t1110 + _t1134 := &pb.RelAtom{Name: name559, Terms: rel_terms563} + return _t1134 } func (p *Parser) parse_cast() *pb.Cast { p.consumeLiteral("(") p.consumeLiteral("cast") - _t1111 := p.parse_term() - term552 := _t1111 - _t1112 := p.parse_term() - term_3553 := _t1112 + _t1135 := p.parse_term() + term564 := _t1135 + _t1136 := p.parse_term() + term_3565 := _t1136 p.consumeLiteral(")") - _t1113 := &pb.Cast{Input: term552, Result: term_3553} - return _t1113 + _t1137 := &pb.Cast{Input: term564, Result: term_3565} + return _t1137 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs554 := []*pb.Attribute{} - cond555 := p.matchLookaheadLiteral("(", 0) - for cond555 { - _t1114 := p.parse_attribute() - item556 := _t1114 - xs554 = append(xs554, item556) - cond555 = p.matchLookaheadLiteral("(", 0) + xs566 := []*pb.Attribute{} + cond567 := p.matchLookaheadLiteral("(", 0) + for cond567 { + _t1138 := p.parse_attribute() + item568 := _t1138 + xs566 = append(xs566, item568) + cond567 = p.matchLookaheadLiteral("(", 0) } - attributes557 := xs554 + attributes569 := xs566 p.consumeLiteral(")") - return attributes557 + return attributes569 } func (p *Parser) parse_attribute() *pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1115 := p.parse_name() - name558 := _t1115 - xs559 := []*pb.Value{} - cond560 := (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond560 { - _t1116 := p.parse_value() - item561 := _t1116 - xs559 = append(xs559, item561) - cond560 = (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1139 := p.parse_name() + name570 := _t1139 + xs571 := []*pb.Value{} + cond572 := (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond572 { + _t1140 := p.parse_value() + item573 := _t1140 + xs571 = append(xs571, item573) + cond572 = (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - values562 := xs559 + values574 := xs571 p.consumeLiteral(")") - _t1117 := &pb.Attribute{Name: name558, Args: values562} - return _t1117 + _t1141 := &pb.Attribute{Name: name570, Args: values574} + return _t1141 } func (p *Parser) parse_algorithm() *pb.Algorithm { p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs563 := []*pb.RelationId{} - cond564 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond564 { - _t1118 := p.parse_relation_id() - item565 := _t1118 - xs563 = append(xs563, item565) - cond564 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + xs575 := []*pb.RelationId{} + cond576 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond576 { + _t1142 := p.parse_relation_id() + item577 := _t1142 + xs575 = append(xs575, item577) + cond576 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) } - relation_ids566 := xs563 - _t1119 := p.parse_script() - script567 := _t1119 + relation_ids578 := xs575 + _t1143 := p.parse_script() + script579 := _t1143 p.consumeLiteral(")") - _t1120 := &pb.Algorithm{Global: relation_ids566, Body: script567} - return _t1120 + _t1144 := &pb.Algorithm{Global: relation_ids578, Body: script579} + return _t1144 } func (p *Parser) parse_script() *pb.Script { p.consumeLiteral("(") p.consumeLiteral("script") - xs568 := []*pb.Construct{} - cond569 := p.matchLookaheadLiteral("(", 0) - for cond569 { - _t1121 := p.parse_construct() - item570 := _t1121 - xs568 = append(xs568, item570) - cond569 = p.matchLookaheadLiteral("(", 0) + xs580 := []*pb.Construct{} + cond581 := p.matchLookaheadLiteral("(", 0) + for cond581 { + _t1145 := p.parse_construct() + item582 := _t1145 + xs580 = append(xs580, item582) + cond581 = p.matchLookaheadLiteral("(", 0) } - constructs571 := xs568 + constructs583 := xs580 p.consumeLiteral(")") - _t1122 := &pb.Script{Constructs: constructs571} - return _t1122 + _t1146 := &pb.Script{Constructs: constructs583} + return _t1146 } func (p *Parser) parse_construct() *pb.Construct { - var _t1123 int64 + var _t1147 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1124 int64 + var _t1148 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1124 = 1 + _t1148 = 1 } else { - var _t1125 int64 + var _t1149 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1125 = 1 + _t1149 = 1 } else { - var _t1126 int64 + var _t1150 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1126 = 1 + _t1150 = 1 } else { - var _t1127 int64 + var _t1151 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1127 = 0 + _t1151 = 0 } else { - var _t1128 int64 + var _t1152 int64 if p.matchLookaheadLiteral("break", 1) { - _t1128 = 1 + _t1152 = 1 } else { - var _t1129 int64 + var _t1153 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1129 = 1 + _t1153 = 1 } else { - _t1129 = -1 + _t1153 = -1 } - _t1128 = _t1129 + _t1152 = _t1153 } - _t1127 = _t1128 + _t1151 = _t1152 } - _t1126 = _t1127 + _t1150 = _t1151 } - _t1125 = _t1126 + _t1149 = _t1150 } - _t1124 = _t1125 + _t1148 = _t1149 } - _t1123 = _t1124 + _t1147 = _t1148 } else { - _t1123 = -1 - } - prediction572 := _t1123 - var _t1130 *pb.Construct - if prediction572 == 1 { - _t1131 := p.parse_instruction() - instruction574 := _t1131 - _t1132 := &pb.Construct{} - _t1132.ConstructType = &pb.Construct_Instruction{Instruction: instruction574} - _t1130 = _t1132 + _t1147 = -1 + } + prediction584 := _t1147 + var _t1154 *pb.Construct + if prediction584 == 1 { + _t1155 := p.parse_instruction() + instruction586 := _t1155 + _t1156 := &pb.Construct{} + _t1156.ConstructType = &pb.Construct_Instruction{Instruction: instruction586} + _t1154 = _t1156 } else { - var _t1133 *pb.Construct - if prediction572 == 0 { - _t1134 := p.parse_loop() - loop573 := _t1134 - _t1135 := &pb.Construct{} - _t1135.ConstructType = &pb.Construct_Loop{Loop: loop573} - _t1133 = _t1135 + var _t1157 *pb.Construct + if prediction584 == 0 { + _t1158 := p.parse_loop() + loop585 := _t1158 + _t1159 := &pb.Construct{} + _t1159.ConstructType = &pb.Construct_Loop{Loop: loop585} + _t1157 = _t1159 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1130 = _t1133 + _t1154 = _t1157 } - return _t1130 + return _t1154 } func (p *Parser) parse_loop() *pb.Loop { p.consumeLiteral("(") p.consumeLiteral("loop") - _t1136 := p.parse_init() - init575 := _t1136 - _t1137 := p.parse_script() - script576 := _t1137 + _t1160 := p.parse_init() + init587 := _t1160 + _t1161 := p.parse_script() + script588 := _t1161 p.consumeLiteral(")") - _t1138 := &pb.Loop{Init: init575, Body: script576} - return _t1138 + _t1162 := &pb.Loop{Init: init587, Body: script588} + return _t1162 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs577 := []*pb.Instruction{} - cond578 := p.matchLookaheadLiteral("(", 0) - for cond578 { - _t1139 := p.parse_instruction() - item579 := _t1139 - xs577 = append(xs577, item579) - cond578 = p.matchLookaheadLiteral("(", 0) + xs589 := []*pb.Instruction{} + cond590 := p.matchLookaheadLiteral("(", 0) + for cond590 { + _t1163 := p.parse_instruction() + item591 := _t1163 + xs589 = append(xs589, item591) + cond590 = p.matchLookaheadLiteral("(", 0) } - instructions580 := xs577 + instructions592 := xs589 p.consumeLiteral(")") - return instructions580 + return instructions592 } func (p *Parser) parse_instruction() *pb.Instruction { - var _t1140 int64 + var _t1164 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1141 int64 + var _t1165 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1141 = 1 + _t1165 = 1 } else { - var _t1142 int64 + var _t1166 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1142 = 4 + _t1166 = 4 } else { - var _t1143 int64 + var _t1167 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1143 = 3 + _t1167 = 3 } else { - var _t1144 int64 + var _t1168 int64 if p.matchLookaheadLiteral("break", 1) { - _t1144 = 2 + _t1168 = 2 } else { - var _t1145 int64 + var _t1169 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1145 = 0 + _t1169 = 0 } else { - _t1145 = -1 + _t1169 = -1 } - _t1144 = _t1145 + _t1168 = _t1169 } - _t1143 = _t1144 + _t1167 = _t1168 } - _t1142 = _t1143 + _t1166 = _t1167 } - _t1141 = _t1142 + _t1165 = _t1166 } - _t1140 = _t1141 + _t1164 = _t1165 } else { - _t1140 = -1 - } - prediction581 := _t1140 - var _t1146 *pb.Instruction - if prediction581 == 4 { - _t1147 := p.parse_monus_def() - monus_def586 := _t1147 - _t1148 := &pb.Instruction{} - _t1148.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def586} - _t1146 = _t1148 + _t1164 = -1 + } + prediction593 := _t1164 + var _t1170 *pb.Instruction + if prediction593 == 4 { + _t1171 := p.parse_monus_def() + monus_def598 := _t1171 + _t1172 := &pb.Instruction{} + _t1172.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def598} + _t1170 = _t1172 } else { - var _t1149 *pb.Instruction - if prediction581 == 3 { - _t1150 := p.parse_monoid_def() - monoid_def585 := _t1150 - _t1151 := &pb.Instruction{} - _t1151.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def585} - _t1149 = _t1151 + var _t1173 *pb.Instruction + if prediction593 == 3 { + _t1174 := p.parse_monoid_def() + monoid_def597 := _t1174 + _t1175 := &pb.Instruction{} + _t1175.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def597} + _t1173 = _t1175 } else { - var _t1152 *pb.Instruction - if prediction581 == 2 { - _t1153 := p.parse_break() - break584 := _t1153 - _t1154 := &pb.Instruction{} - _t1154.InstrType = &pb.Instruction_Break{Break: break584} - _t1152 = _t1154 + var _t1176 *pb.Instruction + if prediction593 == 2 { + _t1177 := p.parse_break() + break596 := _t1177 + _t1178 := &pb.Instruction{} + _t1178.InstrType = &pb.Instruction_Break{Break: break596} + _t1176 = _t1178 } else { - var _t1155 *pb.Instruction - if prediction581 == 1 { - _t1156 := p.parse_upsert() - upsert583 := _t1156 - _t1157 := &pb.Instruction{} - _t1157.InstrType = &pb.Instruction_Upsert{Upsert: upsert583} - _t1155 = _t1157 + var _t1179 *pb.Instruction + if prediction593 == 1 { + _t1180 := p.parse_upsert() + upsert595 := _t1180 + _t1181 := &pb.Instruction{} + _t1181.InstrType = &pb.Instruction_Upsert{Upsert: upsert595} + _t1179 = _t1181 } else { - var _t1158 *pb.Instruction - if prediction581 == 0 { - _t1159 := p.parse_assign() - assign582 := _t1159 - _t1160 := &pb.Instruction{} - _t1160.InstrType = &pb.Instruction_Assign{Assign: assign582} - _t1158 = _t1160 + var _t1182 *pb.Instruction + if prediction593 == 0 { + _t1183 := p.parse_assign() + assign594 := _t1183 + _t1184 := &pb.Instruction{} + _t1184.InstrType = &pb.Instruction_Assign{Assign: assign594} + _t1182 = _t1184 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1155 = _t1158 + _t1179 = _t1182 } - _t1152 = _t1155 + _t1176 = _t1179 } - _t1149 = _t1152 + _t1173 = _t1176 } - _t1146 = _t1149 + _t1170 = _t1173 } - return _t1146 + return _t1170 } func (p *Parser) parse_assign() *pb.Assign { p.consumeLiteral("(") p.consumeLiteral("assign") - _t1161 := p.parse_relation_id() - relation_id587 := _t1161 - _t1162 := p.parse_abstraction() - abstraction588 := _t1162 - var _t1163 []*pb.Attribute + _t1185 := p.parse_relation_id() + relation_id599 := _t1185 + _t1186 := p.parse_abstraction() + abstraction600 := _t1186 + var _t1187 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1164 := p.parse_attrs() - _t1163 = _t1164 + _t1188 := p.parse_attrs() + _t1187 = _t1188 } - attrs589 := _t1163 + attrs601 := _t1187 p.consumeLiteral(")") - _t1165 := attrs589 - if attrs589 == nil { - _t1165 = []*pb.Attribute{} + _t1189 := attrs601 + if attrs601 == nil { + _t1189 = []*pb.Attribute{} } - _t1166 := &pb.Assign{Name: relation_id587, Body: abstraction588, Attrs: _t1165} - return _t1166 + _t1190 := &pb.Assign{Name: relation_id599, Body: abstraction600, Attrs: _t1189} + return _t1190 } func (p *Parser) parse_upsert() *pb.Upsert { p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1167 := p.parse_relation_id() - relation_id590 := _t1167 - _t1168 := p.parse_abstraction_with_arity() - abstraction_with_arity591 := _t1168 - var _t1169 []*pb.Attribute + _t1191 := p.parse_relation_id() + relation_id602 := _t1191 + _t1192 := p.parse_abstraction_with_arity() + abstraction_with_arity603 := _t1192 + var _t1193 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1170 := p.parse_attrs() - _t1169 = _t1170 + _t1194 := p.parse_attrs() + _t1193 = _t1194 } - attrs592 := _t1169 + attrs604 := _t1193 p.consumeLiteral(")") - _t1171 := attrs592 - if attrs592 == nil { - _t1171 = []*pb.Attribute{} + _t1195 := attrs604 + if attrs604 == nil { + _t1195 = []*pb.Attribute{} } - _t1172 := &pb.Upsert{Name: relation_id590, Body: abstraction_with_arity591[0].(*pb.Abstraction), Attrs: _t1171, ValueArity: abstraction_with_arity591[1].(int64)} - return _t1172 + _t1196 := &pb.Upsert{Name: relation_id602, Body: abstraction_with_arity603[0].(*pb.Abstraction), Attrs: _t1195, ValueArity: abstraction_with_arity603[1].(int64)} + return _t1196 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1173 := p.parse_bindings() - bindings593 := _t1173 - _t1174 := p.parse_formula() - formula594 := _t1174 + _t1197 := p.parse_bindings() + bindings605 := _t1197 + _t1198 := p.parse_formula() + formula606 := _t1198 p.consumeLiteral(")") - _t1175 := &pb.Abstraction{Vars: listConcat(bindings593[0].([]*pb.Binding), bindings593[1].([]*pb.Binding)), Value: formula594} - return []interface{}{_t1175, int64(len(bindings593[1].([]*pb.Binding)))} + _t1199 := &pb.Abstraction{Vars: listConcat(bindings605[0].([]*pb.Binding), bindings605[1].([]*pb.Binding)), Value: formula606} + return []interface{}{_t1199, int64(len(bindings605[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { p.consumeLiteral("(") p.consumeLiteral("break") - _t1176 := p.parse_relation_id() - relation_id595 := _t1176 - _t1177 := p.parse_abstraction() - abstraction596 := _t1177 - var _t1178 []*pb.Attribute + _t1200 := p.parse_relation_id() + relation_id607 := _t1200 + _t1201 := p.parse_abstraction() + abstraction608 := _t1201 + var _t1202 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1179 := p.parse_attrs() - _t1178 = _t1179 + _t1203 := p.parse_attrs() + _t1202 = _t1203 } - attrs597 := _t1178 + attrs609 := _t1202 p.consumeLiteral(")") - _t1180 := attrs597 - if attrs597 == nil { - _t1180 = []*pb.Attribute{} + _t1204 := attrs609 + if attrs609 == nil { + _t1204 = []*pb.Attribute{} } - _t1181 := &pb.Break{Name: relation_id595, Body: abstraction596, Attrs: _t1180} - return _t1181 + _t1205 := &pb.Break{Name: relation_id607, Body: abstraction608, Attrs: _t1204} + return _t1205 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1182 := p.parse_monoid() - monoid598 := _t1182 - _t1183 := p.parse_relation_id() - relation_id599 := _t1183 - _t1184 := p.parse_abstraction_with_arity() - abstraction_with_arity600 := _t1184 - var _t1185 []*pb.Attribute + _t1206 := p.parse_monoid() + monoid610 := _t1206 + _t1207 := p.parse_relation_id() + relation_id611 := _t1207 + _t1208 := p.parse_abstraction_with_arity() + abstraction_with_arity612 := _t1208 + var _t1209 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1186 := p.parse_attrs() - _t1185 = _t1186 + _t1210 := p.parse_attrs() + _t1209 = _t1210 } - attrs601 := _t1185 + attrs613 := _t1209 p.consumeLiteral(")") - _t1187 := attrs601 - if attrs601 == nil { - _t1187 = []*pb.Attribute{} + _t1211 := attrs613 + if attrs613 == nil { + _t1211 = []*pb.Attribute{} } - _t1188 := &pb.MonoidDef{Monoid: monoid598, Name: relation_id599, Body: abstraction_with_arity600[0].(*pb.Abstraction), Attrs: _t1187, ValueArity: abstraction_with_arity600[1].(int64)} - return _t1188 + _t1212 := &pb.MonoidDef{Monoid: monoid610, Name: relation_id611, Body: abstraction_with_arity612[0].(*pb.Abstraction), Attrs: _t1211, ValueArity: abstraction_with_arity612[1].(int64)} + return _t1212 } func (p *Parser) parse_monoid() *pb.Monoid { - var _t1189 int64 + var _t1213 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1190 int64 + var _t1214 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1190 = 3 + _t1214 = 3 } else { - var _t1191 int64 + var _t1215 int64 if p.matchLookaheadLiteral("or", 1) { - _t1191 = 0 + _t1215 = 0 } else { - var _t1192 int64 + var _t1216 int64 if p.matchLookaheadLiteral("min", 1) { - _t1192 = 1 + _t1216 = 1 } else { - var _t1193 int64 + var _t1217 int64 if p.matchLookaheadLiteral("max", 1) { - _t1193 = 2 + _t1217 = 2 } else { - _t1193 = -1 + _t1217 = -1 } - _t1192 = _t1193 + _t1216 = _t1217 } - _t1191 = _t1192 + _t1215 = _t1216 } - _t1190 = _t1191 + _t1214 = _t1215 } - _t1189 = _t1190 + _t1213 = _t1214 } else { - _t1189 = -1 - } - prediction602 := _t1189 - var _t1194 *pb.Monoid - if prediction602 == 3 { - _t1195 := p.parse_sum_monoid() - sum_monoid606 := _t1195 - _t1196 := &pb.Monoid{} - _t1196.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid606} - _t1194 = _t1196 + _t1213 = -1 + } + prediction614 := _t1213 + var _t1218 *pb.Monoid + if prediction614 == 3 { + _t1219 := p.parse_sum_monoid() + sum_monoid618 := _t1219 + _t1220 := &pb.Monoid{} + _t1220.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid618} + _t1218 = _t1220 } else { - var _t1197 *pb.Monoid - if prediction602 == 2 { - _t1198 := p.parse_max_monoid() - max_monoid605 := _t1198 - _t1199 := &pb.Monoid{} - _t1199.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid605} - _t1197 = _t1199 + var _t1221 *pb.Monoid + if prediction614 == 2 { + _t1222 := p.parse_max_monoid() + max_monoid617 := _t1222 + _t1223 := &pb.Monoid{} + _t1223.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid617} + _t1221 = _t1223 } else { - var _t1200 *pb.Monoid - if prediction602 == 1 { - _t1201 := p.parse_min_monoid() - min_monoid604 := _t1201 - _t1202 := &pb.Monoid{} - _t1202.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid604} - _t1200 = _t1202 + var _t1224 *pb.Monoid + if prediction614 == 1 { + _t1225 := p.parse_min_monoid() + min_monoid616 := _t1225 + _t1226 := &pb.Monoid{} + _t1226.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid616} + _t1224 = _t1226 } else { - var _t1203 *pb.Monoid - if prediction602 == 0 { - _t1204 := p.parse_or_monoid() - or_monoid603 := _t1204 - _t1205 := &pb.Monoid{} - _t1205.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid603} - _t1203 = _t1205 + var _t1227 *pb.Monoid + if prediction614 == 0 { + _t1228 := p.parse_or_monoid() + or_monoid615 := _t1228 + _t1229 := &pb.Monoid{} + _t1229.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid615} + _t1227 = _t1229 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1200 = _t1203 + _t1224 = _t1227 } - _t1197 = _t1200 + _t1221 = _t1224 } - _t1194 = _t1197 + _t1218 = _t1221 } - return _t1194 + return _t1218 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1206 := &pb.OrMonoid{} - return _t1206 + _t1230 := &pb.OrMonoid{} + return _t1230 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { p.consumeLiteral("(") p.consumeLiteral("min") - _t1207 := p.parse_type() - type607 := _t1207 + _t1231 := p.parse_type() + type619 := _t1231 p.consumeLiteral(")") - _t1208 := &pb.MinMonoid{Type: type607} - return _t1208 + _t1232 := &pb.MinMonoid{Type: type619} + return _t1232 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { p.consumeLiteral("(") p.consumeLiteral("max") - _t1209 := p.parse_type() - type608 := _t1209 + _t1233 := p.parse_type() + type620 := _t1233 p.consumeLiteral(")") - _t1210 := &pb.MaxMonoid{Type: type608} - return _t1210 + _t1234 := &pb.MaxMonoid{Type: type620} + return _t1234 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { p.consumeLiteral("(") p.consumeLiteral("sum") - _t1211 := p.parse_type() - type609 := _t1211 + _t1235 := p.parse_type() + type621 := _t1235 p.consumeLiteral(")") - _t1212 := &pb.SumMonoid{Type: type609} - return _t1212 + _t1236 := &pb.SumMonoid{Type: type621} + return _t1236 } func (p *Parser) parse_monus_def() *pb.MonusDef { p.consumeLiteral("(") p.consumeLiteral("monus") - _t1213 := p.parse_monoid() - monoid610 := _t1213 - _t1214 := p.parse_relation_id() - relation_id611 := _t1214 - _t1215 := p.parse_abstraction_with_arity() - abstraction_with_arity612 := _t1215 - var _t1216 []*pb.Attribute + _t1237 := p.parse_monoid() + monoid622 := _t1237 + _t1238 := p.parse_relation_id() + relation_id623 := _t1238 + _t1239 := p.parse_abstraction_with_arity() + abstraction_with_arity624 := _t1239 + var _t1240 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1217 := p.parse_attrs() - _t1216 = _t1217 + _t1241 := p.parse_attrs() + _t1240 = _t1241 } - attrs613 := _t1216 + attrs625 := _t1240 p.consumeLiteral(")") - _t1218 := attrs613 - if attrs613 == nil { - _t1218 = []*pb.Attribute{} + _t1242 := attrs625 + if attrs625 == nil { + _t1242 = []*pb.Attribute{} } - _t1219 := &pb.MonusDef{Monoid: monoid610, Name: relation_id611, Body: abstraction_with_arity612[0].(*pb.Abstraction), Attrs: _t1218, ValueArity: abstraction_with_arity612[1].(int64)} - return _t1219 + _t1243 := &pb.MonusDef{Monoid: monoid622, Name: relation_id623, Body: abstraction_with_arity624[0].(*pb.Abstraction), Attrs: _t1242, ValueArity: abstraction_with_arity624[1].(int64)} + return _t1243 } func (p *Parser) parse_constraint() *pb.Constraint { p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1220 := p.parse_relation_id() - relation_id614 := _t1220 - _t1221 := p.parse_abstraction() - abstraction615 := _t1221 - _t1222 := p.parse_functional_dependency_keys() - functional_dependency_keys616 := _t1222 - _t1223 := p.parse_functional_dependency_values() - functional_dependency_values617 := _t1223 + _t1244 := p.parse_relation_id() + relation_id626 := _t1244 + _t1245 := p.parse_abstraction() + abstraction627 := _t1245 + _t1246 := p.parse_functional_dependency_keys() + functional_dependency_keys628 := _t1246 + _t1247 := p.parse_functional_dependency_values() + functional_dependency_values629 := _t1247 p.consumeLiteral(")") - _t1224 := &pb.FunctionalDependency{Guard: abstraction615, Keys: functional_dependency_keys616, Values: functional_dependency_values617} - _t1225 := &pb.Constraint{Name: relation_id614} - _t1225.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1224} - return _t1225 + _t1248 := &pb.FunctionalDependency{Guard: abstraction627, Keys: functional_dependency_keys628, Values: functional_dependency_values629} + _t1249 := &pb.Constraint{Name: relation_id626} + _t1249.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1248} + return _t1249 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs618 := []*pb.Var{} - cond619 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond619 { - _t1226 := p.parse_var() - item620 := _t1226 - xs618 = append(xs618, item620) - cond619 = p.matchLookaheadTerminal("SYMBOL", 0) + xs630 := []*pb.Var{} + cond631 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond631 { + _t1250 := p.parse_var() + item632 := _t1250 + xs630 = append(xs630, item632) + cond631 = p.matchLookaheadTerminal("SYMBOL", 0) } - vars621 := xs618 + vars633 := xs630 p.consumeLiteral(")") - return vars621 + return vars633 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs622 := []*pb.Var{} - cond623 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond623 { - _t1227 := p.parse_var() - item624 := _t1227 - xs622 = append(xs622, item624) - cond623 = p.matchLookaheadTerminal("SYMBOL", 0) + xs634 := []*pb.Var{} + cond635 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond635 { + _t1251 := p.parse_var() + item636 := _t1251 + xs634 = append(xs634, item636) + cond635 = p.matchLookaheadTerminal("SYMBOL", 0) } - vars625 := xs622 + vars637 := xs634 p.consumeLiteral(")") - return vars625 + return vars637 } func (p *Parser) parse_data() *pb.Data { - var _t1228 int64 + var _t1252 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1229 int64 + var _t1253 int64 if p.matchLookaheadLiteral("rel_edb", 1) { - _t1229 = 0 + _t1253 = 0 } else { - var _t1230 int64 + var _t1254 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1230 = 2 + _t1254 = 2 } else { - var _t1231 int64 + var _t1255 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1231 = 1 + _t1255 = 1 } else { - _t1231 = -1 + _t1255 = -1 } - _t1230 = _t1231 + _t1254 = _t1255 } - _t1229 = _t1230 + _t1253 = _t1254 } - _t1228 = _t1229 + _t1252 = _t1253 } else { - _t1228 = -1 - } - prediction626 := _t1228 - var _t1232 *pb.Data - if prediction626 == 2 { - _t1233 := p.parse_csv_data() - csv_data629 := _t1233 - _t1234 := &pb.Data{} - _t1234.DataType = &pb.Data_CsvData{CsvData: csv_data629} - _t1232 = _t1234 + _t1252 = -1 + } + prediction638 := _t1252 + var _t1256 *pb.Data + if prediction638 == 2 { + _t1257 := p.parse_csv_data() + csv_data641 := _t1257 + _t1258 := &pb.Data{} + _t1258.DataType = &pb.Data_CsvData{CsvData: csv_data641} + _t1256 = _t1258 } else { - var _t1235 *pb.Data - if prediction626 == 1 { - _t1236 := p.parse_betree_relation() - betree_relation628 := _t1236 - _t1237 := &pb.Data{} - _t1237.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation628} - _t1235 = _t1237 + var _t1259 *pb.Data + if prediction638 == 1 { + _t1260 := p.parse_betree_relation() + betree_relation640 := _t1260 + _t1261 := &pb.Data{} + _t1261.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation640} + _t1259 = _t1261 } else { - var _t1238 *pb.Data - if prediction626 == 0 { - _t1239 := p.parse_rel_edb() - rel_edb627 := _t1239 - _t1240 := &pb.Data{} - _t1240.DataType = &pb.Data_RelEdb{RelEdb: rel_edb627} - _t1238 = _t1240 + var _t1262 *pb.Data + if prediction638 == 0 { + _t1263 := p.parse_rel_edb() + rel_edb639 := _t1263 + _t1264 := &pb.Data{} + _t1264.DataType = &pb.Data_RelEdb{RelEdb: rel_edb639} + _t1262 = _t1264 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1235 = _t1238 + _t1259 = _t1262 } - _t1232 = _t1235 + _t1256 = _t1259 } - return _t1232 + return _t1256 } func (p *Parser) parse_rel_edb() *pb.RelEDB { p.consumeLiteral("(") p.consumeLiteral("rel_edb") - _t1241 := p.parse_relation_id() - relation_id630 := _t1241 - _t1242 := p.parse_rel_edb_path() - rel_edb_path631 := _t1242 - _t1243 := p.parse_rel_edb_types() - rel_edb_types632 := _t1243 + _t1265 := p.parse_relation_id() + relation_id642 := _t1265 + _t1266 := p.parse_rel_edb_path() + rel_edb_path643 := _t1266 + _t1267 := p.parse_rel_edb_types() + rel_edb_types644 := _t1267 p.consumeLiteral(")") - _t1244 := &pb.RelEDB{TargetId: relation_id630, Path: rel_edb_path631, Types: rel_edb_types632} - return _t1244 + _t1268 := &pb.RelEDB{TargetId: relation_id642, Path: rel_edb_path643, Types: rel_edb_types644} + return _t1268 } func (p *Parser) parse_rel_edb_path() []string { p.consumeLiteral("[") - xs633 := []string{} - cond634 := p.matchLookaheadTerminal("STRING", 0) - for cond634 { - item635 := p.consumeTerminal("STRING").Value.str - xs633 = append(xs633, item635) - cond634 = p.matchLookaheadTerminal("STRING", 0) - } - strings636 := xs633 + xs645 := []string{} + cond646 := p.matchLookaheadTerminal("STRING", 0) + for cond646 { + item647 := p.consumeTerminal("STRING").Value.str + xs645 = append(xs645, item647) + cond646 = p.matchLookaheadTerminal("STRING", 0) + } + strings648 := xs645 p.consumeLiteral("]") - return strings636 + return strings648 } func (p *Parser) parse_rel_edb_types() []*pb.Type { p.consumeLiteral("[") - xs637 := []*pb.Type{} - cond638 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond638 { - _t1245 := p.parse_type() - item639 := _t1245 - xs637 = append(xs637, item639) - cond638 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types640 := xs637 + xs649 := []*pb.Type{} + cond650 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond650 { + _t1269 := p.parse_type() + item651 := _t1269 + xs649 = append(xs649, item651) + cond650 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types652 := xs649 p.consumeLiteral("]") - return types640 + return types652 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1246 := p.parse_relation_id() - relation_id641 := _t1246 - _t1247 := p.parse_betree_info() - betree_info642 := _t1247 + _t1270 := p.parse_relation_id() + relation_id653 := _t1270 + _t1271 := p.parse_betree_info() + betree_info654 := _t1271 p.consumeLiteral(")") - _t1248 := &pb.BeTreeRelation{Name: relation_id641, RelationInfo: betree_info642} - return _t1248 + _t1272 := &pb.BeTreeRelation{Name: relation_id653, RelationInfo: betree_info654} + return _t1272 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1249 := p.parse_betree_info_key_types() - betree_info_key_types643 := _t1249 - _t1250 := p.parse_betree_info_value_types() - betree_info_value_types644 := _t1250 - _t1251 := p.parse_config_dict() - config_dict645 := _t1251 + _t1273 := p.parse_betree_info_key_types() + betree_info_key_types655 := _t1273 + _t1274 := p.parse_betree_info_value_types() + betree_info_value_types656 := _t1274 + _t1275 := p.parse_config_dict() + config_dict657 := _t1275 p.consumeLiteral(")") - _t1252 := p.construct_betree_info(betree_info_key_types643, betree_info_value_types644, config_dict645) - return _t1252 + _t1276 := p.construct_betree_info(betree_info_key_types655, betree_info_value_types656, config_dict657) + return _t1276 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs646 := []*pb.Type{} - cond647 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond647 { - _t1253 := p.parse_type() - item648 := _t1253 - xs646 = append(xs646, item648) - cond647 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + xs658 := []*pb.Type{} + cond659 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond659 { + _t1277 := p.parse_type() + item660 := _t1277 + xs658 = append(xs658, item660) + cond659 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } - types649 := xs646 + types661 := xs658 p.consumeLiteral(")") - return types649 + return types661 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs650 := []*pb.Type{} - cond651 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond651 { - _t1254 := p.parse_type() - item652 := _t1254 - xs650 = append(xs650, item652) - cond651 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + xs662 := []*pb.Type{} + cond663 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond663 { + _t1278 := p.parse_type() + item664 := _t1278 + xs662 = append(xs662, item664) + cond663 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } - types653 := xs650 + types665 := xs662 p.consumeLiteral(")") - return types653 + return types665 } func (p *Parser) parse_csv_data() *pb.CSVData { p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1255 := p.parse_csvlocator() - csvlocator654 := _t1255 - _t1256 := p.parse_csv_config() - csv_config655 := _t1256 - _t1257 := p.parse_csv_columns() - csv_columns656 := _t1257 - _t1258 := p.parse_csv_asof() - csv_asof657 := _t1258 + _t1279 := p.parse_csvlocator() + csvlocator666 := _t1279 + _t1280 := p.parse_csv_config() + csv_config667 := _t1280 + _t1281 := p.parse_csv_columns() + csv_columns668 := _t1281 + _t1282 := p.parse_csv_asof() + csv_asof669 := _t1282 p.consumeLiteral(")") - _t1259 := &pb.CSVData{Locator: csvlocator654, Config: csv_config655, Columns: csv_columns656, Asof: csv_asof657} - return _t1259 + _t1283 := &pb.CSVData{Locator: csvlocator666, Config: csv_config667, Columns: csv_columns668, Asof: csv_asof669} + return _t1283 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1260 []string + var _t1284 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1261 := p.parse_csv_locator_paths() - _t1260 = _t1261 + _t1285 := p.parse_csv_locator_paths() + _t1284 = _t1285 } - csv_locator_paths658 := _t1260 - var _t1262 *string + csv_locator_paths670 := _t1284 + var _t1286 *string if p.matchLookaheadLiteral("(", 0) { - _t1263 := p.parse_csv_locator_inline_data() - _t1262 = ptr(_t1263) + _t1287 := p.parse_csv_locator_inline_data() + _t1286 = ptr(_t1287) } - csv_locator_inline_data659 := _t1262 + csv_locator_inline_data671 := _t1286 p.consumeLiteral(")") - _t1264 := csv_locator_paths658 - if csv_locator_paths658 == nil { - _t1264 = []string{} + _t1288 := csv_locator_paths670 + if csv_locator_paths670 == nil { + _t1288 = []string{} } - _t1265 := &pb.CSVLocator{Paths: _t1264, InlineData: []byte(deref(csv_locator_inline_data659, ""))} - return _t1265 + _t1289 := &pb.CSVLocator{Paths: _t1288, InlineData: []byte(deref(csv_locator_inline_data671, ""))} + return _t1289 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs660 := []string{} - cond661 := p.matchLookaheadTerminal("STRING", 0) - for cond661 { - item662 := p.consumeTerminal("STRING").Value.str - xs660 = append(xs660, item662) - cond661 = p.matchLookaheadTerminal("STRING", 0) + xs672 := []string{} + cond673 := p.matchLookaheadTerminal("STRING", 0) + for cond673 { + item674 := p.consumeTerminal("STRING").Value.str + xs672 = append(xs672, item674) + cond673 = p.matchLookaheadTerminal("STRING", 0) } - strings663 := xs660 + strings675 := xs672 p.consumeLiteral(")") - return strings663 + return strings675 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - string664 := p.consumeTerminal("STRING").Value.str + string676 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string664 + return string676 } func (p *Parser) parse_csv_config() *pb.CSVConfig { p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1266 := p.parse_config_dict() - config_dict665 := _t1266 + _t1290 := p.parse_config_dict() + config_dict677 := _t1290 p.consumeLiteral(")") - _t1267 := p.construct_csv_config(config_dict665) - return _t1267 + _t1291 := p.construct_csv_config(config_dict677) + return _t1291 } func (p *Parser) parse_csv_columns() []*pb.CSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs666 := []*pb.CSVColumn{} - cond667 := p.matchLookaheadLiteral("(", 0) - for cond667 { - _t1268 := p.parse_csv_column() - item668 := _t1268 - xs666 = append(xs666, item668) - cond667 = p.matchLookaheadLiteral("(", 0) + xs678 := []*pb.CSVColumn{} + cond679 := p.matchLookaheadLiteral("(", 0) + for cond679 { + _t1292 := p.parse_csv_column() + item680 := _t1292 + xs678 = append(xs678, item680) + cond679 = p.matchLookaheadLiteral("(", 0) } - csv_columns669 := xs666 + csv_columns681 := xs678 p.consumeLiteral(")") - return csv_columns669 + return csv_columns681 } func (p *Parser) parse_csv_column() *pb.CSVColumn { p.consumeLiteral("(") p.consumeLiteral("column") - string670 := p.consumeTerminal("STRING").Value.str - _t1269 := p.parse_relation_id() - relation_id671 := _t1269 - p.consumeLiteral("[") - xs672 := []*pb.Type{} - cond673 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond673 { - _t1270 := p.parse_type() - item674 := _t1270 - xs672 = append(xs672, item674) - cond673 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + _t1293 := p.parse_csv_column_path() + csv_column_path682 := _t1293 + var _t1294 []interface{} + if ((p.matchLookaheadLiteral(":", 0) || p.matchLookaheadLiteral("[", 0)) || p.matchLookaheadTerminal("UINT128", 0)) { + _t1295 := p.parse_csv_column_tail() + _t1294 = _t1295 } - types675 := xs672 - p.consumeLiteral("]") + csv_column_tail683 := _t1294 p.consumeLiteral(")") - _t1271 := &pb.CSVColumn{ColumnName: string670, TargetId: relation_id671, Types: types675} - return _t1271 + _t1296 := p.construct_csv_column(csv_column_path682, csv_column_tail683) + return _t1296 +} + +func (p *Parser) parse_csv_column_path() []string { + var _t1297 int64 + if p.matchLookaheadLiteral("[", 0) { + _t1297 = 1 + } else { + var _t1298 int64 + if p.matchLookaheadTerminal("STRING", 0) { + _t1298 = 0 + } else { + _t1298 = -1 + } + _t1297 = _t1298 + } + prediction684 := _t1297 + var _t1299 []string + if prediction684 == 1 { + p.consumeLiteral("[") + xs686 := []string{} + cond687 := p.matchLookaheadTerminal("STRING", 0) + for cond687 { + item688 := p.consumeTerminal("STRING").Value.str + xs686 = append(xs686, item688) + cond687 = p.matchLookaheadTerminal("STRING", 0) + } + strings689 := xs686 + p.consumeLiteral("]") + _t1299 = strings689 + } else { + var _t1300 []string + if prediction684 == 0 { + string685 := p.consumeTerminal("STRING").Value.str + _ = string685 + _t1300 = []string{string685} + } else { + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in csv_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) + } + _t1299 = _t1300 + } + return _t1299 +} + +func (p *Parser) parse_csv_column_tail() []interface{} { + var _t1301 int64 + if p.matchLookaheadLiteral("[", 0) { + _t1301 = 1 + } else { + var _t1302 int64 + if p.matchLookaheadLiteral(":", 0) { + _t1302 = 0 + } else { + var _t1303 int64 + if p.matchLookaheadTerminal("UINT128", 0) { + _t1303 = 0 + } else { + _t1303 = -1 + } + _t1302 = _t1303 + } + _t1301 = _t1302 + } + prediction690 := _t1301 + var _t1304 []interface{} + if prediction690 == 1 { + p.consumeLiteral("[") + xs696 := []*pb.Type{} + cond697 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond697 { + _t1305 := p.parse_type() + item698 := _t1305 + xs696 = append(xs696, item698) + cond697 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types699 := xs696 + p.consumeLiteral("]") + _t1304 = []interface{}{nil, types699} + } else { + var _t1306 []interface{} + if prediction690 == 0 { + _t1307 := p.parse_relation_id() + relation_id691 := _t1307 + p.consumeLiteral("[") + xs692 := []*pb.Type{} + cond693 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond693 { + _t1308 := p.parse_type() + item694 := _t1308 + xs692 = append(xs692, item694) + cond693 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types695 := xs692 + p.consumeLiteral("]") + _t1306 = []interface{}{relation_id691, types695} + } else { + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in csv_column_tail", p.lookahead(0).Type, p.lookahead(0).Value)}) + } + _t1304 = _t1306 + } + return _t1304 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string676 := p.consumeTerminal("STRING").Value.str + string700 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string676 + return string700 } func (p *Parser) parse_undefine() *pb.Undefine { p.consumeLiteral("(") p.consumeLiteral("undefine") - _t1272 := p.parse_fragment_id() - fragment_id677 := _t1272 + _t1309 := p.parse_fragment_id() + fragment_id701 := _t1309 p.consumeLiteral(")") - _t1273 := &pb.Undefine{FragmentId: fragment_id677} - return _t1273 + _t1310 := &pb.Undefine{FragmentId: fragment_id701} + return _t1310 } func (p *Parser) parse_context() *pb.Context { p.consumeLiteral("(") p.consumeLiteral("context") - xs678 := []*pb.RelationId{} - cond679 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond679 { - _t1274 := p.parse_relation_id() - item680 := _t1274 - xs678 = append(xs678, item680) - cond679 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + xs702 := []*pb.RelationId{} + cond703 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond703 { + _t1311 := p.parse_relation_id() + item704 := _t1311 + xs702 = append(xs702, item704) + cond703 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) } - relation_ids681 := xs678 + relation_ids705 := xs702 p.consumeLiteral(")") - _t1275 := &pb.Context{Relations: relation_ids681} - return _t1275 + _t1312 := &pb.Context{Relations: relation_ids705} + return _t1312 } func (p *Parser) parse_snapshot() *pb.Snapshot { p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t1276 := p.parse_rel_edb_path() - rel_edb_path682 := _t1276 - _t1277 := p.parse_relation_id() - relation_id683 := _t1277 + _t1313 := p.parse_rel_edb_path() + rel_edb_path706 := _t1313 + _t1314 := p.parse_relation_id() + relation_id707 := _t1314 p.consumeLiteral(")") - _t1278 := &pb.Snapshot{DestinationPath: rel_edb_path682, SourceRelation: relation_id683} - return _t1278 + _t1315 := &pb.Snapshot{DestinationPath: rel_edb_path706, SourceRelation: relation_id707} + return _t1315 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs684 := []*pb.Read{} - cond685 := p.matchLookaheadLiteral("(", 0) - for cond685 { - _t1279 := p.parse_read() - item686 := _t1279 - xs684 = append(xs684, item686) - cond685 = p.matchLookaheadLiteral("(", 0) + xs708 := []*pb.Read{} + cond709 := p.matchLookaheadLiteral("(", 0) + for cond709 { + _t1316 := p.parse_read() + item710 := _t1316 + xs708 = append(xs708, item710) + cond709 = p.matchLookaheadLiteral("(", 0) } - reads687 := xs684 + reads711 := xs708 p.consumeLiteral(")") - return reads687 + return reads711 } func (p *Parser) parse_read() *pb.Read { - var _t1280 int64 + var _t1317 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1281 int64 + var _t1318 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t1281 = 2 + _t1318 = 2 } else { - var _t1282 int64 + var _t1319 int64 if p.matchLookaheadLiteral("output", 1) { - _t1282 = 1 + _t1319 = 1 } else { - var _t1283 int64 + var _t1320 int64 if p.matchLookaheadLiteral("export", 1) { - _t1283 = 4 + _t1320 = 4 } else { - var _t1284 int64 + var _t1321 int64 if p.matchLookaheadLiteral("demand", 1) { - _t1284 = 0 + _t1321 = 0 } else { - var _t1285 int64 + var _t1322 int64 if p.matchLookaheadLiteral("abort", 1) { - _t1285 = 3 + _t1322 = 3 } else { - _t1285 = -1 + _t1322 = -1 } - _t1284 = _t1285 + _t1321 = _t1322 } - _t1283 = _t1284 + _t1320 = _t1321 } - _t1282 = _t1283 + _t1319 = _t1320 } - _t1281 = _t1282 + _t1318 = _t1319 } - _t1280 = _t1281 + _t1317 = _t1318 } else { - _t1280 = -1 - } - prediction688 := _t1280 - var _t1286 *pb.Read - if prediction688 == 4 { - _t1287 := p.parse_export() - export693 := _t1287 - _t1288 := &pb.Read{} - _t1288.ReadType = &pb.Read_Export{Export: export693} - _t1286 = _t1288 + _t1317 = -1 + } + prediction712 := _t1317 + var _t1323 *pb.Read + if prediction712 == 4 { + _t1324 := p.parse_export() + export717 := _t1324 + _t1325 := &pb.Read{} + _t1325.ReadType = &pb.Read_Export{Export: export717} + _t1323 = _t1325 } else { - var _t1289 *pb.Read - if prediction688 == 3 { - _t1290 := p.parse_abort() - abort692 := _t1290 - _t1291 := &pb.Read{} - _t1291.ReadType = &pb.Read_Abort{Abort: abort692} - _t1289 = _t1291 + var _t1326 *pb.Read + if prediction712 == 3 { + _t1327 := p.parse_abort() + abort716 := _t1327 + _t1328 := &pb.Read{} + _t1328.ReadType = &pb.Read_Abort{Abort: abort716} + _t1326 = _t1328 } else { - var _t1292 *pb.Read - if prediction688 == 2 { - _t1293 := p.parse_what_if() - what_if691 := _t1293 - _t1294 := &pb.Read{} - _t1294.ReadType = &pb.Read_WhatIf{WhatIf: what_if691} - _t1292 = _t1294 + var _t1329 *pb.Read + if prediction712 == 2 { + _t1330 := p.parse_what_if() + what_if715 := _t1330 + _t1331 := &pb.Read{} + _t1331.ReadType = &pb.Read_WhatIf{WhatIf: what_if715} + _t1329 = _t1331 } else { - var _t1295 *pb.Read - if prediction688 == 1 { - _t1296 := p.parse_output() - output690 := _t1296 - _t1297 := &pb.Read{} - _t1297.ReadType = &pb.Read_Output{Output: output690} - _t1295 = _t1297 + var _t1332 *pb.Read + if prediction712 == 1 { + _t1333 := p.parse_output() + output714 := _t1333 + _t1334 := &pb.Read{} + _t1334.ReadType = &pb.Read_Output{Output: output714} + _t1332 = _t1334 } else { - var _t1298 *pb.Read - if prediction688 == 0 { - _t1299 := p.parse_demand() - demand689 := _t1299 - _t1300 := &pb.Read{} - _t1300.ReadType = &pb.Read_Demand{Demand: demand689} - _t1298 = _t1300 + var _t1335 *pb.Read + if prediction712 == 0 { + _t1336 := p.parse_demand() + demand713 := _t1336 + _t1337 := &pb.Read{} + _t1337.ReadType = &pb.Read_Demand{Demand: demand713} + _t1335 = _t1337 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1295 = _t1298 + _t1332 = _t1335 } - _t1292 = _t1295 + _t1329 = _t1332 } - _t1289 = _t1292 + _t1326 = _t1329 } - _t1286 = _t1289 + _t1323 = _t1326 } - return _t1286 + return _t1323 } func (p *Parser) parse_demand() *pb.Demand { p.consumeLiteral("(") p.consumeLiteral("demand") - _t1301 := p.parse_relation_id() - relation_id694 := _t1301 + _t1338 := p.parse_relation_id() + relation_id718 := _t1338 p.consumeLiteral(")") - _t1302 := &pb.Demand{RelationId: relation_id694} - return _t1302 + _t1339 := &pb.Demand{RelationId: relation_id718} + return _t1339 } func (p *Parser) parse_output() *pb.Output { p.consumeLiteral("(") p.consumeLiteral("output") - _t1303 := p.parse_name() - name695 := _t1303 - _t1304 := p.parse_relation_id() - relation_id696 := _t1304 + _t1340 := p.parse_name() + name719 := _t1340 + _t1341 := p.parse_relation_id() + relation_id720 := _t1341 p.consumeLiteral(")") - _t1305 := &pb.Output{Name: name695, RelationId: relation_id696} - return _t1305 + _t1342 := &pb.Output{Name: name719, RelationId: relation_id720} + return _t1342 } func (p *Parser) parse_what_if() *pb.WhatIf { p.consumeLiteral("(") p.consumeLiteral("what_if") - _t1306 := p.parse_name() - name697 := _t1306 - _t1307 := p.parse_epoch() - epoch698 := _t1307 + _t1343 := p.parse_name() + name721 := _t1343 + _t1344 := p.parse_epoch() + epoch722 := _t1344 p.consumeLiteral(")") - _t1308 := &pb.WhatIf{Branch: name697, Epoch: epoch698} - return _t1308 + _t1345 := &pb.WhatIf{Branch: name721, Epoch: epoch722} + return _t1345 } func (p *Parser) parse_abort() *pb.Abort { p.consumeLiteral("(") p.consumeLiteral("abort") - var _t1309 *string + var _t1346 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t1310 := p.parse_name() - _t1309 = ptr(_t1310) + _t1347 := p.parse_name() + _t1346 = ptr(_t1347) } - name699 := _t1309 - _t1311 := p.parse_relation_id() - relation_id700 := _t1311 + name723 := _t1346 + _t1348 := p.parse_relation_id() + relation_id724 := _t1348 p.consumeLiteral(")") - _t1312 := &pb.Abort{Name: deref(name699, "abort"), RelationId: relation_id700} - return _t1312 + _t1349 := &pb.Abort{Name: deref(name723, "abort"), RelationId: relation_id724} + return _t1349 } func (p *Parser) parse_export() *pb.Export { p.consumeLiteral("(") p.consumeLiteral("export") - _t1313 := p.parse_export_csv_config() - export_csv_config701 := _t1313 + _t1350 := p.parse_export_csv_config() + export_csv_config725 := _t1350 p.consumeLiteral(")") - _t1314 := &pb.Export{} - _t1314.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config701} - return _t1314 + _t1351 := &pb.Export{} + _t1351.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config725} + return _t1351 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t1315 := p.parse_export_csv_path() - export_csv_path702 := _t1315 - _t1316 := p.parse_export_csv_columns() - export_csv_columns703 := _t1316 - _t1317 := p.parse_config_dict() - config_dict704 := _t1317 - p.consumeLiteral(")") - _t1318 := p.export_csv_config(export_csv_path702, export_csv_columns703, config_dict704) - return _t1318 + _t1352 := p.parse_export_csv_path() + export_csv_path726 := _t1352 + _t1353 := p.parse_export_csv_columns() + export_csv_columns727 := _t1353 + _t1354 := p.parse_config_dict() + config_dict728 := _t1354 + p.consumeLiteral(")") + _t1355 := p.export_csv_config(export_csv_path726, export_csv_columns727, config_dict728) + return _t1355 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string705 := p.consumeTerminal("STRING").Value.str + string729 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string705 + return string729 } func (p *Parser) parse_export_csv_columns() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs706 := []*pb.ExportCSVColumn{} - cond707 := p.matchLookaheadLiteral("(", 0) - for cond707 { - _t1319 := p.parse_export_csv_column() - item708 := _t1319 - xs706 = append(xs706, item708) - cond707 = p.matchLookaheadLiteral("(", 0) + xs730 := []*pb.ExportCSVColumn{} + cond731 := p.matchLookaheadLiteral("(", 0) + for cond731 { + _t1356 := p.parse_export_csv_column() + item732 := _t1356 + xs730 = append(xs730, item732) + cond731 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns709 := xs706 + export_csv_columns733 := xs730 p.consumeLiteral(")") - return export_csv_columns709 + return export_csv_columns733 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("column") - string710 := p.consumeTerminal("STRING").Value.str - _t1320 := p.parse_relation_id() - relation_id711 := _t1320 + string734 := p.consumeTerminal("STRING").Value.str + _t1357 := p.parse_relation_id() + relation_id735 := _t1357 p.consumeLiteral(")") - _t1321 := &pb.ExportCSVColumn{ColumnName: string710, ColumnData: relation_id711} - return _t1321 + _t1358 := &pb.ExportCSVColumn{ColumnName: string734, ColumnData: relation_id735} + return _t1358 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index c74c4d97..ec98bfae 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -311,157 +311,166 @@ func formatBool(b bool) string { // --- Helper functions --- func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1654 := &pb.Value{} - _t1654.Value = &pb.Value_IntValue{IntValue: int64(v)} - return _t1654 + _t1698 := &pb.Value{} + _t1698.Value = &pb.Value_IntValue{IntValue: int64(v)} + return _t1698 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1655 := &pb.Value{} - _t1655.Value = &pb.Value_IntValue{IntValue: v} - return _t1655 + _t1699 := &pb.Value{} + _t1699.Value = &pb.Value_IntValue{IntValue: v} + return _t1699 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1656 := &pb.Value{} - _t1656.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1656 + _t1700 := &pb.Value{} + _t1700.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1700 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1657 := &pb.Value{} - _t1657.Value = &pb.Value_StringValue{StringValue: v} - return _t1657 + _t1701 := &pb.Value{} + _t1701.Value = &pb.Value_StringValue{StringValue: v} + return _t1701 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1658 := &pb.Value{} - _t1658.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1658 + _t1702 := &pb.Value{} + _t1702.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1702 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1659 := &pb.Value{} - _t1659.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1659 + _t1703 := &pb.Value{} + _t1703.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1703 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1660 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1660}) + _t1704 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1704}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1661 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1661}) + _t1705 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1705}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1662 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1662}) + _t1706 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1706}) } } } - _t1663 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1663}) + _t1707 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1707}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1664 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1664}) - _t1665 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1665}) + _t1708 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1708}) + _t1709 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1709}) if msg.GetNewLine() != "" { - _t1666 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1666}) - } - _t1667 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1667}) - _t1668 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1668}) - _t1669 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1669}) + _t1710 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1710}) + } + _t1711 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1711}) + _t1712 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1712}) + _t1713 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1713}) if msg.GetComment() != "" { - _t1670 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1670}) + _t1714 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1714}) } for _, missing_string := range msg.GetMissingStrings() { - _t1671 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1671}) - } - _t1672 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1672}) - _t1673 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1673}) - _t1674 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1674}) + _t1715 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1715}) + } + _t1716 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1716}) + _t1717 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1717}) + _t1718 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1718}) return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1675 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1675}) - _t1676 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1676}) - _t1677 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1677}) - _t1678 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1678}) + _t1719 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1719}) + _t1720 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1720}) + _t1721 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1721}) + _t1722 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1722}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1679 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1679}) + _t1723 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1723}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1680 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1680}) + _t1724 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1724}) } } - _t1681 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1681}) - _t1682 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1682}) + _t1725 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1725}) + _t1726 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1726}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1683 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1683}) + _t1727 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1727}) } if msg.Compression != nil { - _t1684 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1684}) + _t1728 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1728}) } if msg.SyntaxHeaderRow != nil { - _t1685 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1685}) + _t1729 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1729}) } if msg.SyntaxMissingString != nil { - _t1686 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1686}) + _t1730 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1730}) } if msg.SyntaxDelim != nil { - _t1687 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1687}) + _t1731 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1731}) } if msg.SyntaxQuotechar != nil { - _t1688 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1688}) + _t1732 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1732}) } if msg.SyntaxEscapechar != nil { - _t1689 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1689}) + _t1733 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1733}) } return listSort(result) } +func (p *PrettyPrinter) deconstruct_csv_column_tail(col *pb.CSVColumn) []interface{} { + var _t1734 interface{} + if (hasProtoField(col, "target_id") || !(len(col.GetTypes()) == 0)) { + return []interface{}{col.GetTargetId(), col.GetTypes()} + } + _ = _t1734 + return nil +} + func (p *PrettyPrinter) deconstruct_relation_id_string(msg *pb.RelationId) string { name := p.relationIdToString(msg) return *name @@ -469,11 +478,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 _t1690 interface{} + var _t1735 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1690 + _ = _t1735 return nil } @@ -491,48 +500,48 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat638 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat638 != nil { - p.write(*flat638) + flat654 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat654 != nil { + p.write(*flat654) return nil } else { - _t1258 := func(_dollar_dollar *pb.Transaction) []interface{} { - var _t1259 *pb.Configure + _t1290 := func(_dollar_dollar *pb.Transaction) []interface{} { + var _t1291 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1259 = _dollar_dollar.GetConfigure() + _t1291 = _dollar_dollar.GetConfigure() } - var _t1260 *pb.Sync + var _t1292 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1260 = _dollar_dollar.GetSync() + _t1292 = _dollar_dollar.GetSync() } - return []interface{}{_t1259, _t1260, _dollar_dollar.GetEpochs()} + return []interface{}{_t1291, _t1292, _dollar_dollar.GetEpochs()} } - _t1261 := _t1258(msg) - fields629 := _t1261 - unwrapped_fields630 := fields629 + _t1293 := _t1290(msg) + fields645 := _t1293 + unwrapped_fields646 := fields645 p.write("(") p.write("transaction") p.indentSexp() - field631 := unwrapped_fields630[0].(*pb.Configure) - if field631 != nil { + field647 := unwrapped_fields646[0].(*pb.Configure) + if field647 != nil { p.newline() - opt_val632 := field631 - p.pretty_configure(opt_val632) + opt_val648 := field647 + p.pretty_configure(opt_val648) } - field633 := unwrapped_fields630[1].(*pb.Sync) - if field633 != nil { + field649 := unwrapped_fields646[1].(*pb.Sync) + if field649 != nil { p.newline() - opt_val634 := field633 - p.pretty_sync(opt_val634) + opt_val650 := field649 + p.pretty_sync(opt_val650) } - field635 := unwrapped_fields630[2].([]*pb.Epoch) - if !(len(field635) == 0) { + field651 := unwrapped_fields646[2].([]*pb.Epoch) + if !(len(field651) == 0) { p.newline() - for i637, elem636 := range field635 { - if (i637 > 0) { + for i653, elem652 := range field651 { + if (i653 > 0) { p.newline() } - p.pretty_epoch(elem636) + p.pretty_epoch(elem652) } } p.dedent() @@ -542,23 +551,23 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat641 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat641 != nil { - p.write(*flat641) + flat657 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat657 != nil { + p.write(*flat657) return nil } else { - _t1262 := func(_dollar_dollar *pb.Configure) [][]interface{} { - _t1263 := p.deconstruct_configure(_dollar_dollar) - return _t1263 + _t1294 := func(_dollar_dollar *pb.Configure) [][]interface{} { + _t1295 := p.deconstruct_configure(_dollar_dollar) + return _t1295 } - _t1264 := _t1262(msg) - fields639 := _t1264 - unwrapped_fields640 := fields639 + _t1296 := _t1294(msg) + fields655 := _t1296 + unwrapped_fields656 := fields655 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields640) + p.pretty_config_dict(unwrapped_fields656) p.dedent() p.write(")") } @@ -566,21 +575,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat645 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat645 != nil { - p.write(*flat645) + flat661 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat661 != nil { + p.write(*flat661) return nil } else { - fields642 := msg + fields658 := msg p.write("{") p.indent() - if !(len(fields642) == 0) { + if !(len(fields658) == 0) { p.newline() - for i644, elem643 := range fields642 { - if (i644 > 0) { + for i660, elem659 := range fields658 { + if (i660 > 0) { p.newline() } - p.pretty_config_key_value(elem643) + p.pretty_config_key_value(elem659) } } p.dedent() @@ -590,152 +599,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat650 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat650 != nil { - p.write(*flat650) + flat666 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat666 != nil { + p.write(*flat666) return nil } else { - _t1265 := func(_dollar_dollar []interface{}) []interface{} { + _t1297 := func(_dollar_dollar []interface{}) []interface{} { return []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} } - _t1266 := _t1265(msg) - fields646 := _t1266 - unwrapped_fields647 := fields646 + _t1298 := _t1297(msg) + fields662 := _t1298 + unwrapped_fields663 := fields662 p.write(":") - field648 := unwrapped_fields647[0].(string) - p.write(field648) + field664 := unwrapped_fields663[0].(string) + p.write(field664) p.write(" ") - field649 := unwrapped_fields647[1].(*pb.Value) - p.pretty_value(field649) + field665 := unwrapped_fields663[1].(*pb.Value) + p.pretty_value(field665) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat670 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat670 != nil { - p.write(*flat670) + flat686 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat686 != nil { + p.write(*flat686) return nil } else { - _t1267 := func(_dollar_dollar *pb.Value) *pb.DateValue { - var _t1268 *pb.DateValue + _t1299 := func(_dollar_dollar *pb.Value) *pb.DateValue { + var _t1300 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1268 = _dollar_dollar.GetDateValue() + _t1300 = _dollar_dollar.GetDateValue() } - return _t1268 + return _t1300 } - _t1269 := _t1267(msg) - deconstruct_result668 := _t1269 - if deconstruct_result668 != nil { - unwrapped669 := deconstruct_result668 - p.pretty_date(unwrapped669) + _t1301 := _t1299(msg) + deconstruct_result684 := _t1301 + if deconstruct_result684 != nil { + unwrapped685 := deconstruct_result684 + p.pretty_date(unwrapped685) } else { - _t1270 := func(_dollar_dollar *pb.Value) *pb.DateTimeValue { - var _t1271 *pb.DateTimeValue + _t1302 := func(_dollar_dollar *pb.Value) *pb.DateTimeValue { + var _t1303 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1271 = _dollar_dollar.GetDatetimeValue() + _t1303 = _dollar_dollar.GetDatetimeValue() } - return _t1271 + return _t1303 } - _t1272 := _t1270(msg) - deconstruct_result666 := _t1272 - if deconstruct_result666 != nil { - unwrapped667 := deconstruct_result666 - p.pretty_datetime(unwrapped667) + _t1304 := _t1302(msg) + deconstruct_result682 := _t1304 + if deconstruct_result682 != nil { + unwrapped683 := deconstruct_result682 + p.pretty_datetime(unwrapped683) } else { - _t1273 := func(_dollar_dollar *pb.Value) *string { - var _t1274 *string + _t1305 := func(_dollar_dollar *pb.Value) *string { + var _t1306 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1274 = ptr(_dollar_dollar.GetStringValue()) + _t1306 = ptr(_dollar_dollar.GetStringValue()) } - return _t1274 + return _t1306 } - _t1275 := _t1273(msg) - deconstruct_result664 := _t1275 - if deconstruct_result664 != nil { - unwrapped665 := *deconstruct_result664 - p.write(p.formatStringValue(unwrapped665)) + _t1307 := _t1305(msg) + deconstruct_result680 := _t1307 + if deconstruct_result680 != nil { + unwrapped681 := *deconstruct_result680 + p.write(p.formatStringValue(unwrapped681)) } else { - _t1276 := func(_dollar_dollar *pb.Value) *int64 { - var _t1277 *int64 + _t1308 := func(_dollar_dollar *pb.Value) *int64 { + var _t1309 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1277 = ptr(_dollar_dollar.GetIntValue()) + _t1309 = ptr(_dollar_dollar.GetIntValue()) } - return _t1277 + return _t1309 } - _t1278 := _t1276(msg) - deconstruct_result662 := _t1278 - if deconstruct_result662 != nil { - unwrapped663 := *deconstruct_result662 - p.write(fmt.Sprintf("%d", unwrapped663)) + _t1310 := _t1308(msg) + deconstruct_result678 := _t1310 + if deconstruct_result678 != nil { + unwrapped679 := *deconstruct_result678 + p.write(fmt.Sprintf("%d", unwrapped679)) } else { - _t1279 := func(_dollar_dollar *pb.Value) *float64 { - var _t1280 *float64 + _t1311 := func(_dollar_dollar *pb.Value) *float64 { + var _t1312 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1280 = ptr(_dollar_dollar.GetFloatValue()) + _t1312 = ptr(_dollar_dollar.GetFloatValue()) } - return _t1280 + return _t1312 } - _t1281 := _t1279(msg) - deconstruct_result660 := _t1281 - if deconstruct_result660 != nil { - unwrapped661 := *deconstruct_result660 - p.write(formatFloat64(unwrapped661)) + _t1313 := _t1311(msg) + deconstruct_result676 := _t1313 + if deconstruct_result676 != nil { + unwrapped677 := *deconstruct_result676 + p.write(formatFloat64(unwrapped677)) } else { - _t1282 := func(_dollar_dollar *pb.Value) *pb.UInt128Value { - var _t1283 *pb.UInt128Value + _t1314 := func(_dollar_dollar *pb.Value) *pb.UInt128Value { + var _t1315 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1283 = _dollar_dollar.GetUint128Value() + _t1315 = _dollar_dollar.GetUint128Value() } - return _t1283 + return _t1315 } - _t1284 := _t1282(msg) - deconstruct_result658 := _t1284 - if deconstruct_result658 != nil { - unwrapped659 := deconstruct_result658 - p.write(p.formatUint128(unwrapped659)) + _t1316 := _t1314(msg) + deconstruct_result674 := _t1316 + if deconstruct_result674 != nil { + unwrapped675 := deconstruct_result674 + p.write(p.formatUint128(unwrapped675)) } else { - _t1285 := func(_dollar_dollar *pb.Value) *pb.Int128Value { - var _t1286 *pb.Int128Value + _t1317 := func(_dollar_dollar *pb.Value) *pb.Int128Value { + var _t1318 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1286 = _dollar_dollar.GetInt128Value() + _t1318 = _dollar_dollar.GetInt128Value() } - return _t1286 + return _t1318 } - _t1287 := _t1285(msg) - deconstruct_result656 := _t1287 - if deconstruct_result656 != nil { - unwrapped657 := deconstruct_result656 - p.write(p.formatInt128(unwrapped657)) + _t1319 := _t1317(msg) + deconstruct_result672 := _t1319 + if deconstruct_result672 != nil { + unwrapped673 := deconstruct_result672 + p.write(p.formatInt128(unwrapped673)) } else { - _t1288 := func(_dollar_dollar *pb.Value) *pb.DecimalValue { - var _t1289 *pb.DecimalValue + _t1320 := func(_dollar_dollar *pb.Value) *pb.DecimalValue { + var _t1321 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1289 = _dollar_dollar.GetDecimalValue() + _t1321 = _dollar_dollar.GetDecimalValue() } - return _t1289 + return _t1321 } - _t1290 := _t1288(msg) - deconstruct_result654 := _t1290 - if deconstruct_result654 != nil { - unwrapped655 := deconstruct_result654 - p.write(p.formatDecimal(unwrapped655)) + _t1322 := _t1320(msg) + deconstruct_result670 := _t1322 + if deconstruct_result670 != nil { + unwrapped671 := deconstruct_result670 + p.write(p.formatDecimal(unwrapped671)) } else { - _t1291 := func(_dollar_dollar *pb.Value) *bool { - var _t1292 *bool + _t1323 := func(_dollar_dollar *pb.Value) *bool { + var _t1324 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1292 = ptr(_dollar_dollar.GetBooleanValue()) + _t1324 = ptr(_dollar_dollar.GetBooleanValue()) } - return _t1292 + return _t1324 } - _t1293 := _t1291(msg) - deconstruct_result652 := _t1293 - if deconstruct_result652 != nil { - unwrapped653 := *deconstruct_result652 - p.pretty_boolean_value(unwrapped653) + _t1325 := _t1323(msg) + deconstruct_result668 := _t1325 + if deconstruct_result668 != nil { + unwrapped669 := *deconstruct_result668 + p.pretty_boolean_value(unwrapped669) } else { - fields651 := msg - _ = fields651 + fields667 := msg + _ = fields667 p.write("missing") } } @@ -751,29 +760,29 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat676 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat676 != nil { - p.write(*flat676) + flat692 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat692 != nil { + p.write(*flat692) return nil } else { - _t1294 := func(_dollar_dollar *pb.DateValue) []interface{} { + _t1326 := func(_dollar_dollar *pb.DateValue) []interface{} { return []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} } - _t1295 := _t1294(msg) - fields671 := _t1295 - unwrapped_fields672 := fields671 + _t1327 := _t1326(msg) + fields687 := _t1327 + unwrapped_fields688 := fields687 p.write("(") p.write("date") p.indentSexp() p.newline() - field673 := unwrapped_fields672[0].(int64) - p.write(fmt.Sprintf("%d", field673)) + field689 := unwrapped_fields688[0].(int64) + p.write(fmt.Sprintf("%d", field689)) p.newline() - field674 := unwrapped_fields672[1].(int64) - p.write(fmt.Sprintf("%d", field674)) + field690 := unwrapped_fields688[1].(int64) + p.write(fmt.Sprintf("%d", field690)) p.newline() - field675 := unwrapped_fields672[2].(int64) - p.write(fmt.Sprintf("%d", field675)) + field691 := unwrapped_fields688[2].(int64) + p.write(fmt.Sprintf("%d", field691)) p.dedent() p.write(")") } @@ -781,43 +790,43 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat687 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat687 != nil { - p.write(*flat687) + flat703 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat703 != nil { + p.write(*flat703) return nil } else { - _t1296 := func(_dollar_dollar *pb.DateTimeValue) []interface{} { + _t1328 := func(_dollar_dollar *pb.DateTimeValue) []interface{} { return []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()))} } - _t1297 := _t1296(msg) - fields677 := _t1297 - unwrapped_fields678 := fields677 + _t1329 := _t1328(msg) + fields693 := _t1329 + unwrapped_fields694 := fields693 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field679 := unwrapped_fields678[0].(int64) - p.write(fmt.Sprintf("%d", field679)) + field695 := unwrapped_fields694[0].(int64) + p.write(fmt.Sprintf("%d", field695)) p.newline() - field680 := unwrapped_fields678[1].(int64) - p.write(fmt.Sprintf("%d", field680)) + field696 := unwrapped_fields694[1].(int64) + p.write(fmt.Sprintf("%d", field696)) p.newline() - field681 := unwrapped_fields678[2].(int64) - p.write(fmt.Sprintf("%d", field681)) + field697 := unwrapped_fields694[2].(int64) + p.write(fmt.Sprintf("%d", field697)) p.newline() - field682 := unwrapped_fields678[3].(int64) - p.write(fmt.Sprintf("%d", field682)) + field698 := unwrapped_fields694[3].(int64) + p.write(fmt.Sprintf("%d", field698)) p.newline() - field683 := unwrapped_fields678[4].(int64) - p.write(fmt.Sprintf("%d", field683)) + field699 := unwrapped_fields694[4].(int64) + p.write(fmt.Sprintf("%d", field699)) p.newline() - field684 := unwrapped_fields678[5].(int64) - p.write(fmt.Sprintf("%d", field684)) - field685 := unwrapped_fields678[6].(*int64) - if field685 != nil { + field700 := unwrapped_fields694[5].(int64) + p.write(fmt.Sprintf("%d", field700)) + field701 := unwrapped_fields694[6].(*int64) + if field701 != nil { p.newline() - opt_val686 := *field685 - p.write(fmt.Sprintf("%d", opt_val686)) + opt_val702 := *field701 + p.write(fmt.Sprintf("%d", opt_val702)) } p.dedent() p.write(")") @@ -826,32 +835,32 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { - _t1298 := func(_dollar_dollar bool) []interface{} { - var _t1299 []interface{} + _t1330 := func(_dollar_dollar bool) []interface{} { + var _t1331 []interface{} if _dollar_dollar { - _t1299 = []interface{}{} + _t1331 = []interface{}{} } - return _t1299 + return _t1331 } - _t1300 := _t1298(msg) - deconstruct_result690 := _t1300 - if deconstruct_result690 != nil { - unwrapped691 := deconstruct_result690 - _ = unwrapped691 + _t1332 := _t1330(msg) + deconstruct_result706 := _t1332 + if deconstruct_result706 != nil { + unwrapped707 := deconstruct_result706 + _ = unwrapped707 p.write("true") } else { - _t1301 := func(_dollar_dollar bool) []interface{} { - var _t1302 []interface{} + _t1333 := func(_dollar_dollar bool) []interface{} { + var _t1334 []interface{} if !(_dollar_dollar) { - _t1302 = []interface{}{} + _t1334 = []interface{}{} } - return _t1302 + return _t1334 } - _t1303 := _t1301(msg) - deconstruct_result688 := _t1303 - if deconstruct_result688 != nil { - unwrapped689 := deconstruct_result688 - _ = unwrapped689 + _t1335 := _t1333(msg) + deconstruct_result704 := _t1335 + if deconstruct_result704 != nil { + unwrapped705 := deconstruct_result704 + _ = unwrapped705 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -861,27 +870,27 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat696 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat696 != nil { - p.write(*flat696) + flat712 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat712 != nil { + p.write(*flat712) return nil } else { - _t1304 := func(_dollar_dollar *pb.Sync) []*pb.FragmentId { + _t1336 := func(_dollar_dollar *pb.Sync) []*pb.FragmentId { return _dollar_dollar.GetFragments() } - _t1305 := _t1304(msg) - fields692 := _t1305 - unwrapped_fields693 := fields692 + _t1337 := _t1336(msg) + fields708 := _t1337 + unwrapped_fields709 := fields708 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields693) == 0) { + if !(len(unwrapped_fields709) == 0) { p.newline() - for i695, elem694 := range unwrapped_fields693 { - if (i695 > 0) { + for i711, elem710 := range unwrapped_fields709 { + if (i711 > 0) { p.newline() } - p.pretty_fragment_id(elem694) + p.pretty_fragment_id(elem710) } } p.dedent() @@ -891,57 +900,57 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat699 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat699 != nil { - p.write(*flat699) + flat715 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat715 != nil { + p.write(*flat715) return nil } else { - _t1306 := func(_dollar_dollar *pb.FragmentId) string { + _t1338 := func(_dollar_dollar *pb.FragmentId) string { return p.fragmentIdToString(_dollar_dollar) } - _t1307 := _t1306(msg) - fields697 := _t1307 - unwrapped_fields698 := fields697 + _t1339 := _t1338(msg) + fields713 := _t1339 + unwrapped_fields714 := fields713 p.write(":") - p.write(unwrapped_fields698) + p.write(unwrapped_fields714) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat706 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat706 != nil { - p.write(*flat706) + flat722 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat722 != nil { + p.write(*flat722) return nil } else { - _t1308 := func(_dollar_dollar *pb.Epoch) []interface{} { - var _t1309 []*pb.Write + _t1340 := func(_dollar_dollar *pb.Epoch) []interface{} { + var _t1341 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1309 = _dollar_dollar.GetWrites() + _t1341 = _dollar_dollar.GetWrites() } - var _t1310 []*pb.Read + var _t1342 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1310 = _dollar_dollar.GetReads() + _t1342 = _dollar_dollar.GetReads() } - return []interface{}{_t1309, _t1310} + return []interface{}{_t1341, _t1342} } - _t1311 := _t1308(msg) - fields700 := _t1311 - unwrapped_fields701 := fields700 + _t1343 := _t1340(msg) + fields716 := _t1343 + unwrapped_fields717 := fields716 p.write("(") p.write("epoch") p.indentSexp() - field702 := unwrapped_fields701[0].([]*pb.Write) - if field702 != nil { + field718 := unwrapped_fields717[0].([]*pb.Write) + if field718 != nil { p.newline() - opt_val703 := field702 - p.pretty_epoch_writes(opt_val703) + opt_val719 := field718 + p.pretty_epoch_writes(opt_val719) } - field704 := unwrapped_fields701[1].([]*pb.Read) - if field704 != nil { + field720 := unwrapped_fields717[1].([]*pb.Read) + if field720 != nil { p.newline() - opt_val705 := field704 - p.pretty_epoch_reads(opt_val705) + opt_val721 := field720 + p.pretty_epoch_reads(opt_val721) } p.dedent() p.write(")") @@ -950,22 +959,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat710 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat710 != nil { - p.write(*flat710) + flat726 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat726 != nil { + p.write(*flat726) return nil } else { - fields707 := msg + fields723 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields707) == 0) { + if !(len(fields723) == 0) { p.newline() - for i709, elem708 := range fields707 { - if (i709 > 0) { + for i725, elem724 := range fields723 { + if (i725 > 0) { p.newline() } - p.pretty_write(elem708) + p.pretty_write(elem724) } } p.dedent() @@ -975,62 +984,62 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat719 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat719 != nil { - p.write(*flat719) + flat735 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat735 != nil { + p.write(*flat735) return nil } else { - _t1312 := func(_dollar_dollar *pb.Write) *pb.Define { - var _t1313 *pb.Define + _t1344 := func(_dollar_dollar *pb.Write) *pb.Define { + var _t1345 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1313 = _dollar_dollar.GetDefine() + _t1345 = _dollar_dollar.GetDefine() } - return _t1313 + return _t1345 } - _t1314 := _t1312(msg) - deconstruct_result717 := _t1314 - if deconstruct_result717 != nil { - unwrapped718 := deconstruct_result717 - p.pretty_define(unwrapped718) + _t1346 := _t1344(msg) + deconstruct_result733 := _t1346 + if deconstruct_result733 != nil { + unwrapped734 := deconstruct_result733 + p.pretty_define(unwrapped734) } else { - _t1315 := func(_dollar_dollar *pb.Write) *pb.Undefine { - var _t1316 *pb.Undefine + _t1347 := func(_dollar_dollar *pb.Write) *pb.Undefine { + var _t1348 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1316 = _dollar_dollar.GetUndefine() + _t1348 = _dollar_dollar.GetUndefine() } - return _t1316 + return _t1348 } - _t1317 := _t1315(msg) - deconstruct_result715 := _t1317 - if deconstruct_result715 != nil { - unwrapped716 := deconstruct_result715 - p.pretty_undefine(unwrapped716) + _t1349 := _t1347(msg) + deconstruct_result731 := _t1349 + if deconstruct_result731 != nil { + unwrapped732 := deconstruct_result731 + p.pretty_undefine(unwrapped732) } else { - _t1318 := func(_dollar_dollar *pb.Write) *pb.Context { - var _t1319 *pb.Context + _t1350 := func(_dollar_dollar *pb.Write) *pb.Context { + var _t1351 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1319 = _dollar_dollar.GetContext() + _t1351 = _dollar_dollar.GetContext() } - return _t1319 + return _t1351 } - _t1320 := _t1318(msg) - deconstruct_result713 := _t1320 - if deconstruct_result713 != nil { - unwrapped714 := deconstruct_result713 - p.pretty_context(unwrapped714) + _t1352 := _t1350(msg) + deconstruct_result729 := _t1352 + if deconstruct_result729 != nil { + unwrapped730 := deconstruct_result729 + p.pretty_context(unwrapped730) } else { - _t1321 := func(_dollar_dollar *pb.Write) *pb.Snapshot { - var _t1322 *pb.Snapshot + _t1353 := func(_dollar_dollar *pb.Write) *pb.Snapshot { + var _t1354 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1322 = _dollar_dollar.GetSnapshot() + _t1354 = _dollar_dollar.GetSnapshot() } - return _t1322 + return _t1354 } - _t1323 := _t1321(msg) - deconstruct_result711 := _t1323 - if deconstruct_result711 != nil { - unwrapped712 := deconstruct_result711 - p.pretty_snapshot(unwrapped712) + _t1355 := _t1353(msg) + deconstruct_result727 := _t1355 + if deconstruct_result727 != nil { + unwrapped728 := deconstruct_result727 + p.pretty_snapshot(unwrapped728) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1042,22 +1051,22 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat722 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat722 != nil { - p.write(*flat722) + flat738 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat738 != nil { + p.write(*flat738) return nil } else { - _t1324 := func(_dollar_dollar *pb.Define) *pb.Fragment { + _t1356 := func(_dollar_dollar *pb.Define) *pb.Fragment { return _dollar_dollar.GetFragment() } - _t1325 := _t1324(msg) - fields720 := _t1325 - unwrapped_fields721 := fields720 + _t1357 := _t1356(msg) + fields736 := _t1357 + unwrapped_fields737 := fields736 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields721) + p.pretty_fragment(unwrapped_fields737) p.dedent() p.write(")") } @@ -1065,32 +1074,32 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat729 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat729 != nil { - p.write(*flat729) + flat745 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat745 != nil { + p.write(*flat745) return nil } else { - _t1326 := func(_dollar_dollar *pb.Fragment) []interface{} { + _t1358 := func(_dollar_dollar *pb.Fragment) []interface{} { p.startPrettyFragment(_dollar_dollar) return []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} } - _t1327 := _t1326(msg) - fields723 := _t1327 - unwrapped_fields724 := fields723 + _t1359 := _t1358(msg) + fields739 := _t1359 + unwrapped_fields740 := fields739 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field725 := unwrapped_fields724[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field725) - field726 := unwrapped_fields724[1].([]*pb.Declaration) - if !(len(field726) == 0) { + field741 := unwrapped_fields740[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field741) + field742 := unwrapped_fields740[1].([]*pb.Declaration) + if !(len(field742) == 0) { p.newline() - for i728, elem727 := range field726 { - if (i728 > 0) { + for i744, elem743 := range field742 { + if (i744 > 0) { p.newline() } - p.pretty_declaration(elem727) + p.pretty_declaration(elem743) } } p.dedent() @@ -1100,74 +1109,74 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat731 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat731 != nil { - p.write(*flat731) + flat747 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat747 != nil { + p.write(*flat747) return nil } else { - fields730 := msg - p.pretty_fragment_id(fields730) + fields746 := msg + p.pretty_fragment_id(fields746) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat740 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat740 != nil { - p.write(*flat740) + flat756 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat756 != nil { + p.write(*flat756) return nil } else { - _t1328 := func(_dollar_dollar *pb.Declaration) *pb.Def { - var _t1329 *pb.Def + _t1360 := func(_dollar_dollar *pb.Declaration) *pb.Def { + var _t1361 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1329 = _dollar_dollar.GetDef() + _t1361 = _dollar_dollar.GetDef() } - return _t1329 + return _t1361 } - _t1330 := _t1328(msg) - deconstruct_result738 := _t1330 - if deconstruct_result738 != nil { - unwrapped739 := deconstruct_result738 - p.pretty_def(unwrapped739) + _t1362 := _t1360(msg) + deconstruct_result754 := _t1362 + if deconstruct_result754 != nil { + unwrapped755 := deconstruct_result754 + p.pretty_def(unwrapped755) } else { - _t1331 := func(_dollar_dollar *pb.Declaration) *pb.Algorithm { - var _t1332 *pb.Algorithm + _t1363 := func(_dollar_dollar *pb.Declaration) *pb.Algorithm { + var _t1364 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1332 = _dollar_dollar.GetAlgorithm() + _t1364 = _dollar_dollar.GetAlgorithm() } - return _t1332 + return _t1364 } - _t1333 := _t1331(msg) - deconstruct_result736 := _t1333 - if deconstruct_result736 != nil { - unwrapped737 := deconstruct_result736 - p.pretty_algorithm(unwrapped737) + _t1365 := _t1363(msg) + deconstruct_result752 := _t1365 + if deconstruct_result752 != nil { + unwrapped753 := deconstruct_result752 + p.pretty_algorithm(unwrapped753) } else { - _t1334 := func(_dollar_dollar *pb.Declaration) *pb.Constraint { - var _t1335 *pb.Constraint + _t1366 := func(_dollar_dollar *pb.Declaration) *pb.Constraint { + var _t1367 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1335 = _dollar_dollar.GetConstraint() + _t1367 = _dollar_dollar.GetConstraint() } - return _t1335 + return _t1367 } - _t1336 := _t1334(msg) - deconstruct_result734 := _t1336 - if deconstruct_result734 != nil { - unwrapped735 := deconstruct_result734 - p.pretty_constraint(unwrapped735) + _t1368 := _t1366(msg) + deconstruct_result750 := _t1368 + if deconstruct_result750 != nil { + unwrapped751 := deconstruct_result750 + p.pretty_constraint(unwrapped751) } else { - _t1337 := func(_dollar_dollar *pb.Declaration) *pb.Data { - var _t1338 *pb.Data + _t1369 := func(_dollar_dollar *pb.Declaration) *pb.Data { + var _t1370 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1338 = _dollar_dollar.GetData() + _t1370 = _dollar_dollar.GetData() } - return _t1338 + return _t1370 } - _t1339 := _t1337(msg) - deconstruct_result732 := _t1339 - if deconstruct_result732 != nil { - unwrapped733 := deconstruct_result732 - p.pretty_data(unwrapped733) + _t1371 := _t1369(msg) + deconstruct_result748 := _t1371 + if deconstruct_result748 != nil { + unwrapped749 := deconstruct_result748 + p.pretty_data(unwrapped749) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1179,35 +1188,35 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat747 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat747 != nil { - p.write(*flat747) + flat763 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat763 != nil { + p.write(*flat763) return nil } else { - _t1340 := func(_dollar_dollar *pb.Def) []interface{} { - var _t1341 []*pb.Attribute + _t1372 := func(_dollar_dollar *pb.Def) []interface{} { + var _t1373 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1341 = _dollar_dollar.GetAttrs() + _t1373 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1341} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1373} } - _t1342 := _t1340(msg) - fields741 := _t1342 - unwrapped_fields742 := fields741 + _t1374 := _t1372(msg) + fields757 := _t1374 + unwrapped_fields758 := fields757 p.write("(") p.write("def") p.indentSexp() p.newline() - field743 := unwrapped_fields742[0].(*pb.RelationId) - p.pretty_relation_id(field743) + field759 := unwrapped_fields758[0].(*pb.RelationId) + p.pretty_relation_id(field759) p.newline() - field744 := unwrapped_fields742[1].(*pb.Abstraction) - p.pretty_abstraction(field744) - field745 := unwrapped_fields742[2].([]*pb.Attribute) - if field745 != nil { + field760 := unwrapped_fields758[1].(*pb.Abstraction) + p.pretty_abstraction(field760) + field761 := unwrapped_fields758[2].([]*pb.Attribute) + if field761 != nil { p.newline() - opt_val746 := field745 - p.pretty_attrs(opt_val746) + opt_val762 := field761 + p.pretty_attrs(opt_val762) } p.dedent() p.write(")") @@ -1216,35 +1225,35 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat752 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat752 != nil { - p.write(*flat752) + flat768 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat768 != nil { + p.write(*flat768) return nil } else { - _t1343 := func(_dollar_dollar *pb.RelationId) *string { - var _t1344 *string + _t1375 := func(_dollar_dollar *pb.RelationId) *string { + var _t1376 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1345 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1344 = ptr(_t1345) + _t1377 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1376 = ptr(_t1377) } - return _t1344 + return _t1376 } - _t1346 := _t1343(msg) - deconstruct_result750 := _t1346 - if deconstruct_result750 != nil { - unwrapped751 := *deconstruct_result750 + _t1378 := _t1375(msg) + deconstruct_result766 := _t1378 + if deconstruct_result766 != nil { + unwrapped767 := *deconstruct_result766 p.write(":") - p.write(unwrapped751) + p.write(unwrapped767) } else { - _t1347 := func(_dollar_dollar *pb.RelationId) *pb.UInt128Value { - _t1348 := p.deconstruct_relation_id_uint128(_dollar_dollar) - return _t1348 + _t1379 := func(_dollar_dollar *pb.RelationId) *pb.UInt128Value { + _t1380 := p.deconstruct_relation_id_uint128(_dollar_dollar) + return _t1380 } - _t1349 := _t1347(msg) - deconstruct_result748 := _t1349 - if deconstruct_result748 != nil { - unwrapped749 := deconstruct_result748 - p.write(p.formatUint128(unwrapped749)) + _t1381 := _t1379(msg) + deconstruct_result764 := _t1381 + if deconstruct_result764 != nil { + unwrapped765 := deconstruct_result764 + p.write(p.formatUint128(unwrapped765)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1254,25 +1263,25 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat757 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat757 != nil { - p.write(*flat757) + flat773 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat773 != nil { + p.write(*flat773) return nil } else { - _t1350 := func(_dollar_dollar *pb.Abstraction) []interface{} { - _t1351 := p.deconstruct_bindings(_dollar_dollar) - return []interface{}{_t1351, _dollar_dollar.GetValue()} + _t1382 := func(_dollar_dollar *pb.Abstraction) []interface{} { + _t1383 := p.deconstruct_bindings(_dollar_dollar) + return []interface{}{_t1383, _dollar_dollar.GetValue()} } - _t1352 := _t1350(msg) - fields753 := _t1352 - unwrapped_fields754 := fields753 + _t1384 := _t1382(msg) + fields769 := _t1384 + unwrapped_fields770 := fields769 p.write("(") p.indent() - field755 := unwrapped_fields754[0].([]interface{}) - p.pretty_bindings(field755) + field771 := unwrapped_fields770[0].([]interface{}) + p.pretty_bindings(field771) p.newline() - field756 := unwrapped_fields754[1].(*pb.Formula) - p.pretty_formula(field756) + field772 := unwrapped_fields770[1].(*pb.Formula) + p.pretty_formula(field772) p.dedent() p.write(")") } @@ -1280,35 +1289,35 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat765 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat765 != nil { - p.write(*flat765) + flat781 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat781 != nil { + p.write(*flat781) return nil } else { - _t1353 := func(_dollar_dollar []interface{}) []interface{} { - var _t1354 []*pb.Binding + _t1385 := func(_dollar_dollar []interface{}) []interface{} { + var _t1386 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1354 = _dollar_dollar[1].([]*pb.Binding) + _t1386 = _dollar_dollar[1].([]*pb.Binding) } - return []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1354} + return []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1386} } - _t1355 := _t1353(msg) - fields758 := _t1355 - unwrapped_fields759 := fields758 + _t1387 := _t1385(msg) + fields774 := _t1387 + unwrapped_fields775 := fields774 p.write("[") p.indent() - field760 := unwrapped_fields759[0].([]*pb.Binding) - for i762, elem761 := range field760 { - if (i762 > 0) { + field776 := unwrapped_fields775[0].([]*pb.Binding) + for i778, elem777 := range field776 { + if (i778 > 0) { p.newline() } - p.pretty_binding(elem761) + p.pretty_binding(elem777) } - field763 := unwrapped_fields759[1].([]*pb.Binding) - if field763 != nil { + field779 := unwrapped_fields775[1].([]*pb.Binding) + if field779 != nil { p.newline() - opt_val764 := field763 - p.pretty_value_bindings(opt_val764) + opt_val780 := field779 + p.pretty_value_bindings(opt_val780) } p.dedent() p.write("]") @@ -1317,174 +1326,174 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat770 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat770 != nil { - p.write(*flat770) + flat786 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat786 != nil { + p.write(*flat786) return nil } else { - _t1356 := func(_dollar_dollar *pb.Binding) []interface{} { + _t1388 := func(_dollar_dollar *pb.Binding) []interface{} { return []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} } - _t1357 := _t1356(msg) - fields766 := _t1357 - unwrapped_fields767 := fields766 - field768 := unwrapped_fields767[0].(string) - p.write(field768) + _t1389 := _t1388(msg) + fields782 := _t1389 + unwrapped_fields783 := fields782 + field784 := unwrapped_fields783[0].(string) + p.write(field784) p.write("::") - field769 := unwrapped_fields767[1].(*pb.Type) - p.pretty_type(field769) + field785 := unwrapped_fields783[1].(*pb.Type) + p.pretty_type(field785) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat793 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat793 != nil { - p.write(*flat793) + flat809 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat809 != nil { + p.write(*flat809) return nil } else { - _t1358 := func(_dollar_dollar *pb.Type) *pb.UnspecifiedType { - var _t1359 *pb.UnspecifiedType + _t1390 := func(_dollar_dollar *pb.Type) *pb.UnspecifiedType { + var _t1391 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1359 = _dollar_dollar.GetUnspecifiedType() + _t1391 = _dollar_dollar.GetUnspecifiedType() } - return _t1359 + return _t1391 } - _t1360 := _t1358(msg) - deconstruct_result791 := _t1360 - if deconstruct_result791 != nil { - unwrapped792 := deconstruct_result791 - p.pretty_unspecified_type(unwrapped792) + _t1392 := _t1390(msg) + deconstruct_result807 := _t1392 + if deconstruct_result807 != nil { + unwrapped808 := deconstruct_result807 + p.pretty_unspecified_type(unwrapped808) } else { - _t1361 := func(_dollar_dollar *pb.Type) *pb.StringType { - var _t1362 *pb.StringType + _t1393 := func(_dollar_dollar *pb.Type) *pb.StringType { + var _t1394 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1362 = _dollar_dollar.GetStringType() + _t1394 = _dollar_dollar.GetStringType() } - return _t1362 + return _t1394 } - _t1363 := _t1361(msg) - deconstruct_result789 := _t1363 - if deconstruct_result789 != nil { - unwrapped790 := deconstruct_result789 - p.pretty_string_type(unwrapped790) + _t1395 := _t1393(msg) + deconstruct_result805 := _t1395 + if deconstruct_result805 != nil { + unwrapped806 := deconstruct_result805 + p.pretty_string_type(unwrapped806) } else { - _t1364 := func(_dollar_dollar *pb.Type) *pb.IntType { - var _t1365 *pb.IntType + _t1396 := func(_dollar_dollar *pb.Type) *pb.IntType { + var _t1397 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1365 = _dollar_dollar.GetIntType() + _t1397 = _dollar_dollar.GetIntType() } - return _t1365 + return _t1397 } - _t1366 := _t1364(msg) - deconstruct_result787 := _t1366 - if deconstruct_result787 != nil { - unwrapped788 := deconstruct_result787 - p.pretty_int_type(unwrapped788) + _t1398 := _t1396(msg) + deconstruct_result803 := _t1398 + if deconstruct_result803 != nil { + unwrapped804 := deconstruct_result803 + p.pretty_int_type(unwrapped804) } else { - _t1367 := func(_dollar_dollar *pb.Type) *pb.FloatType { - var _t1368 *pb.FloatType + _t1399 := func(_dollar_dollar *pb.Type) *pb.FloatType { + var _t1400 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1368 = _dollar_dollar.GetFloatType() + _t1400 = _dollar_dollar.GetFloatType() } - return _t1368 + return _t1400 } - _t1369 := _t1367(msg) - deconstruct_result785 := _t1369 - if deconstruct_result785 != nil { - unwrapped786 := deconstruct_result785 - p.pretty_float_type(unwrapped786) + _t1401 := _t1399(msg) + deconstruct_result801 := _t1401 + if deconstruct_result801 != nil { + unwrapped802 := deconstruct_result801 + p.pretty_float_type(unwrapped802) } else { - _t1370 := func(_dollar_dollar *pb.Type) *pb.UInt128Type { - var _t1371 *pb.UInt128Type + _t1402 := func(_dollar_dollar *pb.Type) *pb.UInt128Type { + var _t1403 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1371 = _dollar_dollar.GetUint128Type() + _t1403 = _dollar_dollar.GetUint128Type() } - return _t1371 + return _t1403 } - _t1372 := _t1370(msg) - deconstruct_result783 := _t1372 - if deconstruct_result783 != nil { - unwrapped784 := deconstruct_result783 - p.pretty_uint128_type(unwrapped784) + _t1404 := _t1402(msg) + deconstruct_result799 := _t1404 + if deconstruct_result799 != nil { + unwrapped800 := deconstruct_result799 + p.pretty_uint128_type(unwrapped800) } else { - _t1373 := func(_dollar_dollar *pb.Type) *pb.Int128Type { - var _t1374 *pb.Int128Type + _t1405 := func(_dollar_dollar *pb.Type) *pb.Int128Type { + var _t1406 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1374 = _dollar_dollar.GetInt128Type() + _t1406 = _dollar_dollar.GetInt128Type() } - return _t1374 + return _t1406 } - _t1375 := _t1373(msg) - deconstruct_result781 := _t1375 - if deconstruct_result781 != nil { - unwrapped782 := deconstruct_result781 - p.pretty_int128_type(unwrapped782) + _t1407 := _t1405(msg) + deconstruct_result797 := _t1407 + if deconstruct_result797 != nil { + unwrapped798 := deconstruct_result797 + p.pretty_int128_type(unwrapped798) } else { - _t1376 := func(_dollar_dollar *pb.Type) *pb.DateType { - var _t1377 *pb.DateType + _t1408 := func(_dollar_dollar *pb.Type) *pb.DateType { + var _t1409 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1377 = _dollar_dollar.GetDateType() + _t1409 = _dollar_dollar.GetDateType() } - return _t1377 + return _t1409 } - _t1378 := _t1376(msg) - deconstruct_result779 := _t1378 - if deconstruct_result779 != nil { - unwrapped780 := deconstruct_result779 - p.pretty_date_type(unwrapped780) + _t1410 := _t1408(msg) + deconstruct_result795 := _t1410 + if deconstruct_result795 != nil { + unwrapped796 := deconstruct_result795 + p.pretty_date_type(unwrapped796) } else { - _t1379 := func(_dollar_dollar *pb.Type) *pb.DateTimeType { - var _t1380 *pb.DateTimeType + _t1411 := func(_dollar_dollar *pb.Type) *pb.DateTimeType { + var _t1412 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1380 = _dollar_dollar.GetDatetimeType() + _t1412 = _dollar_dollar.GetDatetimeType() } - return _t1380 + return _t1412 } - _t1381 := _t1379(msg) - deconstruct_result777 := _t1381 - if deconstruct_result777 != nil { - unwrapped778 := deconstruct_result777 - p.pretty_datetime_type(unwrapped778) + _t1413 := _t1411(msg) + deconstruct_result793 := _t1413 + if deconstruct_result793 != nil { + unwrapped794 := deconstruct_result793 + p.pretty_datetime_type(unwrapped794) } else { - _t1382 := func(_dollar_dollar *pb.Type) *pb.MissingType { - var _t1383 *pb.MissingType + _t1414 := func(_dollar_dollar *pb.Type) *pb.MissingType { + var _t1415 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1383 = _dollar_dollar.GetMissingType() + _t1415 = _dollar_dollar.GetMissingType() } - return _t1383 + return _t1415 } - _t1384 := _t1382(msg) - deconstruct_result775 := _t1384 - if deconstruct_result775 != nil { - unwrapped776 := deconstruct_result775 - p.pretty_missing_type(unwrapped776) + _t1416 := _t1414(msg) + deconstruct_result791 := _t1416 + if deconstruct_result791 != nil { + unwrapped792 := deconstruct_result791 + p.pretty_missing_type(unwrapped792) } else { - _t1385 := func(_dollar_dollar *pb.Type) *pb.DecimalType { - var _t1386 *pb.DecimalType + _t1417 := func(_dollar_dollar *pb.Type) *pb.DecimalType { + var _t1418 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1386 = _dollar_dollar.GetDecimalType() + _t1418 = _dollar_dollar.GetDecimalType() } - return _t1386 + return _t1418 } - _t1387 := _t1385(msg) - deconstruct_result773 := _t1387 - if deconstruct_result773 != nil { - unwrapped774 := deconstruct_result773 - p.pretty_decimal_type(unwrapped774) + _t1419 := _t1417(msg) + deconstruct_result789 := _t1419 + if deconstruct_result789 != nil { + unwrapped790 := deconstruct_result789 + p.pretty_decimal_type(unwrapped790) } else { - _t1388 := func(_dollar_dollar *pb.Type) *pb.BooleanType { - var _t1389 *pb.BooleanType + _t1420 := func(_dollar_dollar *pb.Type) *pb.BooleanType { + var _t1421 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1389 = _dollar_dollar.GetBooleanType() + _t1421 = _dollar_dollar.GetBooleanType() } - return _t1389 + return _t1421 } - _t1390 := _t1388(msg) - deconstruct_result771 := _t1390 - if deconstruct_result771 != nil { - unwrapped772 := deconstruct_result771 - p.pretty_boolean_type(unwrapped772) + _t1422 := _t1420(msg) + deconstruct_result787 := _t1422 + if deconstruct_result787 != nil { + unwrapped788 := deconstruct_result787 + p.pretty_boolean_type(unwrapped788) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1503,89 +1512,89 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields794 := msg - _ = fields794 + fields810 := msg + _ = fields810 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields795 := msg - _ = fields795 + fields811 := msg + _ = fields811 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields796 := msg - _ = fields796 + fields812 := msg + _ = fields812 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields797 := msg - _ = fields797 + fields813 := msg + _ = fields813 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields798 := msg - _ = fields798 + fields814 := msg + _ = fields814 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields799 := msg - _ = fields799 + fields815 := msg + _ = fields815 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields800 := msg - _ = fields800 + fields816 := msg + _ = fields816 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields801 := msg - _ = fields801 + fields817 := msg + _ = fields817 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields802 := msg - _ = fields802 + fields818 := msg + _ = fields818 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat807 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat807 != nil { - p.write(*flat807) + flat823 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat823 != nil { + p.write(*flat823) return nil } else { - _t1391 := func(_dollar_dollar *pb.DecimalType) []interface{} { + _t1423 := func(_dollar_dollar *pb.DecimalType) []interface{} { return []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} } - _t1392 := _t1391(msg) - fields803 := _t1392 - unwrapped_fields804 := fields803 + _t1424 := _t1423(msg) + fields819 := _t1424 + unwrapped_fields820 := fields819 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field805 := unwrapped_fields804[0].(int64) - p.write(fmt.Sprintf("%d", field805)) + field821 := unwrapped_fields820[0].(int64) + p.write(fmt.Sprintf("%d", field821)) p.newline() - field806 := unwrapped_fields804[1].(int64) - p.write(fmt.Sprintf("%d", field806)) + field822 := unwrapped_fields820[1].(int64) + p.write(fmt.Sprintf("%d", field822)) p.dedent() p.write(")") } @@ -1593,27 +1602,27 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields808 := msg - _ = fields808 + fields824 := msg + _ = fields824 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat812 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat812 != nil { - p.write(*flat812) + flat828 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat828 != nil { + p.write(*flat828) return nil } else { - fields809 := msg + fields825 := msg p.write("|") - if !(len(fields809) == 0) { + if !(len(fields825) == 0) { p.write(" ") - for i811, elem810 := range fields809 { - if (i811 > 0) { + for i827, elem826 := range fields825 { + if (i827 > 0) { p.newline() } - p.pretty_binding(elem810) + p.pretty_binding(elem826) } } } @@ -1621,179 +1630,179 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat839 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat839 != nil { - p.write(*flat839) + flat855 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat855 != nil { + p.write(*flat855) return nil } else { - _t1393 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { - var _t1394 *pb.Conjunction + _t1425 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { + var _t1426 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1394 = _dollar_dollar.GetConjunction() + _t1426 = _dollar_dollar.GetConjunction() } - return _t1394 + return _t1426 } - _t1395 := _t1393(msg) - deconstruct_result837 := _t1395 - if deconstruct_result837 != nil { - unwrapped838 := deconstruct_result837 - p.pretty_true(unwrapped838) + _t1427 := _t1425(msg) + deconstruct_result853 := _t1427 + if deconstruct_result853 != nil { + unwrapped854 := deconstruct_result853 + p.pretty_true(unwrapped854) } else { - _t1396 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { - var _t1397 *pb.Disjunction + _t1428 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { + var _t1429 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1397 = _dollar_dollar.GetDisjunction() + _t1429 = _dollar_dollar.GetDisjunction() } - return _t1397 + return _t1429 } - _t1398 := _t1396(msg) - deconstruct_result835 := _t1398 - if deconstruct_result835 != nil { - unwrapped836 := deconstruct_result835 - p.pretty_false(unwrapped836) + _t1430 := _t1428(msg) + deconstruct_result851 := _t1430 + if deconstruct_result851 != nil { + unwrapped852 := deconstruct_result851 + p.pretty_false(unwrapped852) } else { - _t1399 := func(_dollar_dollar *pb.Formula) *pb.Exists { - var _t1400 *pb.Exists + _t1431 := func(_dollar_dollar *pb.Formula) *pb.Exists { + var _t1432 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1400 = _dollar_dollar.GetExists() + _t1432 = _dollar_dollar.GetExists() } - return _t1400 + return _t1432 } - _t1401 := _t1399(msg) - deconstruct_result833 := _t1401 - if deconstruct_result833 != nil { - unwrapped834 := deconstruct_result833 - p.pretty_exists(unwrapped834) + _t1433 := _t1431(msg) + deconstruct_result849 := _t1433 + if deconstruct_result849 != nil { + unwrapped850 := deconstruct_result849 + p.pretty_exists(unwrapped850) } else { - _t1402 := func(_dollar_dollar *pb.Formula) *pb.Reduce { - var _t1403 *pb.Reduce + _t1434 := func(_dollar_dollar *pb.Formula) *pb.Reduce { + var _t1435 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1403 = _dollar_dollar.GetReduce() + _t1435 = _dollar_dollar.GetReduce() } - return _t1403 + return _t1435 } - _t1404 := _t1402(msg) - deconstruct_result831 := _t1404 - if deconstruct_result831 != nil { - unwrapped832 := deconstruct_result831 - p.pretty_reduce(unwrapped832) + _t1436 := _t1434(msg) + deconstruct_result847 := _t1436 + if deconstruct_result847 != nil { + unwrapped848 := deconstruct_result847 + p.pretty_reduce(unwrapped848) } else { - _t1405 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { - var _t1406 *pb.Conjunction + _t1437 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { + var _t1438 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1406 = _dollar_dollar.GetConjunction() + _t1438 = _dollar_dollar.GetConjunction() } - return _t1406 + return _t1438 } - _t1407 := _t1405(msg) - deconstruct_result829 := _t1407 - if deconstruct_result829 != nil { - unwrapped830 := deconstruct_result829 - p.pretty_conjunction(unwrapped830) + _t1439 := _t1437(msg) + deconstruct_result845 := _t1439 + if deconstruct_result845 != nil { + unwrapped846 := deconstruct_result845 + p.pretty_conjunction(unwrapped846) } else { - _t1408 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { - var _t1409 *pb.Disjunction + _t1440 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { + var _t1441 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1409 = _dollar_dollar.GetDisjunction() + _t1441 = _dollar_dollar.GetDisjunction() } - return _t1409 + return _t1441 } - _t1410 := _t1408(msg) - deconstruct_result827 := _t1410 - if deconstruct_result827 != nil { - unwrapped828 := deconstruct_result827 - p.pretty_disjunction(unwrapped828) + _t1442 := _t1440(msg) + deconstruct_result843 := _t1442 + if deconstruct_result843 != nil { + unwrapped844 := deconstruct_result843 + p.pretty_disjunction(unwrapped844) } else { - _t1411 := func(_dollar_dollar *pb.Formula) *pb.Not { - var _t1412 *pb.Not + _t1443 := func(_dollar_dollar *pb.Formula) *pb.Not { + var _t1444 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1412 = _dollar_dollar.GetNot() + _t1444 = _dollar_dollar.GetNot() } - return _t1412 + return _t1444 } - _t1413 := _t1411(msg) - deconstruct_result825 := _t1413 - if deconstruct_result825 != nil { - unwrapped826 := deconstruct_result825 - p.pretty_not(unwrapped826) + _t1445 := _t1443(msg) + deconstruct_result841 := _t1445 + if deconstruct_result841 != nil { + unwrapped842 := deconstruct_result841 + p.pretty_not(unwrapped842) } else { - _t1414 := func(_dollar_dollar *pb.Formula) *pb.FFI { - var _t1415 *pb.FFI + _t1446 := func(_dollar_dollar *pb.Formula) *pb.FFI { + var _t1447 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1415 = _dollar_dollar.GetFfi() + _t1447 = _dollar_dollar.GetFfi() } - return _t1415 + return _t1447 } - _t1416 := _t1414(msg) - deconstruct_result823 := _t1416 - if deconstruct_result823 != nil { - unwrapped824 := deconstruct_result823 - p.pretty_ffi(unwrapped824) + _t1448 := _t1446(msg) + deconstruct_result839 := _t1448 + if deconstruct_result839 != nil { + unwrapped840 := deconstruct_result839 + p.pretty_ffi(unwrapped840) } else { - _t1417 := func(_dollar_dollar *pb.Formula) *pb.Atom { - var _t1418 *pb.Atom + _t1449 := func(_dollar_dollar *pb.Formula) *pb.Atom { + var _t1450 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1418 = _dollar_dollar.GetAtom() + _t1450 = _dollar_dollar.GetAtom() } - return _t1418 + return _t1450 } - _t1419 := _t1417(msg) - deconstruct_result821 := _t1419 - if deconstruct_result821 != nil { - unwrapped822 := deconstruct_result821 - p.pretty_atom(unwrapped822) + _t1451 := _t1449(msg) + deconstruct_result837 := _t1451 + if deconstruct_result837 != nil { + unwrapped838 := deconstruct_result837 + p.pretty_atom(unwrapped838) } else { - _t1420 := func(_dollar_dollar *pb.Formula) *pb.Pragma { - var _t1421 *pb.Pragma + _t1452 := func(_dollar_dollar *pb.Formula) *pb.Pragma { + var _t1453 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1421 = _dollar_dollar.GetPragma() + _t1453 = _dollar_dollar.GetPragma() } - return _t1421 + return _t1453 } - _t1422 := _t1420(msg) - deconstruct_result819 := _t1422 - if deconstruct_result819 != nil { - unwrapped820 := deconstruct_result819 - p.pretty_pragma(unwrapped820) + _t1454 := _t1452(msg) + deconstruct_result835 := _t1454 + if deconstruct_result835 != nil { + unwrapped836 := deconstruct_result835 + p.pretty_pragma(unwrapped836) } else { - _t1423 := func(_dollar_dollar *pb.Formula) *pb.Primitive { - var _t1424 *pb.Primitive + _t1455 := func(_dollar_dollar *pb.Formula) *pb.Primitive { + var _t1456 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1424 = _dollar_dollar.GetPrimitive() + _t1456 = _dollar_dollar.GetPrimitive() } - return _t1424 + return _t1456 } - _t1425 := _t1423(msg) - deconstruct_result817 := _t1425 - if deconstruct_result817 != nil { - unwrapped818 := deconstruct_result817 - p.pretty_primitive(unwrapped818) + _t1457 := _t1455(msg) + deconstruct_result833 := _t1457 + if deconstruct_result833 != nil { + unwrapped834 := deconstruct_result833 + p.pretty_primitive(unwrapped834) } else { - _t1426 := func(_dollar_dollar *pb.Formula) *pb.RelAtom { - var _t1427 *pb.RelAtom + _t1458 := func(_dollar_dollar *pb.Formula) *pb.RelAtom { + var _t1459 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1427 = _dollar_dollar.GetRelAtom() + _t1459 = _dollar_dollar.GetRelAtom() } - return _t1427 + return _t1459 } - _t1428 := _t1426(msg) - deconstruct_result815 := _t1428 - if deconstruct_result815 != nil { - unwrapped816 := deconstruct_result815 - p.pretty_rel_atom(unwrapped816) + _t1460 := _t1458(msg) + deconstruct_result831 := _t1460 + if deconstruct_result831 != nil { + unwrapped832 := deconstruct_result831 + p.pretty_rel_atom(unwrapped832) } else { - _t1429 := func(_dollar_dollar *pb.Formula) *pb.Cast { - var _t1430 *pb.Cast + _t1461 := func(_dollar_dollar *pb.Formula) *pb.Cast { + var _t1462 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1430 = _dollar_dollar.GetCast() + _t1462 = _dollar_dollar.GetCast() } - return _t1430 + return _t1462 } - _t1431 := _t1429(msg) - deconstruct_result813 := _t1431 - if deconstruct_result813 != nil { - unwrapped814 := deconstruct_result813 - p.pretty_cast(unwrapped814) + _t1463 := _t1461(msg) + deconstruct_result829 := _t1463 + if deconstruct_result829 != nil { + unwrapped830 := deconstruct_result829 + p.pretty_cast(unwrapped830) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1814,8 +1823,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields840 := msg - _ = fields840 + fields856 := msg + _ = fields856 p.write("(") p.write("true") p.write(")") @@ -1823,8 +1832,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields841 := msg - _ = fields841 + fields857 := msg + _ = fields857 p.write("(") p.write("false") p.write(")") @@ -1832,27 +1841,27 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat846 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat846 != nil { - p.write(*flat846) + flat862 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat862 != nil { + p.write(*flat862) return nil } else { - _t1432 := func(_dollar_dollar *pb.Exists) []interface{} { - _t1433 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - return []interface{}{_t1433, _dollar_dollar.GetBody().GetValue()} + _t1464 := func(_dollar_dollar *pb.Exists) []interface{} { + _t1465 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + return []interface{}{_t1465, _dollar_dollar.GetBody().GetValue()} } - _t1434 := _t1432(msg) - fields842 := _t1434 - unwrapped_fields843 := fields842 + _t1466 := _t1464(msg) + fields858 := _t1466 + unwrapped_fields859 := fields858 p.write("(") p.write("exists") p.indentSexp() p.newline() - field844 := unwrapped_fields843[0].([]interface{}) - p.pretty_bindings(field844) + field860 := unwrapped_fields859[0].([]interface{}) + p.pretty_bindings(field860) p.newline() - field845 := unwrapped_fields843[1].(*pb.Formula) - p.pretty_formula(field845) + field861 := unwrapped_fields859[1].(*pb.Formula) + p.pretty_formula(field861) p.dedent() p.write(")") } @@ -1860,29 +1869,29 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat852 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat852 != nil { - p.write(*flat852) + flat868 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat868 != nil { + p.write(*flat868) return nil } else { - _t1435 := func(_dollar_dollar *pb.Reduce) []interface{} { + _t1467 := func(_dollar_dollar *pb.Reduce) []interface{} { return []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} } - _t1436 := _t1435(msg) - fields847 := _t1436 - unwrapped_fields848 := fields847 + _t1468 := _t1467(msg) + fields863 := _t1468 + unwrapped_fields864 := fields863 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field849 := unwrapped_fields848[0].(*pb.Abstraction) - p.pretty_abstraction(field849) + field865 := unwrapped_fields864[0].(*pb.Abstraction) + p.pretty_abstraction(field865) p.newline() - field850 := unwrapped_fields848[1].(*pb.Abstraction) - p.pretty_abstraction(field850) + field866 := unwrapped_fields864[1].(*pb.Abstraction) + p.pretty_abstraction(field866) p.newline() - field851 := unwrapped_fields848[2].([]*pb.Term) - p.pretty_terms(field851) + field867 := unwrapped_fields864[2].([]*pb.Term) + p.pretty_terms(field867) p.dedent() p.write(")") } @@ -1890,22 +1899,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat856 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat856 != nil { - p.write(*flat856) + flat872 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat872 != nil { + p.write(*flat872) return nil } else { - fields853 := msg + fields869 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields853) == 0) { + if !(len(fields869) == 0) { p.newline() - for i855, elem854 := range fields853 { - if (i855 > 0) { + for i871, elem870 := range fields869 { + if (i871 > 0) { p.newline() } - p.pretty_term(elem854) + p.pretty_term(elem870) } } p.dedent() @@ -1915,36 +1924,36 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat861 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat861 != nil { - p.write(*flat861) + flat877 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat877 != nil { + p.write(*flat877) return nil } else { - _t1437 := func(_dollar_dollar *pb.Term) *pb.Var { - var _t1438 *pb.Var + _t1469 := func(_dollar_dollar *pb.Term) *pb.Var { + var _t1470 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1438 = _dollar_dollar.GetVar() + _t1470 = _dollar_dollar.GetVar() } - return _t1438 + return _t1470 } - _t1439 := _t1437(msg) - deconstruct_result859 := _t1439 - if deconstruct_result859 != nil { - unwrapped860 := deconstruct_result859 - p.pretty_var(unwrapped860) + _t1471 := _t1469(msg) + deconstruct_result875 := _t1471 + if deconstruct_result875 != nil { + unwrapped876 := deconstruct_result875 + p.pretty_var(unwrapped876) } else { - _t1440 := func(_dollar_dollar *pb.Term) *pb.Value { - var _t1441 *pb.Value + _t1472 := func(_dollar_dollar *pb.Term) *pb.Value { + var _t1473 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1441 = _dollar_dollar.GetConstant() + _t1473 = _dollar_dollar.GetConstant() } - return _t1441 + return _t1473 } - _t1442 := _t1440(msg) - deconstruct_result857 := _t1442 - if deconstruct_result857 != nil { - unwrapped858 := deconstruct_result857 - p.pretty_constant(unwrapped858) + _t1474 := _t1472(msg) + deconstruct_result873 := _t1474 + if deconstruct_result873 != nil { + unwrapped874 := deconstruct_result873 + p.pretty_constant(unwrapped874) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1954,56 +1963,56 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat864 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat864 != nil { - p.write(*flat864) + flat880 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat880 != nil { + p.write(*flat880) return nil } else { - _t1443 := func(_dollar_dollar *pb.Var) string { + _t1475 := func(_dollar_dollar *pb.Var) string { return _dollar_dollar.GetName() } - _t1444 := _t1443(msg) - fields862 := _t1444 - unwrapped_fields863 := fields862 - p.write(unwrapped_fields863) + _t1476 := _t1475(msg) + fields878 := _t1476 + unwrapped_fields879 := fields878 + p.write(unwrapped_fields879) } return nil } func (p *PrettyPrinter) pretty_constant(msg *pb.Value) interface{} { - flat866 := p.tryFlat(msg, func() { p.pretty_constant(msg) }) - if flat866 != nil { - p.write(*flat866) + flat882 := p.tryFlat(msg, func() { p.pretty_constant(msg) }) + if flat882 != nil { + p.write(*flat882) return nil } else { - fields865 := msg - p.pretty_value(fields865) + fields881 := msg + p.pretty_value(fields881) } return nil } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat871 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat871 != nil { - p.write(*flat871) + flat887 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat887 != nil { + p.write(*flat887) return nil } else { - _t1445 := func(_dollar_dollar *pb.Conjunction) []*pb.Formula { + _t1477 := func(_dollar_dollar *pb.Conjunction) []*pb.Formula { return _dollar_dollar.GetArgs() } - _t1446 := _t1445(msg) - fields867 := _t1446 - unwrapped_fields868 := fields867 + _t1478 := _t1477(msg) + fields883 := _t1478 + unwrapped_fields884 := fields883 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields868) == 0) { + if !(len(unwrapped_fields884) == 0) { p.newline() - for i870, elem869 := range unwrapped_fields868 { - if (i870 > 0) { + for i886, elem885 := range unwrapped_fields884 { + if (i886 > 0) { p.newline() } - p.pretty_formula(elem869) + p.pretty_formula(elem885) } } p.dedent() @@ -2013,27 +2022,27 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat876 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat876 != nil { - p.write(*flat876) + flat892 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat892 != nil { + p.write(*flat892) return nil } else { - _t1447 := func(_dollar_dollar *pb.Disjunction) []*pb.Formula { + _t1479 := func(_dollar_dollar *pb.Disjunction) []*pb.Formula { return _dollar_dollar.GetArgs() } - _t1448 := _t1447(msg) - fields872 := _t1448 - unwrapped_fields873 := fields872 + _t1480 := _t1479(msg) + fields888 := _t1480 + unwrapped_fields889 := fields888 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields873) == 0) { + if !(len(unwrapped_fields889) == 0) { p.newline() - for i875, elem874 := range unwrapped_fields873 { - if (i875 > 0) { + for i891, elem890 := range unwrapped_fields889 { + if (i891 > 0) { p.newline() } - p.pretty_formula(elem874) + p.pretty_formula(elem890) } } p.dedent() @@ -2043,22 +2052,22 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat879 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat879 != nil { - p.write(*flat879) + flat895 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat895 != nil { + p.write(*flat895) return nil } else { - _t1449 := func(_dollar_dollar *pb.Not) *pb.Formula { + _t1481 := func(_dollar_dollar *pb.Not) *pb.Formula { return _dollar_dollar.GetArg() } - _t1450 := _t1449(msg) - fields877 := _t1450 - unwrapped_fields878 := fields877 + _t1482 := _t1481(msg) + fields893 := _t1482 + unwrapped_fields894 := fields893 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields878) + p.pretty_formula(unwrapped_fields894) p.dedent() p.write(")") } @@ -2066,29 +2075,29 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat885 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat885 != nil { - p.write(*flat885) + flat901 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat901 != nil { + p.write(*flat901) return nil } else { - _t1451 := func(_dollar_dollar *pb.FFI) []interface{} { + _t1483 := func(_dollar_dollar *pb.FFI) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} } - _t1452 := _t1451(msg) - fields880 := _t1452 - unwrapped_fields881 := fields880 + _t1484 := _t1483(msg) + fields896 := _t1484 + unwrapped_fields897 := fields896 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field882 := unwrapped_fields881[0].(string) - p.pretty_name(field882) + field898 := unwrapped_fields897[0].(string) + p.pretty_name(field898) p.newline() - field883 := unwrapped_fields881[1].([]*pb.Abstraction) - p.pretty_ffi_args(field883) + field899 := unwrapped_fields897[1].([]*pb.Abstraction) + p.pretty_ffi_args(field899) p.newline() - field884 := unwrapped_fields881[2].([]*pb.Term) - p.pretty_terms(field884) + field900 := unwrapped_fields897[2].([]*pb.Term) + p.pretty_terms(field900) p.dedent() p.write(")") } @@ -2096,35 +2105,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat887 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat887 != nil { - p.write(*flat887) + flat903 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat903 != nil { + p.write(*flat903) return nil } else { - fields886 := msg + fields902 := msg p.write(":") - p.write(fields886) + p.write(fields902) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat891 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat891 != nil { - p.write(*flat891) + flat907 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat907 != nil { + p.write(*flat907) return nil } else { - fields888 := msg + fields904 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields888) == 0) { + if !(len(fields904) == 0) { p.newline() - for i890, elem889 := range fields888 { - if (i890 > 0) { + for i906, elem905 := range fields904 { + if (i906 > 0) { p.newline() } - p.pretty_abstraction(elem889) + p.pretty_abstraction(elem905) } } p.dedent() @@ -2134,31 +2143,31 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat898 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat898 != nil { - p.write(*flat898) + flat914 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat914 != nil { + p.write(*flat914) return nil } else { - _t1453 := func(_dollar_dollar *pb.Atom) []interface{} { + _t1485 := func(_dollar_dollar *pb.Atom) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1454 := _t1453(msg) - fields892 := _t1454 - unwrapped_fields893 := fields892 + _t1486 := _t1485(msg) + fields908 := _t1486 + unwrapped_fields909 := fields908 p.write("(") p.write("atom") p.indentSexp() p.newline() - field894 := unwrapped_fields893[0].(*pb.RelationId) - p.pretty_relation_id(field894) - field895 := unwrapped_fields893[1].([]*pb.Term) - if !(len(field895) == 0) { + field910 := unwrapped_fields909[0].(*pb.RelationId) + p.pretty_relation_id(field910) + field911 := unwrapped_fields909[1].([]*pb.Term) + if !(len(field911) == 0) { p.newline() - for i897, elem896 := range field895 { - if (i897 > 0) { + for i913, elem912 := range field911 { + if (i913 > 0) { p.newline() } - p.pretty_term(elem896) + p.pretty_term(elem912) } } p.dedent() @@ -2168,31 +2177,31 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat905 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat905 != nil { - p.write(*flat905) + flat921 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat921 != nil { + p.write(*flat921) return nil } else { - _t1455 := func(_dollar_dollar *pb.Pragma) []interface{} { + _t1487 := func(_dollar_dollar *pb.Pragma) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1456 := _t1455(msg) - fields899 := _t1456 - unwrapped_fields900 := fields899 + _t1488 := _t1487(msg) + fields915 := _t1488 + unwrapped_fields916 := fields915 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field901 := unwrapped_fields900[0].(string) - p.pretty_name(field901) - field902 := unwrapped_fields900[1].([]*pb.Term) - if !(len(field902) == 0) { + field917 := unwrapped_fields916[0].(string) + p.pretty_name(field917) + field918 := unwrapped_fields916[1].([]*pb.Term) + if !(len(field918) == 0) { p.newline() - for i904, elem903 := range field902 { - if (i904 > 0) { + for i920, elem919 := range field918 { + if (i920 > 0) { p.newline() } - p.pretty_term(elem903) + p.pretty_term(elem919) } } p.dedent() @@ -2202,139 +2211,139 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat921 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat921 != nil { - p.write(*flat921) + flat937 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat937 != nil { + p.write(*flat937) return nil } else { - _t1457 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1458 []interface{} + _t1489 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1490 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1458 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1490 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1458 + return _t1490 } - _t1459 := _t1457(msg) - guard_result920 := _t1459 - if guard_result920 != nil { + _t1491 := _t1489(msg) + guard_result936 := _t1491 + if guard_result936 != nil { p.pretty_eq(msg) } else { - _t1460 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1461 []interface{} + _t1492 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1493 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1461 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1493 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1461 + return _t1493 } - _t1462 := _t1460(msg) - guard_result919 := _t1462 - if guard_result919 != nil { + _t1494 := _t1492(msg) + guard_result935 := _t1494 + if guard_result935 != nil { p.pretty_lt(msg) } else { - _t1463 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1464 []interface{} + _t1495 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1496 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1464 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1496 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1464 + return _t1496 } - _t1465 := _t1463(msg) - guard_result918 := _t1465 - if guard_result918 != nil { + _t1497 := _t1495(msg) + guard_result934 := _t1497 + if guard_result934 != nil { p.pretty_lt_eq(msg) } else { - _t1466 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1467 []interface{} + _t1498 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1499 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1467 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1499 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1467 + return _t1499 } - _t1468 := _t1466(msg) - guard_result917 := _t1468 - if guard_result917 != nil { + _t1500 := _t1498(msg) + guard_result933 := _t1500 + if guard_result933 != nil { p.pretty_gt(msg) } else { - _t1469 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1470 []interface{} + _t1501 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1502 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1470 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1502 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1470 + return _t1502 } - _t1471 := _t1469(msg) - guard_result916 := _t1471 - if guard_result916 != nil { + _t1503 := _t1501(msg) + guard_result932 := _t1503 + if guard_result932 != nil { p.pretty_gt_eq(msg) } else { - _t1472 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1473 []interface{} + _t1504 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1505 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1473 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1505 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1473 + return _t1505 } - _t1474 := _t1472(msg) - guard_result915 := _t1474 - if guard_result915 != nil { + _t1506 := _t1504(msg) + guard_result931 := _t1506 + if guard_result931 != nil { p.pretty_add(msg) } else { - _t1475 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1476 []interface{} + _t1507 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1508 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1476 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1508 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1476 + return _t1508 } - _t1477 := _t1475(msg) - guard_result914 := _t1477 - if guard_result914 != nil { + _t1509 := _t1507(msg) + guard_result930 := _t1509 + if guard_result930 != nil { p.pretty_minus(msg) } else { - _t1478 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1479 []interface{} + _t1510 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1511 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1479 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1511 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1479 + return _t1511 } - _t1480 := _t1478(msg) - guard_result913 := _t1480 - if guard_result913 != nil { + _t1512 := _t1510(msg) + guard_result929 := _t1512 + if guard_result929 != nil { p.pretty_multiply(msg) } else { - _t1481 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1482 []interface{} + _t1513 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1514 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1482 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1514 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1482 + return _t1514 } - _t1483 := _t1481(msg) - guard_result912 := _t1483 - if guard_result912 != nil { + _t1515 := _t1513(msg) + guard_result928 := _t1515 + if guard_result928 != nil { p.pretty_divide(msg) } else { - _t1484 := func(_dollar_dollar *pb.Primitive) []interface{} { + _t1516 := func(_dollar_dollar *pb.Primitive) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1485 := _t1484(msg) - fields906 := _t1485 - unwrapped_fields907 := fields906 + _t1517 := _t1516(msg) + fields922 := _t1517 + unwrapped_fields923 := fields922 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field908 := unwrapped_fields907[0].(string) - p.pretty_name(field908) - field909 := unwrapped_fields907[1].([]*pb.RelTerm) - if !(len(field909) == 0) { + field924 := unwrapped_fields923[0].(string) + p.pretty_name(field924) + field925 := unwrapped_fields923[1].([]*pb.RelTerm) + if !(len(field925) == 0) { p.newline() - for i911, elem910 := range field909 { - if (i911 > 0) { + for i927, elem926 := range field925 { + if (i927 > 0) { p.newline() } - p.pretty_rel_term(elem910) + p.pretty_rel_term(elem926) } } p.dedent() @@ -2353,30 +2362,30 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat926 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat926 != nil { - p.write(*flat926) + flat942 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat942 != nil { + p.write(*flat942) return nil } else { - _t1486 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1487 []interface{} + _t1518 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1519 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1487 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1519 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1487 + return _t1519 } - _t1488 := _t1486(msg) - fields922 := _t1488 - unwrapped_fields923 := fields922 + _t1520 := _t1518(msg) + fields938 := _t1520 + unwrapped_fields939 := fields938 p.write("(") p.write("=") p.indentSexp() p.newline() - field924 := unwrapped_fields923[0].(*pb.Term) - p.pretty_term(field924) + field940 := unwrapped_fields939[0].(*pb.Term) + p.pretty_term(field940) p.newline() - field925 := unwrapped_fields923[1].(*pb.Term) - p.pretty_term(field925) + field941 := unwrapped_fields939[1].(*pb.Term) + p.pretty_term(field941) p.dedent() p.write(")") } @@ -2384,30 +2393,30 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat931 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat931 != nil { - p.write(*flat931) + flat947 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat947 != nil { + p.write(*flat947) return nil } else { - _t1489 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1490 []interface{} + _t1521 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1522 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1490 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1522 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1490 + return _t1522 } - _t1491 := _t1489(msg) - fields927 := _t1491 - unwrapped_fields928 := fields927 + _t1523 := _t1521(msg) + fields943 := _t1523 + unwrapped_fields944 := fields943 p.write("(") p.write("<") p.indentSexp() p.newline() - field929 := unwrapped_fields928[0].(*pb.Term) - p.pretty_term(field929) + field945 := unwrapped_fields944[0].(*pb.Term) + p.pretty_term(field945) p.newline() - field930 := unwrapped_fields928[1].(*pb.Term) - p.pretty_term(field930) + field946 := unwrapped_fields944[1].(*pb.Term) + p.pretty_term(field946) p.dedent() p.write(")") } @@ -2415,30 +2424,30 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat936 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat936 != nil { - p.write(*flat936) + flat952 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat952 != nil { + p.write(*flat952) return nil } else { - _t1492 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1493 []interface{} + _t1524 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1525 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1493 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1525 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1493 + return _t1525 } - _t1494 := _t1492(msg) - fields932 := _t1494 - unwrapped_fields933 := fields932 + _t1526 := _t1524(msg) + fields948 := _t1526 + unwrapped_fields949 := fields948 p.write("(") p.write("<=") p.indentSexp() p.newline() - field934 := unwrapped_fields933[0].(*pb.Term) - p.pretty_term(field934) + field950 := unwrapped_fields949[0].(*pb.Term) + p.pretty_term(field950) p.newline() - field935 := unwrapped_fields933[1].(*pb.Term) - p.pretty_term(field935) + field951 := unwrapped_fields949[1].(*pb.Term) + p.pretty_term(field951) p.dedent() p.write(")") } @@ -2446,30 +2455,30 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat941 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat941 != nil { - p.write(*flat941) + flat957 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat957 != nil { + p.write(*flat957) return nil } else { - _t1495 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1496 []interface{} + _t1527 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1528 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1496 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1528 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1496 + return _t1528 } - _t1497 := _t1495(msg) - fields937 := _t1497 - unwrapped_fields938 := fields937 + _t1529 := _t1527(msg) + fields953 := _t1529 + unwrapped_fields954 := fields953 p.write("(") p.write(">") p.indentSexp() p.newline() - field939 := unwrapped_fields938[0].(*pb.Term) - p.pretty_term(field939) + field955 := unwrapped_fields954[0].(*pb.Term) + p.pretty_term(field955) p.newline() - field940 := unwrapped_fields938[1].(*pb.Term) - p.pretty_term(field940) + field956 := unwrapped_fields954[1].(*pb.Term) + p.pretty_term(field956) p.dedent() p.write(")") } @@ -2477,30 +2486,30 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat946 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat946 != nil { - p.write(*flat946) + flat962 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat962 != nil { + p.write(*flat962) return nil } else { - _t1498 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1499 []interface{} + _t1530 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1531 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1499 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1531 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1499 + return _t1531 } - _t1500 := _t1498(msg) - fields942 := _t1500 - unwrapped_fields943 := fields942 + _t1532 := _t1530(msg) + fields958 := _t1532 + unwrapped_fields959 := fields958 p.write("(") p.write(">=") p.indentSexp() p.newline() - field944 := unwrapped_fields943[0].(*pb.Term) - p.pretty_term(field944) + field960 := unwrapped_fields959[0].(*pb.Term) + p.pretty_term(field960) p.newline() - field945 := unwrapped_fields943[1].(*pb.Term) - p.pretty_term(field945) + field961 := unwrapped_fields959[1].(*pb.Term) + p.pretty_term(field961) p.dedent() p.write(")") } @@ -2508,33 +2517,33 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat952 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat952 != nil { - p.write(*flat952) + flat968 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat968 != nil { + p.write(*flat968) return nil } else { - _t1501 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1502 []interface{} + _t1533 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1534 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1502 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1534 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1502 + return _t1534 } - _t1503 := _t1501(msg) - fields947 := _t1503 - unwrapped_fields948 := fields947 + _t1535 := _t1533(msg) + fields963 := _t1535 + unwrapped_fields964 := fields963 p.write("(") p.write("+") p.indentSexp() p.newline() - field949 := unwrapped_fields948[0].(*pb.Term) - p.pretty_term(field949) + field965 := unwrapped_fields964[0].(*pb.Term) + p.pretty_term(field965) p.newline() - field950 := unwrapped_fields948[1].(*pb.Term) - p.pretty_term(field950) + field966 := unwrapped_fields964[1].(*pb.Term) + p.pretty_term(field966) p.newline() - field951 := unwrapped_fields948[2].(*pb.Term) - p.pretty_term(field951) + field967 := unwrapped_fields964[2].(*pb.Term) + p.pretty_term(field967) p.dedent() p.write(")") } @@ -2542,33 +2551,33 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat958 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat958 != nil { - p.write(*flat958) + flat974 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat974 != nil { + p.write(*flat974) return nil } else { - _t1504 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1505 []interface{} + _t1536 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1537 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1505 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1537 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1505 + return _t1537 } - _t1506 := _t1504(msg) - fields953 := _t1506 - unwrapped_fields954 := fields953 + _t1538 := _t1536(msg) + fields969 := _t1538 + unwrapped_fields970 := fields969 p.write("(") p.write("-") p.indentSexp() p.newline() - field955 := unwrapped_fields954[0].(*pb.Term) - p.pretty_term(field955) + field971 := unwrapped_fields970[0].(*pb.Term) + p.pretty_term(field971) p.newline() - field956 := unwrapped_fields954[1].(*pb.Term) - p.pretty_term(field956) + field972 := unwrapped_fields970[1].(*pb.Term) + p.pretty_term(field972) p.newline() - field957 := unwrapped_fields954[2].(*pb.Term) - p.pretty_term(field957) + field973 := unwrapped_fields970[2].(*pb.Term) + p.pretty_term(field973) p.dedent() p.write(")") } @@ -2576,33 +2585,33 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat964 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat964 != nil { - p.write(*flat964) + flat980 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat980 != nil { + p.write(*flat980) return nil } else { - _t1507 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1508 []interface{} + _t1539 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1540 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1508 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1540 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1508 + return _t1540 } - _t1509 := _t1507(msg) - fields959 := _t1509 - unwrapped_fields960 := fields959 + _t1541 := _t1539(msg) + fields975 := _t1541 + unwrapped_fields976 := fields975 p.write("(") p.write("*") p.indentSexp() p.newline() - field961 := unwrapped_fields960[0].(*pb.Term) - p.pretty_term(field961) + field977 := unwrapped_fields976[0].(*pb.Term) + p.pretty_term(field977) p.newline() - field962 := unwrapped_fields960[1].(*pb.Term) - p.pretty_term(field962) + field978 := unwrapped_fields976[1].(*pb.Term) + p.pretty_term(field978) p.newline() - field963 := unwrapped_fields960[2].(*pb.Term) - p.pretty_term(field963) + field979 := unwrapped_fields976[2].(*pb.Term) + p.pretty_term(field979) p.dedent() p.write(")") } @@ -2610,33 +2619,33 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat970 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat970 != nil { - p.write(*flat970) + flat986 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat986 != nil { + p.write(*flat986) return nil } else { - _t1510 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1511 []interface{} + _t1542 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1543 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1511 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1543 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1511 + return _t1543 } - _t1512 := _t1510(msg) - fields965 := _t1512 - unwrapped_fields966 := fields965 + _t1544 := _t1542(msg) + fields981 := _t1544 + unwrapped_fields982 := fields981 p.write("(") p.write("/") p.indentSexp() p.newline() - field967 := unwrapped_fields966[0].(*pb.Term) - p.pretty_term(field967) + field983 := unwrapped_fields982[0].(*pb.Term) + p.pretty_term(field983) p.newline() - field968 := unwrapped_fields966[1].(*pb.Term) - p.pretty_term(field968) + field984 := unwrapped_fields982[1].(*pb.Term) + p.pretty_term(field984) p.newline() - field969 := unwrapped_fields966[2].(*pb.Term) - p.pretty_term(field969) + field985 := unwrapped_fields982[2].(*pb.Term) + p.pretty_term(field985) p.dedent() p.write(")") } @@ -2644,36 +2653,36 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat975 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat975 != nil { - p.write(*flat975) + flat991 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat991 != nil { + p.write(*flat991) return nil } else { - _t1513 := func(_dollar_dollar *pb.RelTerm) *pb.Value { - var _t1514 *pb.Value + _t1545 := func(_dollar_dollar *pb.RelTerm) *pb.Value { + var _t1546 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1514 = _dollar_dollar.GetSpecializedValue() + _t1546 = _dollar_dollar.GetSpecializedValue() } - return _t1514 + return _t1546 } - _t1515 := _t1513(msg) - deconstruct_result973 := _t1515 - if deconstruct_result973 != nil { - unwrapped974 := deconstruct_result973 - p.pretty_specialized_value(unwrapped974) + _t1547 := _t1545(msg) + deconstruct_result989 := _t1547 + if deconstruct_result989 != nil { + unwrapped990 := deconstruct_result989 + p.pretty_specialized_value(unwrapped990) } else { - _t1516 := func(_dollar_dollar *pb.RelTerm) *pb.Term { - var _t1517 *pb.Term + _t1548 := func(_dollar_dollar *pb.RelTerm) *pb.Term { + var _t1549 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1517 = _dollar_dollar.GetTerm() + _t1549 = _dollar_dollar.GetTerm() } - return _t1517 + return _t1549 } - _t1518 := _t1516(msg) - deconstruct_result971 := _t1518 - if deconstruct_result971 != nil { - unwrapped972 := deconstruct_result971 - p.pretty_term(unwrapped972) + _t1550 := _t1548(msg) + deconstruct_result987 := _t1550 + if deconstruct_result987 != nil { + unwrapped988 := deconstruct_result987 + p.pretty_term(unwrapped988) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2683,44 +2692,44 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat977 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat977 != nil { - p.write(*flat977) + flat993 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat993 != nil { + p.write(*flat993) return nil } else { - fields976 := msg + fields992 := msg p.write("#") - p.pretty_value(fields976) + p.pretty_value(fields992) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat984 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat984 != nil { - p.write(*flat984) + flat1000 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1000 != nil { + p.write(*flat1000) return nil } else { - _t1519 := func(_dollar_dollar *pb.RelAtom) []interface{} { + _t1551 := func(_dollar_dollar *pb.RelAtom) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1520 := _t1519(msg) - fields978 := _t1520 - unwrapped_fields979 := fields978 + _t1552 := _t1551(msg) + fields994 := _t1552 + unwrapped_fields995 := fields994 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field980 := unwrapped_fields979[0].(string) - p.pretty_name(field980) - field981 := unwrapped_fields979[1].([]*pb.RelTerm) - if !(len(field981) == 0) { + field996 := unwrapped_fields995[0].(string) + p.pretty_name(field996) + field997 := unwrapped_fields995[1].([]*pb.RelTerm) + if !(len(field997) == 0) { p.newline() - for i983, elem982 := range field981 { - if (i983 > 0) { + for i999, elem998 := range field997 { + if (i999 > 0) { p.newline() } - p.pretty_rel_term(elem982) + p.pretty_rel_term(elem998) } } p.dedent() @@ -2730,26 +2739,26 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat989 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat989 != nil { - p.write(*flat989) + flat1005 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1005 != nil { + p.write(*flat1005) return nil } else { - _t1521 := func(_dollar_dollar *pb.Cast) []interface{} { + _t1553 := func(_dollar_dollar *pb.Cast) []interface{} { return []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} } - _t1522 := _t1521(msg) - fields985 := _t1522 - unwrapped_fields986 := fields985 + _t1554 := _t1553(msg) + fields1001 := _t1554 + unwrapped_fields1002 := fields1001 p.write("(") p.write("cast") p.indentSexp() p.newline() - field987 := unwrapped_fields986[0].(*pb.Term) - p.pretty_term(field987) + field1003 := unwrapped_fields1002[0].(*pb.Term) + p.pretty_term(field1003) p.newline() - field988 := unwrapped_fields986[1].(*pb.Term) - p.pretty_term(field988) + field1004 := unwrapped_fields1002[1].(*pb.Term) + p.pretty_term(field1004) p.dedent() p.write(")") } @@ -2757,22 +2766,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat993 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat993 != nil { - p.write(*flat993) + flat1009 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1009 != nil { + p.write(*flat1009) return nil } else { - fields990 := msg + fields1006 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields990) == 0) { + if !(len(fields1006) == 0) { p.newline() - for i992, elem991 := range fields990 { - if (i992 > 0) { + for i1008, elem1007 := range fields1006 { + if (i1008 > 0) { p.newline() } - p.pretty_attribute(elem991) + p.pretty_attribute(elem1007) } } p.dedent() @@ -2782,31 +2791,31 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1000 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1000 != nil { - p.write(*flat1000) + flat1016 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1016 != nil { + p.write(*flat1016) return nil } else { - _t1523 := func(_dollar_dollar *pb.Attribute) []interface{} { + _t1555 := func(_dollar_dollar *pb.Attribute) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} } - _t1524 := _t1523(msg) - fields994 := _t1524 - unwrapped_fields995 := fields994 + _t1556 := _t1555(msg) + fields1010 := _t1556 + unwrapped_fields1011 := fields1010 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field996 := unwrapped_fields995[0].(string) - p.pretty_name(field996) - field997 := unwrapped_fields995[1].([]*pb.Value) - if !(len(field997) == 0) { + field1012 := unwrapped_fields1011[0].(string) + p.pretty_name(field1012) + field1013 := unwrapped_fields1011[1].([]*pb.Value) + if !(len(field1013) == 0) { p.newline() - for i999, elem998 := range field997 { - if (i999 > 0) { + for i1015, elem1014 := range field1013 { + if (i1015 > 0) { p.newline() } - p.pretty_value(elem998) + p.pretty_value(elem1014) } } p.dedent() @@ -2816,33 +2825,33 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1007 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1007 != nil { - p.write(*flat1007) + flat1023 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1023 != nil { + p.write(*flat1023) return nil } else { - _t1525 := func(_dollar_dollar *pb.Algorithm) []interface{} { + _t1557 := func(_dollar_dollar *pb.Algorithm) []interface{} { return []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()} } - _t1526 := _t1525(msg) - fields1001 := _t1526 - unwrapped_fields1002 := fields1001 + _t1558 := _t1557(msg) + fields1017 := _t1558 + unwrapped_fields1018 := fields1017 p.write("(") p.write("algorithm") p.indentSexp() - field1003 := unwrapped_fields1002[0].([]*pb.RelationId) - if !(len(field1003) == 0) { + field1019 := unwrapped_fields1018[0].([]*pb.RelationId) + if !(len(field1019) == 0) { p.newline() - for i1005, elem1004 := range field1003 { - if (i1005 > 0) { + for i1021, elem1020 := range field1019 { + if (i1021 > 0) { p.newline() } - p.pretty_relation_id(elem1004) + p.pretty_relation_id(elem1020) } } p.newline() - field1006 := unwrapped_fields1002[1].(*pb.Script) - p.pretty_script(field1006) + field1022 := unwrapped_fields1018[1].(*pb.Script) + p.pretty_script(field1022) p.dedent() p.write(")") } @@ -2850,27 +2859,27 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1012 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1012 != nil { - p.write(*flat1012) + flat1028 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1028 != nil { + p.write(*flat1028) return nil } else { - _t1527 := func(_dollar_dollar *pb.Script) []*pb.Construct { + _t1559 := func(_dollar_dollar *pb.Script) []*pb.Construct { return _dollar_dollar.GetConstructs() } - _t1528 := _t1527(msg) - fields1008 := _t1528 - unwrapped_fields1009 := fields1008 + _t1560 := _t1559(msg) + fields1024 := _t1560 + unwrapped_fields1025 := fields1024 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1009) == 0) { + if !(len(unwrapped_fields1025) == 0) { p.newline() - for i1011, elem1010 := range unwrapped_fields1009 { - if (i1011 > 0) { + for i1027, elem1026 := range unwrapped_fields1025 { + if (i1027 > 0) { p.newline() } - p.pretty_construct(elem1010) + p.pretty_construct(elem1026) } } p.dedent() @@ -2880,36 +2889,36 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1017 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1017 != nil { - p.write(*flat1017) + flat1033 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1033 != nil { + p.write(*flat1033) return nil } else { - _t1529 := func(_dollar_dollar *pb.Construct) *pb.Loop { - var _t1530 *pb.Loop + _t1561 := func(_dollar_dollar *pb.Construct) *pb.Loop { + var _t1562 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1530 = _dollar_dollar.GetLoop() + _t1562 = _dollar_dollar.GetLoop() } - return _t1530 + return _t1562 } - _t1531 := _t1529(msg) - deconstruct_result1015 := _t1531 - if deconstruct_result1015 != nil { - unwrapped1016 := deconstruct_result1015 - p.pretty_loop(unwrapped1016) + _t1563 := _t1561(msg) + deconstruct_result1031 := _t1563 + if deconstruct_result1031 != nil { + unwrapped1032 := deconstruct_result1031 + p.pretty_loop(unwrapped1032) } else { - _t1532 := func(_dollar_dollar *pb.Construct) *pb.Instruction { - var _t1533 *pb.Instruction + _t1564 := func(_dollar_dollar *pb.Construct) *pb.Instruction { + var _t1565 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1533 = _dollar_dollar.GetInstruction() + _t1565 = _dollar_dollar.GetInstruction() } - return _t1533 + return _t1565 } - _t1534 := _t1532(msg) - deconstruct_result1013 := _t1534 - if deconstruct_result1013 != nil { - unwrapped1014 := deconstruct_result1013 - p.pretty_instruction(unwrapped1014) + _t1566 := _t1564(msg) + deconstruct_result1029 := _t1566 + if deconstruct_result1029 != nil { + unwrapped1030 := deconstruct_result1029 + p.pretty_instruction(unwrapped1030) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -2919,26 +2928,26 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1022 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1022 != nil { - p.write(*flat1022) + flat1038 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1038 != nil { + p.write(*flat1038) return nil } else { - _t1535 := func(_dollar_dollar *pb.Loop) []interface{} { + _t1567 := func(_dollar_dollar *pb.Loop) []interface{} { return []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()} } - _t1536 := _t1535(msg) - fields1018 := _t1536 - unwrapped_fields1019 := fields1018 + _t1568 := _t1567(msg) + fields1034 := _t1568 + unwrapped_fields1035 := fields1034 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1020 := unwrapped_fields1019[0].([]*pb.Instruction) - p.pretty_init(field1020) + field1036 := unwrapped_fields1035[0].([]*pb.Instruction) + p.pretty_init(field1036) p.newline() - field1021 := unwrapped_fields1019[1].(*pb.Script) - p.pretty_script(field1021) + field1037 := unwrapped_fields1035[1].(*pb.Script) + p.pretty_script(field1037) p.dedent() p.write(")") } @@ -2946,22 +2955,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1026 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1026 != nil { - p.write(*flat1026) + flat1042 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1042 != nil { + p.write(*flat1042) return nil } else { - fields1023 := msg + fields1039 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1023) == 0) { + if !(len(fields1039) == 0) { p.newline() - for i1025, elem1024 := range fields1023 { - if (i1025 > 0) { + for i1041, elem1040 := range fields1039 { + if (i1041 > 0) { p.newline() } - p.pretty_instruction(elem1024) + p.pretty_instruction(elem1040) } } p.dedent() @@ -2971,75 +2980,75 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1037 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1037 != nil { - p.write(*flat1037) + flat1053 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1053 != nil { + p.write(*flat1053) return nil } else { - _t1537 := func(_dollar_dollar *pb.Instruction) *pb.Assign { - var _t1538 *pb.Assign + _t1569 := func(_dollar_dollar *pb.Instruction) *pb.Assign { + var _t1570 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1538 = _dollar_dollar.GetAssign() + _t1570 = _dollar_dollar.GetAssign() } - return _t1538 + return _t1570 } - _t1539 := _t1537(msg) - deconstruct_result1035 := _t1539 - if deconstruct_result1035 != nil { - unwrapped1036 := deconstruct_result1035 - p.pretty_assign(unwrapped1036) + _t1571 := _t1569(msg) + deconstruct_result1051 := _t1571 + if deconstruct_result1051 != nil { + unwrapped1052 := deconstruct_result1051 + p.pretty_assign(unwrapped1052) } else { - _t1540 := func(_dollar_dollar *pb.Instruction) *pb.Upsert { - var _t1541 *pb.Upsert + _t1572 := func(_dollar_dollar *pb.Instruction) *pb.Upsert { + var _t1573 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1541 = _dollar_dollar.GetUpsert() + _t1573 = _dollar_dollar.GetUpsert() } - return _t1541 + return _t1573 } - _t1542 := _t1540(msg) - deconstruct_result1033 := _t1542 - if deconstruct_result1033 != nil { - unwrapped1034 := deconstruct_result1033 - p.pretty_upsert(unwrapped1034) + _t1574 := _t1572(msg) + deconstruct_result1049 := _t1574 + if deconstruct_result1049 != nil { + unwrapped1050 := deconstruct_result1049 + p.pretty_upsert(unwrapped1050) } else { - _t1543 := func(_dollar_dollar *pb.Instruction) *pb.Break { - var _t1544 *pb.Break + _t1575 := func(_dollar_dollar *pb.Instruction) *pb.Break { + var _t1576 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1544 = _dollar_dollar.GetBreak() + _t1576 = _dollar_dollar.GetBreak() } - return _t1544 + return _t1576 } - _t1545 := _t1543(msg) - deconstruct_result1031 := _t1545 - if deconstruct_result1031 != nil { - unwrapped1032 := deconstruct_result1031 - p.pretty_break(unwrapped1032) + _t1577 := _t1575(msg) + deconstruct_result1047 := _t1577 + if deconstruct_result1047 != nil { + unwrapped1048 := deconstruct_result1047 + p.pretty_break(unwrapped1048) } else { - _t1546 := func(_dollar_dollar *pb.Instruction) *pb.MonoidDef { - var _t1547 *pb.MonoidDef + _t1578 := func(_dollar_dollar *pb.Instruction) *pb.MonoidDef { + var _t1579 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1547 = _dollar_dollar.GetMonoidDef() + _t1579 = _dollar_dollar.GetMonoidDef() } - return _t1547 + return _t1579 } - _t1548 := _t1546(msg) - deconstruct_result1029 := _t1548 - if deconstruct_result1029 != nil { - unwrapped1030 := deconstruct_result1029 - p.pretty_monoid_def(unwrapped1030) + _t1580 := _t1578(msg) + deconstruct_result1045 := _t1580 + if deconstruct_result1045 != nil { + unwrapped1046 := deconstruct_result1045 + p.pretty_monoid_def(unwrapped1046) } else { - _t1549 := func(_dollar_dollar *pb.Instruction) *pb.MonusDef { - var _t1550 *pb.MonusDef + _t1581 := func(_dollar_dollar *pb.Instruction) *pb.MonusDef { + var _t1582 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1550 = _dollar_dollar.GetMonusDef() + _t1582 = _dollar_dollar.GetMonusDef() } - return _t1550 + return _t1582 } - _t1551 := _t1549(msg) - deconstruct_result1027 := _t1551 - if deconstruct_result1027 != nil { - unwrapped1028 := deconstruct_result1027 - p.pretty_monus_def(unwrapped1028) + _t1583 := _t1581(msg) + deconstruct_result1043 := _t1583 + if deconstruct_result1043 != nil { + unwrapped1044 := deconstruct_result1043 + p.pretty_monus_def(unwrapped1044) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3052,35 +3061,35 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1044 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1044 != nil { - p.write(*flat1044) + flat1060 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1060 != nil { + p.write(*flat1060) return nil } else { - _t1552 := func(_dollar_dollar *pb.Assign) []interface{} { - var _t1553 []*pb.Attribute + _t1584 := func(_dollar_dollar *pb.Assign) []interface{} { + var _t1585 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1553 = _dollar_dollar.GetAttrs() + _t1585 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1553} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1585} } - _t1554 := _t1552(msg) - fields1038 := _t1554 - unwrapped_fields1039 := fields1038 + _t1586 := _t1584(msg) + fields1054 := _t1586 + unwrapped_fields1055 := fields1054 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1040 := unwrapped_fields1039[0].(*pb.RelationId) - p.pretty_relation_id(field1040) + field1056 := unwrapped_fields1055[0].(*pb.RelationId) + p.pretty_relation_id(field1056) p.newline() - field1041 := unwrapped_fields1039[1].(*pb.Abstraction) - p.pretty_abstraction(field1041) - field1042 := unwrapped_fields1039[2].([]*pb.Attribute) - if field1042 != nil { + field1057 := unwrapped_fields1055[1].(*pb.Abstraction) + p.pretty_abstraction(field1057) + field1058 := unwrapped_fields1055[2].([]*pb.Attribute) + if field1058 != nil { p.newline() - opt_val1043 := field1042 - p.pretty_attrs(opt_val1043) + opt_val1059 := field1058 + p.pretty_attrs(opt_val1059) } p.dedent() p.write(")") @@ -3089,35 +3098,35 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1051 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1051 != nil { - p.write(*flat1051) + flat1067 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1067 != nil { + p.write(*flat1067) return nil } else { - _t1555 := func(_dollar_dollar *pb.Upsert) []interface{} { - var _t1556 []*pb.Attribute + _t1587 := func(_dollar_dollar *pb.Upsert) []interface{} { + var _t1588 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1556 = _dollar_dollar.GetAttrs() + _t1588 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1556} + return []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1588} } - _t1557 := _t1555(msg) - fields1045 := _t1557 - unwrapped_fields1046 := fields1045 + _t1589 := _t1587(msg) + fields1061 := _t1589 + unwrapped_fields1062 := fields1061 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1047 := unwrapped_fields1046[0].(*pb.RelationId) - p.pretty_relation_id(field1047) + field1063 := unwrapped_fields1062[0].(*pb.RelationId) + p.pretty_relation_id(field1063) p.newline() - field1048 := unwrapped_fields1046[1].([]interface{}) - p.pretty_abstraction_with_arity(field1048) - field1049 := unwrapped_fields1046[2].([]*pb.Attribute) - if field1049 != nil { + field1064 := unwrapped_fields1062[1].([]interface{}) + p.pretty_abstraction_with_arity(field1064) + field1065 := unwrapped_fields1062[2].([]*pb.Attribute) + if field1065 != nil { p.newline() - opt_val1050 := field1049 - p.pretty_attrs(opt_val1050) + opt_val1066 := field1065 + p.pretty_attrs(opt_val1066) } p.dedent() p.write(")") @@ -3126,25 +3135,25 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1056 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1056 != nil { - p.write(*flat1056) + flat1072 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1072 != nil { + p.write(*flat1072) return nil } else { - _t1558 := func(_dollar_dollar []interface{}) []interface{} { - _t1559 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - return []interface{}{_t1559, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + _t1590 := func(_dollar_dollar []interface{}) []interface{} { + _t1591 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + return []interface{}{_t1591, _dollar_dollar[0].(*pb.Abstraction).GetValue()} } - _t1560 := _t1558(msg) - fields1052 := _t1560 - unwrapped_fields1053 := fields1052 + _t1592 := _t1590(msg) + fields1068 := _t1592 + unwrapped_fields1069 := fields1068 p.write("(") p.indent() - field1054 := unwrapped_fields1053[0].([]interface{}) - p.pretty_bindings(field1054) + field1070 := unwrapped_fields1069[0].([]interface{}) + p.pretty_bindings(field1070) p.newline() - field1055 := unwrapped_fields1053[1].(*pb.Formula) - p.pretty_formula(field1055) + field1071 := unwrapped_fields1069[1].(*pb.Formula) + p.pretty_formula(field1071) p.dedent() p.write(")") } @@ -3152,35 +3161,35 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1063 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1063 != nil { - p.write(*flat1063) + flat1079 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1079 != nil { + p.write(*flat1079) return nil } else { - _t1561 := func(_dollar_dollar *pb.Break) []interface{} { - var _t1562 []*pb.Attribute + _t1593 := func(_dollar_dollar *pb.Break) []interface{} { + var _t1594 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1562 = _dollar_dollar.GetAttrs() + _t1594 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1562} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1594} } - _t1563 := _t1561(msg) - fields1057 := _t1563 - unwrapped_fields1058 := fields1057 + _t1595 := _t1593(msg) + fields1073 := _t1595 + unwrapped_fields1074 := fields1073 p.write("(") p.write("break") p.indentSexp() p.newline() - field1059 := unwrapped_fields1058[0].(*pb.RelationId) - p.pretty_relation_id(field1059) + field1075 := unwrapped_fields1074[0].(*pb.RelationId) + p.pretty_relation_id(field1075) p.newline() - field1060 := unwrapped_fields1058[1].(*pb.Abstraction) - p.pretty_abstraction(field1060) - field1061 := unwrapped_fields1058[2].([]*pb.Attribute) - if field1061 != nil { + field1076 := unwrapped_fields1074[1].(*pb.Abstraction) + p.pretty_abstraction(field1076) + field1077 := unwrapped_fields1074[2].([]*pb.Attribute) + if field1077 != nil { p.newline() - opt_val1062 := field1061 - p.pretty_attrs(opt_val1062) + opt_val1078 := field1077 + p.pretty_attrs(opt_val1078) } p.dedent() p.write(")") @@ -3189,38 +3198,38 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1071 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1071 != nil { - p.write(*flat1071) + flat1087 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1087 != nil { + p.write(*flat1087) return nil } else { - _t1564 := func(_dollar_dollar *pb.MonoidDef) []interface{} { - var _t1565 []*pb.Attribute + _t1596 := func(_dollar_dollar *pb.MonoidDef) []interface{} { + var _t1597 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1565 = _dollar_dollar.GetAttrs() + _t1597 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1565} + return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1597} } - _t1566 := _t1564(msg) - fields1064 := _t1566 - unwrapped_fields1065 := fields1064 + _t1598 := _t1596(msg) + fields1080 := _t1598 + unwrapped_fields1081 := fields1080 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1066 := unwrapped_fields1065[0].(*pb.Monoid) - p.pretty_monoid(field1066) + field1082 := unwrapped_fields1081[0].(*pb.Monoid) + p.pretty_monoid(field1082) p.newline() - field1067 := unwrapped_fields1065[1].(*pb.RelationId) - p.pretty_relation_id(field1067) + field1083 := unwrapped_fields1081[1].(*pb.RelationId) + p.pretty_relation_id(field1083) p.newline() - field1068 := unwrapped_fields1065[2].([]interface{}) - p.pretty_abstraction_with_arity(field1068) - field1069 := unwrapped_fields1065[3].([]*pb.Attribute) - if field1069 != nil { + field1084 := unwrapped_fields1081[2].([]interface{}) + p.pretty_abstraction_with_arity(field1084) + field1085 := unwrapped_fields1081[3].([]*pb.Attribute) + if field1085 != nil { p.newline() - opt_val1070 := field1069 - p.pretty_attrs(opt_val1070) + opt_val1086 := field1085 + p.pretty_attrs(opt_val1086) } p.dedent() p.write(")") @@ -3229,62 +3238,62 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1080 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1080 != nil { - p.write(*flat1080) + flat1096 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1096 != nil { + p.write(*flat1096) return nil } else { - _t1567 := func(_dollar_dollar *pb.Monoid) *pb.OrMonoid { - var _t1568 *pb.OrMonoid + _t1599 := func(_dollar_dollar *pb.Monoid) *pb.OrMonoid { + var _t1600 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1568 = _dollar_dollar.GetOrMonoid() + _t1600 = _dollar_dollar.GetOrMonoid() } - return _t1568 + return _t1600 } - _t1569 := _t1567(msg) - deconstruct_result1078 := _t1569 - if deconstruct_result1078 != nil { - unwrapped1079 := deconstruct_result1078 - p.pretty_or_monoid(unwrapped1079) + _t1601 := _t1599(msg) + deconstruct_result1094 := _t1601 + if deconstruct_result1094 != nil { + unwrapped1095 := deconstruct_result1094 + p.pretty_or_monoid(unwrapped1095) } else { - _t1570 := func(_dollar_dollar *pb.Monoid) *pb.MinMonoid { - var _t1571 *pb.MinMonoid + _t1602 := func(_dollar_dollar *pb.Monoid) *pb.MinMonoid { + var _t1603 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1571 = _dollar_dollar.GetMinMonoid() + _t1603 = _dollar_dollar.GetMinMonoid() } - return _t1571 + return _t1603 } - _t1572 := _t1570(msg) - deconstruct_result1076 := _t1572 - if deconstruct_result1076 != nil { - unwrapped1077 := deconstruct_result1076 - p.pretty_min_monoid(unwrapped1077) + _t1604 := _t1602(msg) + deconstruct_result1092 := _t1604 + if deconstruct_result1092 != nil { + unwrapped1093 := deconstruct_result1092 + p.pretty_min_monoid(unwrapped1093) } else { - _t1573 := func(_dollar_dollar *pb.Monoid) *pb.MaxMonoid { - var _t1574 *pb.MaxMonoid + _t1605 := func(_dollar_dollar *pb.Monoid) *pb.MaxMonoid { + var _t1606 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1574 = _dollar_dollar.GetMaxMonoid() + _t1606 = _dollar_dollar.GetMaxMonoid() } - return _t1574 + return _t1606 } - _t1575 := _t1573(msg) - deconstruct_result1074 := _t1575 - if deconstruct_result1074 != nil { - unwrapped1075 := deconstruct_result1074 - p.pretty_max_monoid(unwrapped1075) + _t1607 := _t1605(msg) + deconstruct_result1090 := _t1607 + if deconstruct_result1090 != nil { + unwrapped1091 := deconstruct_result1090 + p.pretty_max_monoid(unwrapped1091) } else { - _t1576 := func(_dollar_dollar *pb.Monoid) *pb.SumMonoid { - var _t1577 *pb.SumMonoid + _t1608 := func(_dollar_dollar *pb.Monoid) *pb.SumMonoid { + var _t1609 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1577 = _dollar_dollar.GetSumMonoid() + _t1609 = _dollar_dollar.GetSumMonoid() } - return _t1577 + return _t1609 } - _t1578 := _t1576(msg) - deconstruct_result1072 := _t1578 - if deconstruct_result1072 != nil { - unwrapped1073 := deconstruct_result1072 - p.pretty_sum_monoid(unwrapped1073) + _t1610 := _t1608(msg) + deconstruct_result1088 := _t1610 + if deconstruct_result1088 != nil { + unwrapped1089 := deconstruct_result1088 + p.pretty_sum_monoid(unwrapped1089) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3296,8 +3305,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1081 := msg - _ = fields1081 + fields1097 := msg + _ = fields1097 p.write("(") p.write("or") p.write(")") @@ -3305,22 +3314,22 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1084 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1084 != nil { - p.write(*flat1084) + flat1100 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1100 != nil { + p.write(*flat1100) return nil } else { - _t1579 := func(_dollar_dollar *pb.MinMonoid) *pb.Type { + _t1611 := func(_dollar_dollar *pb.MinMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1580 := _t1579(msg) - fields1082 := _t1580 - unwrapped_fields1083 := fields1082 + _t1612 := _t1611(msg) + fields1098 := _t1612 + unwrapped_fields1099 := fields1098 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1083) + p.pretty_type(unwrapped_fields1099) p.dedent() p.write(")") } @@ -3328,22 +3337,22 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1087 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1087 != nil { - p.write(*flat1087) + flat1103 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1103 != nil { + p.write(*flat1103) return nil } else { - _t1581 := func(_dollar_dollar *pb.MaxMonoid) *pb.Type { + _t1613 := func(_dollar_dollar *pb.MaxMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1582 := _t1581(msg) - fields1085 := _t1582 - unwrapped_fields1086 := fields1085 + _t1614 := _t1613(msg) + fields1101 := _t1614 + unwrapped_fields1102 := fields1101 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1086) + p.pretty_type(unwrapped_fields1102) p.dedent() p.write(")") } @@ -3351,22 +3360,22 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1090 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1090 != nil { - p.write(*flat1090) + flat1106 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1106 != nil { + p.write(*flat1106) return nil } else { - _t1583 := func(_dollar_dollar *pb.SumMonoid) *pb.Type { + _t1615 := func(_dollar_dollar *pb.SumMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1584 := _t1583(msg) - fields1088 := _t1584 - unwrapped_fields1089 := fields1088 + _t1616 := _t1615(msg) + fields1104 := _t1616 + unwrapped_fields1105 := fields1104 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1089) + p.pretty_type(unwrapped_fields1105) p.dedent() p.write(")") } @@ -3374,38 +3383,38 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1098 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1098 != nil { - p.write(*flat1098) + flat1114 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1114 != nil { + p.write(*flat1114) return nil } else { - _t1585 := func(_dollar_dollar *pb.MonusDef) []interface{} { - var _t1586 []*pb.Attribute + _t1617 := func(_dollar_dollar *pb.MonusDef) []interface{} { + var _t1618 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1586 = _dollar_dollar.GetAttrs() + _t1618 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1586} + return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1618} } - _t1587 := _t1585(msg) - fields1091 := _t1587 - unwrapped_fields1092 := fields1091 + _t1619 := _t1617(msg) + fields1107 := _t1619 + unwrapped_fields1108 := fields1107 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1093 := unwrapped_fields1092[0].(*pb.Monoid) - p.pretty_monoid(field1093) + field1109 := unwrapped_fields1108[0].(*pb.Monoid) + p.pretty_monoid(field1109) p.newline() - field1094 := unwrapped_fields1092[1].(*pb.RelationId) - p.pretty_relation_id(field1094) + field1110 := unwrapped_fields1108[1].(*pb.RelationId) + p.pretty_relation_id(field1110) p.newline() - field1095 := unwrapped_fields1092[2].([]interface{}) - p.pretty_abstraction_with_arity(field1095) - field1096 := unwrapped_fields1092[3].([]*pb.Attribute) - if field1096 != nil { + field1111 := unwrapped_fields1108[2].([]interface{}) + p.pretty_abstraction_with_arity(field1111) + field1112 := unwrapped_fields1108[3].([]*pb.Attribute) + if field1112 != nil { p.newline() - opt_val1097 := field1096 - p.pretty_attrs(opt_val1097) + opt_val1113 := field1112 + p.pretty_attrs(opt_val1113) } p.dedent() p.write(")") @@ -3414,32 +3423,32 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1105 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1105 != nil { - p.write(*flat1105) + flat1121 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1121 != nil { + p.write(*flat1121) return nil } else { - _t1588 := func(_dollar_dollar *pb.Constraint) []interface{} { + _t1620 := func(_dollar_dollar *pb.Constraint) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} } - _t1589 := _t1588(msg) - fields1099 := _t1589 - unwrapped_fields1100 := fields1099 + _t1621 := _t1620(msg) + fields1115 := _t1621 + unwrapped_fields1116 := fields1115 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1101 := unwrapped_fields1100[0].(*pb.RelationId) - p.pretty_relation_id(field1101) + field1117 := unwrapped_fields1116[0].(*pb.RelationId) + p.pretty_relation_id(field1117) p.newline() - field1102 := unwrapped_fields1100[1].(*pb.Abstraction) - p.pretty_abstraction(field1102) + field1118 := unwrapped_fields1116[1].(*pb.Abstraction) + p.pretty_abstraction(field1118) p.newline() - field1103 := unwrapped_fields1100[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1103) + field1119 := unwrapped_fields1116[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1119) p.newline() - field1104 := unwrapped_fields1100[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1104) + field1120 := unwrapped_fields1116[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1120) p.dedent() p.write(")") } @@ -3447,22 +3456,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1109 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1109 != nil { - p.write(*flat1109) + flat1125 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1125 != nil { + p.write(*flat1125) return nil } else { - fields1106 := msg + fields1122 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1106) == 0) { + if !(len(fields1122) == 0) { p.newline() - for i1108, elem1107 := range fields1106 { - if (i1108 > 0) { + for i1124, elem1123 := range fields1122 { + if (i1124 > 0) { p.newline() } - p.pretty_var(elem1107) + p.pretty_var(elem1123) } } p.dedent() @@ -3472,22 +3481,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1113 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1113 != nil { - p.write(*flat1113) + flat1129 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1129 != nil { + p.write(*flat1129) return nil } else { - fields1110 := msg + fields1126 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1110) == 0) { + if !(len(fields1126) == 0) { p.newline() - for i1112, elem1111 := range fields1110 { - if (i1112 > 0) { + for i1128, elem1127 := range fields1126 { + if (i1128 > 0) { p.newline() } - p.pretty_var(elem1111) + p.pretty_var(elem1127) } } p.dedent() @@ -3497,49 +3506,49 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1120 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1120 != nil { - p.write(*flat1120) + flat1136 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1136 != nil { + p.write(*flat1136) return nil } else { - _t1590 := func(_dollar_dollar *pb.Data) *pb.RelEDB { - var _t1591 *pb.RelEDB + _t1622 := func(_dollar_dollar *pb.Data) *pb.RelEDB { + var _t1623 *pb.RelEDB if hasProtoField(_dollar_dollar, "rel_edb") { - _t1591 = _dollar_dollar.GetRelEdb() + _t1623 = _dollar_dollar.GetRelEdb() } - return _t1591 + return _t1623 } - _t1592 := _t1590(msg) - deconstruct_result1118 := _t1592 - if deconstruct_result1118 != nil { - unwrapped1119 := deconstruct_result1118 - p.pretty_rel_edb(unwrapped1119) + _t1624 := _t1622(msg) + deconstruct_result1134 := _t1624 + if deconstruct_result1134 != nil { + unwrapped1135 := deconstruct_result1134 + p.pretty_rel_edb(unwrapped1135) } else { - _t1593 := func(_dollar_dollar *pb.Data) *pb.BeTreeRelation { - var _t1594 *pb.BeTreeRelation + _t1625 := func(_dollar_dollar *pb.Data) *pb.BeTreeRelation { + var _t1626 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1594 = _dollar_dollar.GetBetreeRelation() + _t1626 = _dollar_dollar.GetBetreeRelation() } - return _t1594 + return _t1626 } - _t1595 := _t1593(msg) - deconstruct_result1116 := _t1595 - if deconstruct_result1116 != nil { - unwrapped1117 := deconstruct_result1116 - p.pretty_betree_relation(unwrapped1117) + _t1627 := _t1625(msg) + deconstruct_result1132 := _t1627 + if deconstruct_result1132 != nil { + unwrapped1133 := deconstruct_result1132 + p.pretty_betree_relation(unwrapped1133) } else { - _t1596 := func(_dollar_dollar *pb.Data) *pb.CSVData { - var _t1597 *pb.CSVData + _t1628 := func(_dollar_dollar *pb.Data) *pb.CSVData { + var _t1629 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1597 = _dollar_dollar.GetCsvData() + _t1629 = _dollar_dollar.GetCsvData() } - return _t1597 + return _t1629 } - _t1598 := _t1596(msg) - deconstruct_result1114 := _t1598 - if deconstruct_result1114 != nil { - unwrapped1115 := deconstruct_result1114 - p.pretty_csv_data(unwrapped1115) + _t1630 := _t1628(msg) + deconstruct_result1130 := _t1630 + if deconstruct_result1130 != nil { + unwrapped1131 := deconstruct_result1130 + p.pretty_csv_data(unwrapped1131) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3550,29 +3559,29 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_rel_edb(msg *pb.RelEDB) interface{} { - flat1126 := p.tryFlat(msg, func() { p.pretty_rel_edb(msg) }) - if flat1126 != nil { - p.write(*flat1126) + flat1142 := p.tryFlat(msg, func() { p.pretty_rel_edb(msg) }) + if flat1142 != nil { + p.write(*flat1142) return nil } else { - _t1599 := func(_dollar_dollar *pb.RelEDB) []interface{} { + _t1631 := func(_dollar_dollar *pb.RelEDB) []interface{} { return []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} } - _t1600 := _t1599(msg) - fields1121 := _t1600 - unwrapped_fields1122 := fields1121 + _t1632 := _t1631(msg) + fields1137 := _t1632 + unwrapped_fields1138 := fields1137 p.write("(") p.write("rel_edb") p.indentSexp() p.newline() - field1123 := unwrapped_fields1122[0].(*pb.RelationId) - p.pretty_relation_id(field1123) + field1139 := unwrapped_fields1138[0].(*pb.RelationId) + p.pretty_relation_id(field1139) p.newline() - field1124 := unwrapped_fields1122[1].([]string) - p.pretty_rel_edb_path(field1124) + field1140 := unwrapped_fields1138[1].([]string) + p.pretty_rel_edb_path(field1140) p.newline() - field1125 := unwrapped_fields1122[2].([]*pb.Type) - p.pretty_rel_edb_types(field1125) + field1141 := unwrapped_fields1138[2].([]*pb.Type) + p.pretty_rel_edb_types(field1141) p.dedent() p.write(")") } @@ -3580,19 +3589,19 @@ func (p *PrettyPrinter) pretty_rel_edb(msg *pb.RelEDB) interface{} { } func (p *PrettyPrinter) pretty_rel_edb_path(msg []string) interface{} { - flat1130 := p.tryFlat(msg, func() { p.pretty_rel_edb_path(msg) }) - if flat1130 != nil { - p.write(*flat1130) + flat1146 := p.tryFlat(msg, func() { p.pretty_rel_edb_path(msg) }) + if flat1146 != nil { + p.write(*flat1146) return nil } else { - fields1127 := msg + fields1143 := msg p.write("[") p.indent() - for i1129, elem1128 := range fields1127 { - if (i1129 > 0) { + for i1145, elem1144 := range fields1143 { + if (i1145 > 0) { p.newline() } - p.write(p.formatStringValue(elem1128)) + p.write(p.formatStringValue(elem1144)) } p.dedent() p.write("]") @@ -3601,19 +3610,19 @@ func (p *PrettyPrinter) pretty_rel_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_rel_edb_types(msg []*pb.Type) interface{} { - flat1134 := p.tryFlat(msg, func() { p.pretty_rel_edb_types(msg) }) - if flat1134 != nil { - p.write(*flat1134) + flat1150 := p.tryFlat(msg, func() { p.pretty_rel_edb_types(msg) }) + if flat1150 != nil { + p.write(*flat1150) return nil } else { - fields1131 := msg + fields1147 := msg p.write("[") p.indent() - for i1133, elem1132 := range fields1131 { - if (i1133 > 0) { + for i1149, elem1148 := range fields1147 { + if (i1149 > 0) { p.newline() } - p.pretty_type(elem1132) + p.pretty_type(elem1148) } p.dedent() p.write("]") @@ -3622,26 +3631,26 @@ func (p *PrettyPrinter) pretty_rel_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1139 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1139 != nil { - p.write(*flat1139) + flat1155 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1155 != nil { + p.write(*flat1155) return nil } else { - _t1601 := func(_dollar_dollar *pb.BeTreeRelation) []interface{} { + _t1633 := func(_dollar_dollar *pb.BeTreeRelation) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} } - _t1602 := _t1601(msg) - fields1135 := _t1602 - unwrapped_fields1136 := fields1135 + _t1634 := _t1633(msg) + fields1151 := _t1634 + unwrapped_fields1152 := fields1151 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1137 := unwrapped_fields1136[0].(*pb.RelationId) - p.pretty_relation_id(field1137) + field1153 := unwrapped_fields1152[0].(*pb.RelationId) + p.pretty_relation_id(field1153) p.newline() - field1138 := unwrapped_fields1136[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1138) + field1154 := unwrapped_fields1152[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1154) p.dedent() p.write(")") } @@ -3649,30 +3658,30 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1145 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1145 != nil { - p.write(*flat1145) + flat1161 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1161 != nil { + p.write(*flat1161) return nil } else { - _t1603 := func(_dollar_dollar *pb.BeTreeInfo) []interface{} { - _t1604 := p.deconstruct_betree_info_config(_dollar_dollar) - return []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1604} + _t1635 := func(_dollar_dollar *pb.BeTreeInfo) []interface{} { + _t1636 := p.deconstruct_betree_info_config(_dollar_dollar) + return []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1636} } - _t1605 := _t1603(msg) - fields1140 := _t1605 - unwrapped_fields1141 := fields1140 + _t1637 := _t1635(msg) + fields1156 := _t1637 + unwrapped_fields1157 := fields1156 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1142 := unwrapped_fields1141[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1142) + field1158 := unwrapped_fields1157[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1158) p.newline() - field1143 := unwrapped_fields1141[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1143) + field1159 := unwrapped_fields1157[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1159) p.newline() - field1144 := unwrapped_fields1141[2].([][]interface{}) - p.pretty_config_dict(field1144) + field1160 := unwrapped_fields1157[2].([][]interface{}) + p.pretty_config_dict(field1160) p.dedent() p.write(")") } @@ -3680,22 +3689,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1149 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1149 != nil { - p.write(*flat1149) + flat1165 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1165 != nil { + p.write(*flat1165) return nil } else { - fields1146 := msg + fields1162 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1146) == 0) { + if !(len(fields1162) == 0) { p.newline() - for i1148, elem1147 := range fields1146 { - if (i1148 > 0) { + for i1164, elem1163 := range fields1162 { + if (i1164 > 0) { p.newline() } - p.pretty_type(elem1147) + p.pretty_type(elem1163) } } p.dedent() @@ -3705,22 +3714,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{} { - flat1153 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1153 != nil { - p.write(*flat1153) + flat1169 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1169 != nil { + p.write(*flat1169) return nil } else { - fields1150 := msg + fields1166 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1150) == 0) { + if !(len(fields1166) == 0) { p.newline() - for i1152, elem1151 := range fields1150 { - if (i1152 > 0) { + for i1168, elem1167 := range fields1166 { + if (i1168 > 0) { p.newline() } - p.pretty_type(elem1151) + p.pretty_type(elem1167) } } p.dedent() @@ -3730,32 +3739,32 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1160 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1160 != nil { - p.write(*flat1160) + flat1176 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1176 != nil { + p.write(*flat1176) return nil } else { - _t1606 := func(_dollar_dollar *pb.CSVData) []interface{} { + _t1638 := func(_dollar_dollar *pb.CSVData) []interface{} { return []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} } - _t1607 := _t1606(msg) - fields1154 := _t1607 - unwrapped_fields1155 := fields1154 + _t1639 := _t1638(msg) + fields1170 := _t1639 + unwrapped_fields1171 := fields1170 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1156 := unwrapped_fields1155[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1156) + field1172 := unwrapped_fields1171[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1172) p.newline() - field1157 := unwrapped_fields1155[1].(*pb.CSVConfig) - p.pretty_csv_config(field1157) + field1173 := unwrapped_fields1171[1].(*pb.CSVConfig) + p.pretty_csv_config(field1173) p.newline() - field1158 := unwrapped_fields1155[2].([]*pb.CSVColumn) - p.pretty_csv_columns(field1158) + field1174 := unwrapped_fields1171[2].([]*pb.CSVColumn) + p.pretty_csv_columns(field1174) p.newline() - field1159 := unwrapped_fields1155[3].(string) - p.pretty_csv_asof(field1159) + field1175 := unwrapped_fields1171[3].(string) + p.pretty_csv_asof(field1175) p.dedent() p.write(")") } @@ -3763,39 +3772,39 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1167 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1167 != nil { - p.write(*flat1167) + flat1183 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1183 != nil { + p.write(*flat1183) return nil } else { - _t1608 := func(_dollar_dollar *pb.CSVLocator) []interface{} { - var _t1609 []string + _t1640 := func(_dollar_dollar *pb.CSVLocator) []interface{} { + var _t1641 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1609 = _dollar_dollar.GetPaths() + _t1641 = _dollar_dollar.GetPaths() } - var _t1610 *string + var _t1642 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1610 = ptr(string(_dollar_dollar.GetInlineData())) + _t1642 = ptr(string(_dollar_dollar.GetInlineData())) } - return []interface{}{_t1609, _t1610} + return []interface{}{_t1641, _t1642} } - _t1611 := _t1608(msg) - fields1161 := _t1611 - unwrapped_fields1162 := fields1161 + _t1643 := _t1640(msg) + fields1177 := _t1643 + unwrapped_fields1178 := fields1177 p.write("(") p.write("csv_locator") p.indentSexp() - field1163 := unwrapped_fields1162[0].([]string) - if field1163 != nil { + field1179 := unwrapped_fields1178[0].([]string) + if field1179 != nil { p.newline() - opt_val1164 := field1163 - p.pretty_csv_locator_paths(opt_val1164) + opt_val1180 := field1179 + p.pretty_csv_locator_paths(opt_val1180) } - field1165 := unwrapped_fields1162[1].(*string) - if field1165 != nil { + field1181 := unwrapped_fields1178[1].(*string) + if field1181 != nil { p.newline() - opt_val1166 := *field1165 - p.pretty_csv_locator_inline_data(opt_val1166) + opt_val1182 := *field1181 + p.pretty_csv_locator_inline_data(opt_val1182) } p.dedent() p.write(")") @@ -3804,22 +3813,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1171 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1171 != nil { - p.write(*flat1171) + flat1187 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1187 != nil { + p.write(*flat1187) return nil } else { - fields1168 := msg + fields1184 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1168) == 0) { + if !(len(fields1184) == 0) { p.newline() - for i1170, elem1169 := range fields1168 { - if (i1170 > 0) { + for i1186, elem1185 := range fields1184 { + if (i1186 > 0) { p.newline() } - p.write(p.formatStringValue(elem1169)) + p.write(p.formatStringValue(elem1185)) } } p.dedent() @@ -3829,17 +3838,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1173 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1173 != nil { - p.write(*flat1173) + flat1189 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1189 != nil { + p.write(*flat1189) return nil } else { - fields1172 := msg + fields1188 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1172)) + p.write(p.formatStringValue(fields1188)) p.dedent() p.write(")") } @@ -3847,23 +3856,23 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1176 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1176 != nil { - p.write(*flat1176) + flat1192 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1192 != nil { + p.write(*flat1192) return nil } else { - _t1612 := func(_dollar_dollar *pb.CSVConfig) [][]interface{} { - _t1613 := p.deconstruct_csv_config(_dollar_dollar) - return _t1613 + _t1644 := func(_dollar_dollar *pb.CSVConfig) [][]interface{} { + _t1645 := p.deconstruct_csv_config(_dollar_dollar) + return _t1645 } - _t1614 := _t1612(msg) - fields1174 := _t1614 - unwrapped_fields1175 := fields1174 + _t1646 := _t1644(msg) + fields1190 := _t1646 + unwrapped_fields1191 := fields1190 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields1175) + p.pretty_config_dict(unwrapped_fields1191) p.dedent() p.write(")") } @@ -3871,22 +3880,22 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty_csv_columns(msg []*pb.CSVColumn) interface{} { - flat1180 := p.tryFlat(msg, func() { p.pretty_csv_columns(msg) }) - if flat1180 != nil { - p.write(*flat1180) + flat1196 := p.tryFlat(msg, func() { p.pretty_csv_columns(msg) }) + if flat1196 != nil { + p.write(*flat1196) return nil } else { - fields1177 := msg + fields1193 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1177) == 0) { + if !(len(fields1193) == 0) { p.newline() - for i1179, elem1178 := range fields1177 { - if (i1179 > 0) { + for i1195, elem1194 := range fields1193 { + if (i1195 > 0) { p.newline() } - p.pretty_csv_column(elem1178) + p.pretty_csv_column(elem1194) } } p.dedent() @@ -3896,54 +3905,147 @@ func (p *PrettyPrinter) pretty_csv_columns(msg []*pb.CSVColumn) interface{} { } func (p *PrettyPrinter) pretty_csv_column(msg *pb.CSVColumn) interface{} { - flat1188 := p.tryFlat(msg, func() { p.pretty_csv_column(msg) }) - if flat1188 != nil { - p.write(*flat1188) + flat1202 := p.tryFlat(msg, func() { p.pretty_csv_column(msg) }) + if flat1202 != nil { + p.write(*flat1202) return nil } else { - _t1615 := func(_dollar_dollar *pb.CSVColumn) []interface{} { - return []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetTargetId(), _dollar_dollar.GetTypes()} + _t1647 := func(_dollar_dollar *pb.CSVColumn) []interface{} { + _t1648 := p.deconstruct_csv_column_tail(_dollar_dollar) + return []interface{}{_dollar_dollar.GetColumnPath(), _t1648} } - _t1616 := _t1615(msg) - fields1181 := _t1616 - unwrapped_fields1182 := fields1181 + _t1649 := _t1647(msg) + fields1197 := _t1649 + unwrapped_fields1198 := fields1197 p.write("(") p.write("column") p.indentSexp() p.newline() - field1183 := unwrapped_fields1182[0].(string) - p.write(p.formatStringValue(field1183)) - p.newline() - field1184 := unwrapped_fields1182[1].(*pb.RelationId) - p.pretty_relation_id(field1184) - p.newline() - p.write("[") - field1185 := unwrapped_fields1182[2].([]*pb.Type) - for i1187, elem1186 := range field1185 { - if (i1187 > 0) { - p.newline() - } - p.pretty_type(elem1186) + field1199 := unwrapped_fields1198[0].([]string) + p.pretty_csv_column_path(field1199) + field1200 := unwrapped_fields1198[1].([]interface{}) + if field1200 != nil { + p.newline() + opt_val1201 := field1200 + p.pretty_csv_column_tail(opt_val1201) } - p.write("]") p.dedent() p.write(")") } return nil } +func (p *PrettyPrinter) pretty_csv_column_path(msg []string) interface{} { + flat1209 := p.tryFlat(msg, func() { p.pretty_csv_column_path(msg) }) + if flat1209 != nil { + p.write(*flat1209) + return nil + } else { + _t1650 := func(_dollar_dollar []string) *string { + var _t1651 *string + if int64(len(_dollar_dollar)) == 1 { + _t1651 = ptr(_dollar_dollar[0]) + } + return _t1651 + } + _t1652 := _t1650(msg) + deconstruct_result1207 := _t1652 + if deconstruct_result1207 != nil { + unwrapped1208 := *deconstruct_result1207 + p.write(p.formatStringValue(unwrapped1208)) + } else { + _t1653 := func(_dollar_dollar []string) []string { + var _t1654 []string + if int64(len(_dollar_dollar)) != 1 { + _t1654 = _dollar_dollar + } + return _t1654 + } + _t1655 := _t1653(msg) + deconstruct_result1203 := _t1655 + if deconstruct_result1203 != nil { + unwrapped1204 := deconstruct_result1203 + p.write("[") + p.indent() + for i1206, elem1205 := range unwrapped1204 { + if (i1206 > 0) { + p.newline() + } + p.write(p.formatStringValue(elem1205)) + } + p.dedent() + p.write("]") + } else { + panic(ParseError{msg: "No matching rule for csv_column_path"}) + } + } + } + return nil +} + +func (p *PrettyPrinter) pretty_csv_column_tail(msg []interface{}) interface{} { + flat1220 := p.tryFlat(msg, func() { p.pretty_csv_column_tail(msg) }) + if flat1220 != nil { + p.write(*flat1220) + return nil + } else { + _t1656 := func(_dollar_dollar []interface{}) []interface{} { + var _t1657 []interface{} + if _dollar_dollar[0].(*pb.RelationId) != nil { + _t1657 = []interface{}{_dollar_dollar[0].(*pb.RelationId), _dollar_dollar[1].([]*pb.Type)} + } + return _t1657 + } + _t1658 := _t1656(msg) + deconstruct_result1214 := _t1658 + if deconstruct_result1214 != nil { + unwrapped1215 := deconstruct_result1214 + field1216 := unwrapped1215[0].(*pb.RelationId) + p.pretty_relation_id(field1216) + p.write(" ") + p.write("[") + field1217 := unwrapped1215[1].([]*pb.Type) + for i1219, elem1218 := range field1217 { + if (i1219 > 0) { + p.newline() + } + p.pretty_type(elem1218) + } + p.write("]") + } else { + _t1659 := func(_dollar_dollar []interface{}) []*pb.Type { + return _dollar_dollar[1].([]*pb.Type) + } + _t1660 := _t1659(msg) + fields1210 := _t1660 + unwrapped_fields1211 := fields1210 + p.write("[") + p.indent() + for i1213, elem1212 := range unwrapped_fields1211 { + if (i1213 > 0) { + p.newline() + } + p.pretty_type(elem1212) + } + p.dedent() + p.write("]") + } + } + return nil +} + func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1190 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1190 != nil { - p.write(*flat1190) + flat1222 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1222 != nil { + p.write(*flat1222) return nil } else { - fields1189 := msg + fields1221 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1189)) + p.write(p.formatStringValue(fields1221)) p.dedent() p.write(")") } @@ -3951,22 +4053,22 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1193 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1193 != nil { - p.write(*flat1193) + flat1225 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1225 != nil { + p.write(*flat1225) return nil } else { - _t1617 := func(_dollar_dollar *pb.Undefine) *pb.FragmentId { + _t1661 := func(_dollar_dollar *pb.Undefine) *pb.FragmentId { return _dollar_dollar.GetFragmentId() } - _t1618 := _t1617(msg) - fields1191 := _t1618 - unwrapped_fields1192 := fields1191 + _t1662 := _t1661(msg) + fields1223 := _t1662 + unwrapped_fields1224 := fields1223 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1192) + p.pretty_fragment_id(unwrapped_fields1224) p.dedent() p.write(")") } @@ -3974,27 +4076,27 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1198 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1198 != nil { - p.write(*flat1198) + flat1230 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1230 != nil { + p.write(*flat1230) return nil } else { - _t1619 := func(_dollar_dollar *pb.Context) []*pb.RelationId { + _t1663 := func(_dollar_dollar *pb.Context) []*pb.RelationId { return _dollar_dollar.GetRelations() } - _t1620 := _t1619(msg) - fields1194 := _t1620 - unwrapped_fields1195 := fields1194 + _t1664 := _t1663(msg) + fields1226 := _t1664 + unwrapped_fields1227 := fields1226 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1195) == 0) { + if !(len(unwrapped_fields1227) == 0) { p.newline() - for i1197, elem1196 := range unwrapped_fields1195 { - if (i1197 > 0) { + for i1229, elem1228 := range unwrapped_fields1227 { + if (i1229 > 0) { p.newline() } - p.pretty_relation_id(elem1196) + p.pretty_relation_id(elem1228) } } p.dedent() @@ -4004,26 +4106,26 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1203 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1203 != nil { - p.write(*flat1203) + flat1235 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1235 != nil { + p.write(*flat1235) return nil } else { - _t1621 := func(_dollar_dollar *pb.Snapshot) []interface{} { + _t1665 := func(_dollar_dollar *pb.Snapshot) []interface{} { return []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} } - _t1622 := _t1621(msg) - fields1199 := _t1622 - unwrapped_fields1200 := fields1199 + _t1666 := _t1665(msg) + fields1231 := _t1666 + unwrapped_fields1232 := fields1231 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1201 := unwrapped_fields1200[0].([]string) - p.pretty_rel_edb_path(field1201) + field1233 := unwrapped_fields1232[0].([]string) + p.pretty_rel_edb_path(field1233) p.newline() - field1202 := unwrapped_fields1200[1].(*pb.RelationId) - p.pretty_relation_id(field1202) + field1234 := unwrapped_fields1232[1].(*pb.RelationId) + p.pretty_relation_id(field1234) p.dedent() p.write(")") } @@ -4031,22 +4133,22 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1207 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1207 != nil { - p.write(*flat1207) + flat1239 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1239 != nil { + p.write(*flat1239) return nil } else { - fields1204 := msg + fields1236 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1204) == 0) { + if !(len(fields1236) == 0) { p.newline() - for i1206, elem1205 := range fields1204 { - if (i1206 > 0) { + for i1238, elem1237 := range fields1236 { + if (i1238 > 0) { p.newline() } - p.pretty_read(elem1205) + p.pretty_read(elem1237) } } p.dedent() @@ -4056,75 +4158,75 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1218 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1218 != nil { - p.write(*flat1218) + flat1250 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1250 != nil { + p.write(*flat1250) return nil } else { - _t1623 := func(_dollar_dollar *pb.Read) *pb.Demand { - var _t1624 *pb.Demand + _t1667 := func(_dollar_dollar *pb.Read) *pb.Demand { + var _t1668 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1624 = _dollar_dollar.GetDemand() + _t1668 = _dollar_dollar.GetDemand() } - return _t1624 + return _t1668 } - _t1625 := _t1623(msg) - deconstruct_result1216 := _t1625 - if deconstruct_result1216 != nil { - unwrapped1217 := deconstruct_result1216 - p.pretty_demand(unwrapped1217) + _t1669 := _t1667(msg) + deconstruct_result1248 := _t1669 + if deconstruct_result1248 != nil { + unwrapped1249 := deconstruct_result1248 + p.pretty_demand(unwrapped1249) } else { - _t1626 := func(_dollar_dollar *pb.Read) *pb.Output { - var _t1627 *pb.Output + _t1670 := func(_dollar_dollar *pb.Read) *pb.Output { + var _t1671 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1627 = _dollar_dollar.GetOutput() + _t1671 = _dollar_dollar.GetOutput() } - return _t1627 + return _t1671 } - _t1628 := _t1626(msg) - deconstruct_result1214 := _t1628 - if deconstruct_result1214 != nil { - unwrapped1215 := deconstruct_result1214 - p.pretty_output(unwrapped1215) + _t1672 := _t1670(msg) + deconstruct_result1246 := _t1672 + if deconstruct_result1246 != nil { + unwrapped1247 := deconstruct_result1246 + p.pretty_output(unwrapped1247) } else { - _t1629 := func(_dollar_dollar *pb.Read) *pb.WhatIf { - var _t1630 *pb.WhatIf + _t1673 := func(_dollar_dollar *pb.Read) *pb.WhatIf { + var _t1674 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1630 = _dollar_dollar.GetWhatIf() + _t1674 = _dollar_dollar.GetWhatIf() } - return _t1630 + return _t1674 } - _t1631 := _t1629(msg) - deconstruct_result1212 := _t1631 - if deconstruct_result1212 != nil { - unwrapped1213 := deconstruct_result1212 - p.pretty_what_if(unwrapped1213) + _t1675 := _t1673(msg) + deconstruct_result1244 := _t1675 + if deconstruct_result1244 != nil { + unwrapped1245 := deconstruct_result1244 + p.pretty_what_if(unwrapped1245) } else { - _t1632 := func(_dollar_dollar *pb.Read) *pb.Abort { - var _t1633 *pb.Abort + _t1676 := func(_dollar_dollar *pb.Read) *pb.Abort { + var _t1677 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1633 = _dollar_dollar.GetAbort() + _t1677 = _dollar_dollar.GetAbort() } - return _t1633 + return _t1677 } - _t1634 := _t1632(msg) - deconstruct_result1210 := _t1634 - if deconstruct_result1210 != nil { - unwrapped1211 := deconstruct_result1210 - p.pretty_abort(unwrapped1211) + _t1678 := _t1676(msg) + deconstruct_result1242 := _t1678 + if deconstruct_result1242 != nil { + unwrapped1243 := deconstruct_result1242 + p.pretty_abort(unwrapped1243) } else { - _t1635 := func(_dollar_dollar *pb.Read) *pb.Export { - var _t1636 *pb.Export + _t1679 := func(_dollar_dollar *pb.Read) *pb.Export { + var _t1680 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1636 = _dollar_dollar.GetExport() + _t1680 = _dollar_dollar.GetExport() } - return _t1636 + return _t1680 } - _t1637 := _t1635(msg) - deconstruct_result1208 := _t1637 - if deconstruct_result1208 != nil { - unwrapped1209 := deconstruct_result1208 - p.pretty_export(unwrapped1209) + _t1681 := _t1679(msg) + deconstruct_result1240 := _t1681 + if deconstruct_result1240 != nil { + unwrapped1241 := deconstruct_result1240 + p.pretty_export(unwrapped1241) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4137,22 +4239,22 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1221 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1221 != nil { - p.write(*flat1221) + flat1253 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1253 != nil { + p.write(*flat1253) return nil } else { - _t1638 := func(_dollar_dollar *pb.Demand) *pb.RelationId { + _t1682 := func(_dollar_dollar *pb.Demand) *pb.RelationId { return _dollar_dollar.GetRelationId() } - _t1639 := _t1638(msg) - fields1219 := _t1639 - unwrapped_fields1220 := fields1219 + _t1683 := _t1682(msg) + fields1251 := _t1683 + unwrapped_fields1252 := fields1251 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1220) + p.pretty_relation_id(unwrapped_fields1252) p.dedent() p.write(")") } @@ -4160,26 +4262,26 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1226 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1226 != nil { - p.write(*flat1226) + flat1258 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1258 != nil { + p.write(*flat1258) return nil } else { - _t1640 := func(_dollar_dollar *pb.Output) []interface{} { + _t1684 := func(_dollar_dollar *pb.Output) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} } - _t1641 := _t1640(msg) - fields1222 := _t1641 - unwrapped_fields1223 := fields1222 + _t1685 := _t1684(msg) + fields1254 := _t1685 + unwrapped_fields1255 := fields1254 p.write("(") p.write("output") p.indentSexp() p.newline() - field1224 := unwrapped_fields1223[0].(string) - p.pretty_name(field1224) + field1256 := unwrapped_fields1255[0].(string) + p.pretty_name(field1256) p.newline() - field1225 := unwrapped_fields1223[1].(*pb.RelationId) - p.pretty_relation_id(field1225) + field1257 := unwrapped_fields1255[1].(*pb.RelationId) + p.pretty_relation_id(field1257) p.dedent() p.write(")") } @@ -4187,26 +4289,26 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1231 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1231 != nil { - p.write(*flat1231) + flat1263 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1263 != nil { + p.write(*flat1263) return nil } else { - _t1642 := func(_dollar_dollar *pb.WhatIf) []interface{} { + _t1686 := func(_dollar_dollar *pb.WhatIf) []interface{} { return []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} } - _t1643 := _t1642(msg) - fields1227 := _t1643 - unwrapped_fields1228 := fields1227 + _t1687 := _t1686(msg) + fields1259 := _t1687 + unwrapped_fields1260 := fields1259 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1229 := unwrapped_fields1228[0].(string) - p.pretty_name(field1229) + field1261 := unwrapped_fields1260[0].(string) + p.pretty_name(field1261) p.newline() - field1230 := unwrapped_fields1228[1].(*pb.Epoch) - p.pretty_epoch(field1230) + field1262 := unwrapped_fields1260[1].(*pb.Epoch) + p.pretty_epoch(field1262) p.dedent() p.write(")") } @@ -4214,33 +4316,33 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1237 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1237 != nil { - p.write(*flat1237) + flat1269 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1269 != nil { + p.write(*flat1269) return nil } else { - _t1644 := func(_dollar_dollar *pb.Abort) []interface{} { - var _t1645 *string + _t1688 := func(_dollar_dollar *pb.Abort) []interface{} { + var _t1689 *string if _dollar_dollar.GetName() != "abort" { - _t1645 = ptr(_dollar_dollar.GetName()) + _t1689 = ptr(_dollar_dollar.GetName()) } - return []interface{}{_t1645, _dollar_dollar.GetRelationId()} + return []interface{}{_t1689, _dollar_dollar.GetRelationId()} } - _t1646 := _t1644(msg) - fields1232 := _t1646 - unwrapped_fields1233 := fields1232 + _t1690 := _t1688(msg) + fields1264 := _t1690 + unwrapped_fields1265 := fields1264 p.write("(") p.write("abort") p.indentSexp() - field1234 := unwrapped_fields1233[0].(*string) - if field1234 != nil { + field1266 := unwrapped_fields1265[0].(*string) + if field1266 != nil { p.newline() - opt_val1235 := *field1234 - p.pretty_name(opt_val1235) + opt_val1267 := *field1266 + p.pretty_name(opt_val1267) } p.newline() - field1236 := unwrapped_fields1233[1].(*pb.RelationId) - p.pretty_relation_id(field1236) + field1268 := unwrapped_fields1265[1].(*pb.RelationId) + p.pretty_relation_id(field1268) p.dedent() p.write(")") } @@ -4248,22 +4350,22 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1240 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1240 != nil { - p.write(*flat1240) + flat1272 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1272 != nil { + p.write(*flat1272) return nil } else { - _t1647 := func(_dollar_dollar *pb.Export) *pb.ExportCSVConfig { + _t1691 := func(_dollar_dollar *pb.Export) *pb.ExportCSVConfig { return _dollar_dollar.GetCsvConfig() } - _t1648 := _t1647(msg) - fields1238 := _t1648 - unwrapped_fields1239 := fields1238 + _t1692 := _t1691(msg) + fields1270 := _t1692 + unwrapped_fields1271 := fields1270 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped_fields1239) + p.pretty_export_csv_config(unwrapped_fields1271) p.dedent() p.write(")") } @@ -4271,30 +4373,30 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1246 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1246 != nil { - p.write(*flat1246) + flat1278 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1278 != nil { + p.write(*flat1278) return nil } else { - _t1649 := func(_dollar_dollar *pb.ExportCSVConfig) []interface{} { - _t1650 := p.deconstruct_export_csv_config(_dollar_dollar) - return []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1650} + _t1693 := func(_dollar_dollar *pb.ExportCSVConfig) []interface{} { + _t1694 := p.deconstruct_export_csv_config(_dollar_dollar) + return []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1694} } - _t1651 := _t1649(msg) - fields1241 := _t1651 - unwrapped_fields1242 := fields1241 + _t1695 := _t1693(msg) + fields1273 := _t1695 + unwrapped_fields1274 := fields1273 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1243 := unwrapped_fields1242[0].(string) - p.pretty_export_csv_path(field1243) + field1275 := unwrapped_fields1274[0].(string) + p.pretty_export_csv_path(field1275) p.newline() - field1244 := unwrapped_fields1242[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns(field1244) + field1276 := unwrapped_fields1274[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns(field1276) p.newline() - field1245 := unwrapped_fields1242[2].([][]interface{}) - p.pretty_config_dict(field1245) + field1277 := unwrapped_fields1274[2].([][]interface{}) + p.pretty_config_dict(field1277) p.dedent() p.write(")") } @@ -4302,17 +4404,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1248 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1248 != nil { - p.write(*flat1248) + flat1280 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1280 != nil { + p.write(*flat1280) return nil } else { - fields1247 := msg + fields1279 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1247)) + p.write(p.formatStringValue(fields1279)) p.dedent() p.write(")") } @@ -4320,22 +4422,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) interface{} { - flat1252 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) }) - if flat1252 != nil { - p.write(*flat1252) + flat1284 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) }) + if flat1284 != nil { + p.write(*flat1284) return nil } else { - fields1249 := msg + fields1281 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1249) == 0) { + if !(len(fields1281) == 0) { p.newline() - for i1251, elem1250 := range fields1249 { - if (i1251 > 0) { + for i1283, elem1282 := range fields1281 { + if (i1283 > 0) { p.newline() } - p.pretty_export_csv_column(elem1250) + p.pretty_export_csv_column(elem1282) } } p.dedent() @@ -4345,26 +4447,26 @@ func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) int } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1257 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1257 != nil { - p.write(*flat1257) + flat1289 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1289 != nil { + p.write(*flat1289) return nil } else { - _t1652 := func(_dollar_dollar *pb.ExportCSVColumn) []interface{} { + _t1696 := func(_dollar_dollar *pb.ExportCSVColumn) []interface{} { return []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} } - _t1653 := _t1652(msg) - fields1253 := _t1653 - unwrapped_fields1254 := fields1253 + _t1697 := _t1696(msg) + fields1285 := _t1697 + unwrapped_fields1286 := fields1285 p.write("(") p.write("column") p.indentSexp() p.newline() - field1255 := unwrapped_fields1254[0].(string) - p.write(p.formatStringValue(field1255)) + field1287 := unwrapped_fields1286[0].(string) + p.write(p.formatStringValue(field1287)) p.newline() - field1256 := unwrapped_fields1254[1].(*pb.RelationId) - p.pretty_relation_id(field1256) + field1288 := unwrapped_fields1286[1].(*pb.RelationId) + p.pretty_relation_id(field1288) p.dedent() p.write(")") } @@ -4380,8 +4482,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1691 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1691) + _t1736 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1736) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 31402b6a..9283123f 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -498,9 +498,9 @@ Base.hash(a::BeTreeInfo, h::UInt) = hash(a.relation_locator, hash(a.storage_conf Base.isequal(a::BeTreeInfo, b::BeTreeInfo) = isequal(a.key_types, b.key_types) && isequal(a.value_types, b.value_types) && isequal(a.storage_config, b.storage_config) && isequal(a.relation_locator, b.relation_locator) # CSVColumn -Base.:(==)(a::CSVColumn, b::CSVColumn) = a.column_name == b.column_name && a.target_id == b.target_id && a.types == b.types -Base.hash(a::CSVColumn, h::UInt) = hash(a.types, hash(a.target_id, hash(a.column_name, h))) -Base.isequal(a::CSVColumn, b::CSVColumn) = isequal(a.column_name, b.column_name) && isequal(a.target_id, b.target_id) && isequal(a.types, b.types) +Base.:(==)(a::CSVColumn, b::CSVColumn) = a.column_path == b.column_path && a.target_id == b.target_id && a.types == b.types +Base.hash(a::CSVColumn, h::UInt) = hash(a.types, hash(a.target_id, hash(a.column_path, h))) +Base.isequal(a::CSVColumn, b::CSVColumn) = isequal(a.column_path, b.column_path) && isequal(a.target_id, b.target_id) && isequal(a.types, b.types) # BeTreeRelation Base.:(==)(a::BeTreeRelation, b::BeTreeRelation) = a.name == b.name && a.relation_info == b.relation_info diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl index 268f4944..b94867b5 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl @@ -1,4 +1,4 @@ -# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-18T23:42:15.080 +# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-24T19:44:16.194 # original file: /Users/niko/Projects/logical-query-protocol/proto/relationalai/lqp/v1/fragments.proto (proto3 syntax) import ProtoBuf as PB 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 f5429eab..fecfa050 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 @@ -1,4 +1,4 @@ -# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-18T23:42:14.655 +# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-24T19:44:15.762 # original file: /Users/niko/Projects/logical-query-protocol/proto/relationalai/lqp/v1/logic.proto (proto3 syntax) import ProtoBuf as PB @@ -1251,22 +1251,22 @@ function PB._encoded_size(x::Binding) end struct CSVColumn - column_name::String + column_path::Vector{String} target_id::Union{Nothing,RelationId} types::Vector{var"#Type"} end -CSVColumn(;column_name = "", target_id = nothing, types = Vector{var"#Type"}()) = CSVColumn(column_name, target_id, types) -PB.default_values(::Type{CSVColumn}) = (;column_name = "", target_id = nothing, types = Vector{var"#Type"}()) -PB.field_numbers(::Type{CSVColumn}) = (;column_name = 1, target_id = 2, types = 3) +CSVColumn(;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) = CSVColumn(column_path, target_id, types) +PB.default_values(::Type{CSVColumn}) = (;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) +PB.field_numbers(::Type{CSVColumn}) = (;column_path = 1, target_id = 2, types = 3) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVColumn}) - column_name = "" + column_path = PB.BufferedVector{String}() target_id = Ref{Union{Nothing,RelationId}}(nothing) types = PB.BufferedVector{var"#Type"}() while !PB.message_done(d) field_number, wire_type = PB.decode_tag(d) if field_number == 1 - column_name = PB.decode(d, String) + PB.decode!(d, column_path) elseif field_number == 2 PB.decode!(d, target_id) elseif field_number == 3 @@ -1275,19 +1275,19 @@ function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVColumn}) Base.skip(d, wire_type) end end - return CSVColumn(column_name, target_id[], types[]) + return CSVColumn(column_path[], target_id[], types[]) end function PB.encode(e::PB.AbstractProtoEncoder, x::CSVColumn) initpos = position(e.io) - !isempty(x.column_name) && PB.encode(e, 1, x.column_name) + !isempty(x.column_path) && PB.encode(e, 1, x.column_path) !isnothing(x.target_id) && PB.encode(e, 2, x.target_id) !isempty(x.types) && PB.encode(e, 3, x.types) return position(e.io) - initpos end function PB._encoded_size(x::CSVColumn) encoded_size = 0 - !isempty(x.column_name) && (encoded_size += PB._encoded_size(x.column_name, 1)) + !isempty(x.column_path) && (encoded_size += PB._encoded_size(x.column_path, 1)) !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 2)) !isempty(x.types) && (encoded_size += PB._encoded_size(x.types, 3)) return encoded_size diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl index 28028128..7b9af9af 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl @@ -1,4 +1,4 @@ -# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-18T23:42:15.080 +# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-24T19:44:16.195 # original file: /Users/niko/Projects/logical-query-protocol/proto/relationalai/lqp/v1/transactions.proto (proto3 syntax) import ProtoBuf as PB diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 361e1130..c6a51019 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -305,7 +305,7 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return Int32(_get_oneof_field(value, :int_value)) else - _t1311 = nothing + _t1348 = nothing end return Int32(default) end @@ -314,7 +314,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 - _t1312 = nothing + _t1349 = nothing end return default end @@ -323,7 +323,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 - _t1313 = nothing + _t1350 = nothing end return default end @@ -332,7 +332,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 - _t1314 = nothing + _t1351 = nothing end return default end @@ -341,7 +341,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 - _t1315 = nothing + _t1352 = nothing end return default end @@ -350,7 +350,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 - _t1316 = nothing + _t1353 = nothing end return nothing end @@ -359,7 +359,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 - _t1317 = nothing + _t1354 = nothing end return nothing end @@ -368,7 +368,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 - _t1318 = nothing + _t1355 = nothing end return nothing end @@ -377,70 +377,70 @@ 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 - _t1319 = nothing + _t1356 = nothing end return nothing end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.CSVConfig config = Dict(config_dict) - _t1320 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t1320 - _t1321 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t1321 - _t1322 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t1322 - _t1323 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t1323 - _t1324 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t1324 - _t1325 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t1325 - _t1326 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t1326 - _t1327 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t1327 - _t1328 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t1328 - _t1329 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t1329 - _t1330 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") - compression = _t1330 - _t1331 = 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) - return _t1331 + _t1357 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t1357 + _t1358 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t1358 + _t1359 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t1359 + _t1360 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t1360 + _t1361 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t1361 + _t1362 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t1362 + _t1363 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t1363 + _t1364 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t1364 + _t1365 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t1365 + _t1366 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t1366 + _t1367 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") + compression = _t1367 + _t1368 = 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) + return _t1368 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) - _t1332 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t1332 - _t1333 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t1333 - _t1334 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t1334 - _t1335 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t1335 - _t1336 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t1336 - _t1337 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t1337 - _t1338 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t1338 - _t1339 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t1339 - _t1340 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t1340 - _t1341 = 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 = _t1341 - _t1342 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t1342 + _t1369 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t1369 + _t1370 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t1370 + _t1371 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t1371 + _t1372 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t1372 + _t1373 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t1373 + _t1374 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t1374 + _t1375 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t1375 + _t1376 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t1376 + _t1377 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t1377 + _t1378 = 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 = _t1378 + _t1379 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t1379 end function default_configure(parser::ParserState)::Proto.Configure - _t1343 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t1343 - _t1344 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t1344 + _t1380 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t1380 + _t1381 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t1381 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -462,32 +462,44 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t1345 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t1345 - _t1346 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t1346 - _t1347 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t1347 + _t1382 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t1382 + _t1383 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t1383 + _t1384 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t1384 end function export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t1348 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t1348 - _t1349 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t1349 - _t1350 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t1350 - _t1351 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t1351 - _t1352 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t1352 - _t1353 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t1353 - _t1354 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t1354 - _t1355 = 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 _t1355 + _t1385 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t1385 + _t1386 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t1386 + _t1387 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t1387 + _t1388 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t1388 + _t1389 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t1389 + _t1390 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t1390 + _t1391 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t1391 + _t1392 = 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 _t1392 +end + +function construct_csv_column(parser::ParserState, path::Vector{String}, tail::Union{Nothing, Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}})::Proto.CSVColumn + if !isnothing(tail) + t = tail + _t1394 = Proto.CSVColumn(column_path=path, target_id=t[1], types=t[2]) + return _t1394 + else + _t1393 = nothing + end + _t1395 = Proto.CSVColumn(column_path=path, target_id=nothing, types=Proto.var"#Type"[]) + return _t1395 end # --- Parse functions --- @@ -496,2699 +508,2784 @@ function parse_transaction(parser::ParserState)::Proto.Transaction consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t713 = parse_configure(parser) - _t712 = _t713 + _t737 = parse_configure(parser) + _t736 = _t737 else - _t712 = nothing + _t736 = nothing end - configure356 = _t712 + configure368 = _t736 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t715 = parse_sync(parser) - _t714 = _t715 + _t739 = parse_sync(parser) + _t738 = _t739 else - _t714 = nothing + _t738 = nothing end - sync357 = _t714 - xs358 = Proto.Epoch[] - cond359 = match_lookahead_literal(parser, "(", 0) - while cond359 - _t716 = parse_epoch(parser) - item360 = _t716 - push!(xs358, item360) - cond359 = match_lookahead_literal(parser, "(", 0) + sync369 = _t738 + xs370 = Proto.Epoch[] + cond371 = match_lookahead_literal(parser, "(", 0) + while cond371 + _t740 = parse_epoch(parser) + item372 = _t740 + push!(xs370, item372) + cond371 = match_lookahead_literal(parser, "(", 0) end - epochs361 = xs358 + epochs373 = xs370 consume_literal!(parser, ")") - _t717 = default_configure(parser) - _t718 = Proto.Transaction(epochs=epochs361, configure=(!isnothing(configure356) ? configure356 : _t717), sync=sync357) - return _t718 + _t741 = default_configure(parser) + _t742 = Proto.Transaction(epochs=epochs373, configure=(!isnothing(configure368) ? configure368 : _t741), sync=sync369) + return _t742 end function parse_configure(parser::ParserState)::Proto.Configure consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t719 = parse_config_dict(parser) - config_dict362 = _t719 + _t743 = parse_config_dict(parser) + config_dict374 = _t743 consume_literal!(parser, ")") - _t720 = construct_configure(parser, config_dict362) - return _t720 + _t744 = construct_configure(parser, config_dict374) + return _t744 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs363 = Tuple{String, Proto.Value}[] - cond364 = match_lookahead_literal(parser, ":", 0) - while cond364 - _t721 = parse_config_key_value(parser) - item365 = _t721 - push!(xs363, item365) - cond364 = match_lookahead_literal(parser, ":", 0) - end - config_key_values366 = xs363 + xs375 = Tuple{String, Proto.Value}[] + cond376 = match_lookahead_literal(parser, ":", 0) + while cond376 + _t745 = parse_config_key_value(parser) + item377 = _t745 + push!(xs375, item377) + cond376 = match_lookahead_literal(parser, ":", 0) + end + config_key_values378 = xs375 consume_literal!(parser, "}") - return config_key_values366 + return config_key_values378 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol367 = consume_terminal!(parser, "SYMBOL") - _t722 = parse_value(parser) - value368 = _t722 - return (symbol367, value368,) + symbol379 = consume_terminal!(parser, "SYMBOL") + _t746 = parse_value(parser) + value380 = _t746 + return (symbol379, value380,) end function parse_value(parser::ParserState)::Proto.Value if match_lookahead_literal(parser, "true", 0) - _t723 = 9 + _t747 = 9 else if match_lookahead_literal(parser, "missing", 0) - _t724 = 8 + _t748 = 8 else if match_lookahead_literal(parser, "false", 0) - _t725 = 9 + _t749 = 9 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t727 = 1 + _t751 = 1 else if match_lookahead_literal(parser, "date", 1) - _t728 = 0 + _t752 = 0 else - _t728 = -1 + _t752 = -1 end - _t727 = _t728 + _t751 = _t752 end - _t726 = _t727 + _t750 = _t751 else if match_lookahead_terminal(parser, "UINT128", 0) - _t729 = 5 + _t753 = 5 else if match_lookahead_terminal(parser, "STRING", 0) - _t730 = 2 + _t754 = 2 else if match_lookahead_terminal(parser, "INT128", 0) - _t731 = 6 + _t755 = 6 else if match_lookahead_terminal(parser, "INT", 0) - _t732 = 3 + _t756 = 3 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t733 = 4 + _t757 = 4 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t734 = 7 + _t758 = 7 else - _t734 = -1 + _t758 = -1 end - _t733 = _t734 + _t757 = _t758 end - _t732 = _t733 + _t756 = _t757 end - _t731 = _t732 + _t755 = _t756 end - _t730 = _t731 + _t754 = _t755 end - _t729 = _t730 + _t753 = _t754 end - _t726 = _t729 + _t750 = _t753 end - _t725 = _t726 + _t749 = _t750 end - _t724 = _t725 + _t748 = _t749 end - _t723 = _t724 - end - prediction369 = _t723 - if prediction369 == 9 - _t736 = parse_boolean_value(parser) - boolean_value378 = _t736 - _t737 = Proto.Value(value=OneOf(:boolean_value, boolean_value378)) - _t735 = _t737 + _t747 = _t748 + end + prediction381 = _t747 + if prediction381 == 9 + _t760 = parse_boolean_value(parser) + boolean_value390 = _t760 + _t761 = Proto.Value(value=OneOf(:boolean_value, boolean_value390)) + _t759 = _t761 else - if prediction369 == 8 + if prediction381 == 8 consume_literal!(parser, "missing") - _t739 = Proto.MissingValue() - _t740 = Proto.Value(value=OneOf(:missing_value, _t739)) - _t738 = _t740 + _t763 = Proto.MissingValue() + _t764 = Proto.Value(value=OneOf(:missing_value, _t763)) + _t762 = _t764 else - if prediction369 == 7 - decimal377 = consume_terminal!(parser, "DECIMAL") - _t742 = Proto.Value(value=OneOf(:decimal_value, decimal377)) - _t741 = _t742 + if prediction381 == 7 + decimal389 = consume_terminal!(parser, "DECIMAL") + _t766 = Proto.Value(value=OneOf(:decimal_value, decimal389)) + _t765 = _t766 else - if prediction369 == 6 - int128376 = consume_terminal!(parser, "INT128") - _t744 = Proto.Value(value=OneOf(:int128_value, int128376)) - _t743 = _t744 + if prediction381 == 6 + int128388 = consume_terminal!(parser, "INT128") + _t768 = Proto.Value(value=OneOf(:int128_value, int128388)) + _t767 = _t768 else - if prediction369 == 5 - uint128375 = consume_terminal!(parser, "UINT128") - _t746 = Proto.Value(value=OneOf(:uint128_value, uint128375)) - _t745 = _t746 + if prediction381 == 5 + uint128387 = consume_terminal!(parser, "UINT128") + _t770 = Proto.Value(value=OneOf(:uint128_value, uint128387)) + _t769 = _t770 else - if prediction369 == 4 - float374 = consume_terminal!(parser, "FLOAT") - _t748 = Proto.Value(value=OneOf(:float_value, float374)) - _t747 = _t748 + if prediction381 == 4 + float386 = consume_terminal!(parser, "FLOAT") + _t772 = Proto.Value(value=OneOf(:float_value, float386)) + _t771 = _t772 else - if prediction369 == 3 - int373 = consume_terminal!(parser, "INT") - _t750 = Proto.Value(value=OneOf(:int_value, int373)) - _t749 = _t750 + if prediction381 == 3 + int385 = consume_terminal!(parser, "INT") + _t774 = Proto.Value(value=OneOf(:int_value, int385)) + _t773 = _t774 else - if prediction369 == 2 - string372 = consume_terminal!(parser, "STRING") - _t752 = Proto.Value(value=OneOf(:string_value, string372)) - _t751 = _t752 + if prediction381 == 2 + string384 = consume_terminal!(parser, "STRING") + _t776 = Proto.Value(value=OneOf(:string_value, string384)) + _t775 = _t776 else - if prediction369 == 1 - _t754 = parse_datetime(parser) - datetime371 = _t754 - _t755 = Proto.Value(value=OneOf(:datetime_value, datetime371)) - _t753 = _t755 + if prediction381 == 1 + _t778 = parse_datetime(parser) + datetime383 = _t778 + _t779 = Proto.Value(value=OneOf(:datetime_value, datetime383)) + _t777 = _t779 else - if prediction369 == 0 - _t757 = parse_date(parser) - date370 = _t757 - _t758 = Proto.Value(value=OneOf(:date_value, date370)) - _t756 = _t758 + if prediction381 == 0 + _t781 = parse_date(parser) + date382 = _t781 + _t782 = Proto.Value(value=OneOf(:date_value, date382)) + _t780 = _t782 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t753 = _t756 + _t777 = _t780 end - _t751 = _t753 + _t775 = _t777 end - _t749 = _t751 + _t773 = _t775 end - _t747 = _t749 + _t771 = _t773 end - _t745 = _t747 + _t769 = _t771 end - _t743 = _t745 + _t767 = _t769 end - _t741 = _t743 + _t765 = _t767 end - _t738 = _t741 + _t762 = _t765 end - _t735 = _t738 + _t759 = _t762 end - return _t735 + return _t759 end function parse_date(parser::ParserState)::Proto.DateValue consume_literal!(parser, "(") consume_literal!(parser, "date") - int379 = consume_terminal!(parser, "INT") - int_3380 = consume_terminal!(parser, "INT") - int_4381 = consume_terminal!(parser, "INT") + int391 = consume_terminal!(parser, "INT") + int_3392 = consume_terminal!(parser, "INT") + int_4393 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t759 = Proto.DateValue(year=Int32(int379), month=Int32(int_3380), day=Int32(int_4381)) - return _t759 + _t783 = Proto.DateValue(year=Int32(int391), month=Int32(int_3392), day=Int32(int_4393)) + return _t783 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int382 = consume_terminal!(parser, "INT") - int_3383 = consume_terminal!(parser, "INT") - int_4384 = consume_terminal!(parser, "INT") - int_5385 = consume_terminal!(parser, "INT") - int_6386 = consume_terminal!(parser, "INT") - int_7387 = consume_terminal!(parser, "INT") + int394 = consume_terminal!(parser, "INT") + int_3395 = consume_terminal!(parser, "INT") + int_4396 = consume_terminal!(parser, "INT") + int_5397 = consume_terminal!(parser, "INT") + int_6398 = consume_terminal!(parser, "INT") + int_7399 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t760 = consume_terminal!(parser, "INT") + _t784 = consume_terminal!(parser, "INT") else - _t760 = nothing + _t784 = nothing end - int_8388 = _t760 + int_8400 = _t784 consume_literal!(parser, ")") - _t761 = Proto.DateTimeValue(year=Int32(int382), month=Int32(int_3383), day=Int32(int_4384), hour=Int32(int_5385), minute=Int32(int_6386), second=Int32(int_7387), microsecond=Int32((!isnothing(int_8388) ? int_8388 : 0))) - return _t761 + _t785 = Proto.DateTimeValue(year=Int32(int394), month=Int32(int_3395), day=Int32(int_4396), hour=Int32(int_5397), minute=Int32(int_6398), second=Int32(int_7399), microsecond=Int32((!isnothing(int_8400) ? int_8400 : 0))) + return _t785 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t762 = 0 + _t786 = 0 else if match_lookahead_literal(parser, "false", 0) - _t763 = 1 + _t787 = 1 else - _t763 = -1 + _t787 = -1 end - _t762 = _t763 + _t786 = _t787 end - prediction389 = _t762 - if prediction389 == 1 + prediction401 = _t786 + if prediction401 == 1 consume_literal!(parser, "false") - _t764 = false + _t788 = false else - if prediction389 == 0 + if prediction401 == 0 consume_literal!(parser, "true") - _t765 = true + _t789 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t764 = _t765 + _t788 = _t789 end - return _t764 + return _t788 end function parse_sync(parser::ParserState)::Proto.Sync consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs390 = Proto.FragmentId[] - cond391 = match_lookahead_literal(parser, ":", 0) - while cond391 - _t766 = parse_fragment_id(parser) - item392 = _t766 - push!(xs390, item392) - cond391 = match_lookahead_literal(parser, ":", 0) + xs402 = Proto.FragmentId[] + cond403 = match_lookahead_literal(parser, ":", 0) + while cond403 + _t790 = parse_fragment_id(parser) + item404 = _t790 + push!(xs402, item404) + cond403 = match_lookahead_literal(parser, ":", 0) end - fragment_ids393 = xs390 + fragment_ids405 = xs402 consume_literal!(parser, ")") - _t767 = Proto.Sync(fragments=fragment_ids393) - return _t767 + _t791 = Proto.Sync(fragments=fragment_ids405) + return _t791 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId consume_literal!(parser, ":") - symbol394 = consume_terminal!(parser, "SYMBOL") - return Proto.FragmentId(Vector{UInt8}(symbol394)) + symbol406 = consume_terminal!(parser, "SYMBOL") + return Proto.FragmentId(Vector{UInt8}(symbol406)) end function parse_epoch(parser::ParserState)::Proto.Epoch consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t769 = parse_epoch_writes(parser) - _t768 = _t769 + _t793 = parse_epoch_writes(parser) + _t792 = _t793 else - _t768 = nothing + _t792 = nothing end - epoch_writes395 = _t768 + epoch_writes407 = _t792 if match_lookahead_literal(parser, "(", 0) - _t771 = parse_epoch_reads(parser) - _t770 = _t771 + _t795 = parse_epoch_reads(parser) + _t794 = _t795 else - _t770 = nothing + _t794 = nothing end - epoch_reads396 = _t770 + epoch_reads408 = _t794 consume_literal!(parser, ")") - _t772 = Proto.Epoch(writes=(!isnothing(epoch_writes395) ? epoch_writes395 : Proto.Write[]), reads=(!isnothing(epoch_reads396) ? epoch_reads396 : Proto.Read[])) - return _t772 + _t796 = Proto.Epoch(writes=(!isnothing(epoch_writes407) ? epoch_writes407 : Proto.Write[]), reads=(!isnothing(epoch_reads408) ? epoch_reads408 : Proto.Read[])) + return _t796 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs397 = Proto.Write[] - cond398 = match_lookahead_literal(parser, "(", 0) - while cond398 - _t773 = parse_write(parser) - item399 = _t773 - push!(xs397, item399) - cond398 = match_lookahead_literal(parser, "(", 0) + xs409 = Proto.Write[] + cond410 = match_lookahead_literal(parser, "(", 0) + while cond410 + _t797 = parse_write(parser) + item411 = _t797 + push!(xs409, item411) + cond410 = match_lookahead_literal(parser, "(", 0) end - writes400 = xs397 + writes412 = xs409 consume_literal!(parser, ")") - return writes400 + return writes412 end function parse_write(parser::ParserState)::Proto.Write if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t775 = 1 + _t799 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t776 = 3 + _t800 = 3 else if match_lookahead_literal(parser, "define", 1) - _t777 = 0 + _t801 = 0 else if match_lookahead_literal(parser, "context", 1) - _t778 = 2 + _t802 = 2 else - _t778 = -1 + _t802 = -1 end - _t777 = _t778 + _t801 = _t802 end - _t776 = _t777 + _t800 = _t801 end - _t775 = _t776 + _t799 = _t800 end - _t774 = _t775 + _t798 = _t799 else - _t774 = -1 - end - prediction401 = _t774 - if prediction401 == 3 - _t780 = parse_snapshot(parser) - snapshot405 = _t780 - _t781 = Proto.Write(write_type=OneOf(:snapshot, snapshot405)) - _t779 = _t781 + _t798 = -1 + end + prediction413 = _t798 + if prediction413 == 3 + _t804 = parse_snapshot(parser) + snapshot417 = _t804 + _t805 = Proto.Write(write_type=OneOf(:snapshot, snapshot417)) + _t803 = _t805 else - if prediction401 == 2 - _t783 = parse_context(parser) - context404 = _t783 - _t784 = Proto.Write(write_type=OneOf(:context, context404)) - _t782 = _t784 + if prediction413 == 2 + _t807 = parse_context(parser) + context416 = _t807 + _t808 = Proto.Write(write_type=OneOf(:context, context416)) + _t806 = _t808 else - if prediction401 == 1 - _t786 = parse_undefine(parser) - undefine403 = _t786 - _t787 = Proto.Write(write_type=OneOf(:undefine, undefine403)) - _t785 = _t787 + if prediction413 == 1 + _t810 = parse_undefine(parser) + undefine415 = _t810 + _t811 = Proto.Write(write_type=OneOf(:undefine, undefine415)) + _t809 = _t811 else - if prediction401 == 0 - _t789 = parse_define(parser) - define402 = _t789 - _t790 = Proto.Write(write_type=OneOf(:define, define402)) - _t788 = _t790 + if prediction413 == 0 + _t813 = parse_define(parser) + define414 = _t813 + _t814 = Proto.Write(write_type=OneOf(:define, define414)) + _t812 = _t814 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t785 = _t788 + _t809 = _t812 end - _t782 = _t785 + _t806 = _t809 end - _t779 = _t782 + _t803 = _t806 end - return _t779 + return _t803 end function parse_define(parser::ParserState)::Proto.Define consume_literal!(parser, "(") consume_literal!(parser, "define") - _t791 = parse_fragment(parser) - fragment406 = _t791 + _t815 = parse_fragment(parser) + fragment418 = _t815 consume_literal!(parser, ")") - _t792 = Proto.Define(fragment=fragment406) - return _t792 + _t816 = Proto.Define(fragment=fragment418) + return _t816 end function parse_fragment(parser::ParserState)::Proto.Fragment consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t793 = parse_new_fragment_id(parser) - new_fragment_id407 = _t793 - xs408 = Proto.Declaration[] - cond409 = match_lookahead_literal(parser, "(", 0) - while cond409 - _t794 = parse_declaration(parser) - item410 = _t794 - push!(xs408, item410) - cond409 = match_lookahead_literal(parser, "(", 0) + _t817 = parse_new_fragment_id(parser) + new_fragment_id419 = _t817 + xs420 = Proto.Declaration[] + cond421 = match_lookahead_literal(parser, "(", 0) + while cond421 + _t818 = parse_declaration(parser) + item422 = _t818 + push!(xs420, item422) + cond421 = match_lookahead_literal(parser, "(", 0) end - declarations411 = xs408 + declarations423 = xs420 consume_literal!(parser, ")") - return construct_fragment(parser, new_fragment_id407, declarations411) + return construct_fragment(parser, new_fragment_id419, declarations423) end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - _t795 = parse_fragment_id(parser) - fragment_id412 = _t795 - start_fragment!(parser, fragment_id412) - return fragment_id412 + _t819 = parse_fragment_id(parser) + fragment_id424 = _t819 + start_fragment!(parser, fragment_id424) + return fragment_id424 end function parse_declaration(parser::ParserState)::Proto.Declaration if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "rel_edb", 1) - _t797 = 3 + _t821 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t798 = 2 + _t822 = 2 else if match_lookahead_literal(parser, "def", 1) - _t799 = 0 + _t823 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t800 = 3 + _t824 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t801 = 3 + _t825 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t802 = 1 + _t826 = 1 else - _t802 = -1 + _t826 = -1 end - _t801 = _t802 + _t825 = _t826 end - _t800 = _t801 + _t824 = _t825 end - _t799 = _t800 + _t823 = _t824 end - _t798 = _t799 + _t822 = _t823 end - _t797 = _t798 + _t821 = _t822 end - _t796 = _t797 + _t820 = _t821 else - _t796 = -1 - end - prediction413 = _t796 - if prediction413 == 3 - _t804 = parse_data(parser) - data417 = _t804 - _t805 = Proto.Declaration(declaration_type=OneOf(:data, data417)) - _t803 = _t805 + _t820 = -1 + end + prediction425 = _t820 + if prediction425 == 3 + _t828 = parse_data(parser) + data429 = _t828 + _t829 = Proto.Declaration(declaration_type=OneOf(:data, data429)) + _t827 = _t829 else - if prediction413 == 2 - _t807 = parse_constraint(parser) - constraint416 = _t807 - _t808 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint416)) - _t806 = _t808 + if prediction425 == 2 + _t831 = parse_constraint(parser) + constraint428 = _t831 + _t832 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint428)) + _t830 = _t832 else - if prediction413 == 1 - _t810 = parse_algorithm(parser) - algorithm415 = _t810 - _t811 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm415)) - _t809 = _t811 + if prediction425 == 1 + _t834 = parse_algorithm(parser) + algorithm427 = _t834 + _t835 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm427)) + _t833 = _t835 else - if prediction413 == 0 - _t813 = parse_def(parser) - def414 = _t813 - _t814 = Proto.Declaration(declaration_type=OneOf(:def, def414)) - _t812 = _t814 + if prediction425 == 0 + _t837 = parse_def(parser) + def426 = _t837 + _t838 = Proto.Declaration(declaration_type=OneOf(:def, def426)) + _t836 = _t838 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t809 = _t812 + _t833 = _t836 end - _t806 = _t809 + _t830 = _t833 end - _t803 = _t806 + _t827 = _t830 end - return _t803 + return _t827 end function parse_def(parser::ParserState)::Proto.Def consume_literal!(parser, "(") consume_literal!(parser, "def") - _t815 = parse_relation_id(parser) - relation_id418 = _t815 - _t816 = parse_abstraction(parser) - abstraction419 = _t816 + _t839 = parse_relation_id(parser) + relation_id430 = _t839 + _t840 = parse_abstraction(parser) + abstraction431 = _t840 if match_lookahead_literal(parser, "(", 0) - _t818 = parse_attrs(parser) - _t817 = _t818 + _t842 = parse_attrs(parser) + _t841 = _t842 else - _t817 = nothing + _t841 = nothing end - attrs420 = _t817 + attrs432 = _t841 consume_literal!(parser, ")") - _t819 = Proto.Def(name=relation_id418, body=abstraction419, attrs=(!isnothing(attrs420) ? attrs420 : Proto.Attribute[])) - return _t819 + _t843 = Proto.Def(name=relation_id430, body=abstraction431, attrs=(!isnothing(attrs432) ? attrs432 : Proto.Attribute[])) + return _t843 end function parse_relation_id(parser::ParserState)::Proto.RelationId if match_lookahead_literal(parser, ":", 0) - _t820 = 0 + _t844 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t821 = 1 + _t845 = 1 else - _t821 = -1 + _t845 = -1 end - _t820 = _t821 + _t844 = _t845 end - prediction421 = _t820 - if prediction421 == 1 - uint128423 = consume_terminal!(parser, "UINT128") - _t822 = Proto.RelationId(uint128423.low, uint128423.high) + prediction433 = _t844 + if prediction433 == 1 + uint128435 = consume_terminal!(parser, "UINT128") + _t846 = Proto.RelationId(uint128435.low, uint128435.high) else - if prediction421 == 0 + if prediction433 == 0 consume_literal!(parser, ":") - symbol422 = consume_terminal!(parser, "SYMBOL") - _t823 = relation_id_from_string(parser, symbol422) + symbol434 = consume_terminal!(parser, "SYMBOL") + _t847 = relation_id_from_string(parser, symbol434) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t822 = _t823 + _t846 = _t847 end - return _t822 + return _t846 end function parse_abstraction(parser::ParserState)::Proto.Abstraction consume_literal!(parser, "(") - _t824 = parse_bindings(parser) - bindings424 = _t824 - _t825 = parse_formula(parser) - formula425 = _t825 + _t848 = parse_bindings(parser) + bindings436 = _t848 + _t849 = parse_formula(parser) + formula437 = _t849 consume_literal!(parser, ")") - _t826 = Proto.Abstraction(vars=vcat(bindings424[1], !isnothing(bindings424[2]) ? bindings424[2] : []), value=formula425) - return _t826 + _t850 = Proto.Abstraction(vars=vcat(bindings436[1], !isnothing(bindings436[2]) ? bindings436[2] : []), value=formula437) + return _t850 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs426 = Proto.Binding[] - cond427 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond427 - _t827 = parse_binding(parser) - item428 = _t827 - push!(xs426, item428) - cond427 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings429 = xs426 + xs438 = Proto.Binding[] + cond439 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond439 + _t851 = parse_binding(parser) + item440 = _t851 + push!(xs438, item440) + cond439 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings441 = xs438 if match_lookahead_literal(parser, "|", 0) - _t829 = parse_value_bindings(parser) - _t828 = _t829 + _t853 = parse_value_bindings(parser) + _t852 = _t853 else - _t828 = nothing + _t852 = nothing end - value_bindings430 = _t828 + value_bindings442 = _t852 consume_literal!(parser, "]") - return (bindings429, (!isnothing(value_bindings430) ? value_bindings430 : Proto.Binding[]),) + return (bindings441, (!isnothing(value_bindings442) ? value_bindings442 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - symbol431 = consume_terminal!(parser, "SYMBOL") + symbol443 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t830 = parse_type(parser) - type432 = _t830 - _t831 = Proto.Var(name=symbol431) - _t832 = Proto.Binding(var=_t831, var"#type"=type432) - return _t832 + _t854 = parse_type(parser) + type444 = _t854 + _t855 = Proto.Var(name=symbol443) + _t856 = Proto.Binding(var=_t855, var"#type"=type444) + return _t856 end function parse_type(parser::ParserState)::Proto.var"#Type" if match_lookahead_literal(parser, "UNKNOWN", 0) - _t833 = 0 + _t857 = 0 else if match_lookahead_literal(parser, "UINT128", 0) - _t834 = 4 + _t858 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t835 = 1 + _t859 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t836 = 8 + _t860 = 8 else if match_lookahead_literal(parser, "INT128", 0) - _t837 = 5 + _t861 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t838 = 2 + _t862 = 2 else if match_lookahead_literal(parser, "FLOAT", 0) - _t839 = 3 + _t863 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t840 = 7 + _t864 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t841 = 6 + _t865 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t842 = 10 + _t866 = 10 else if match_lookahead_literal(parser, "(", 0) - _t843 = 9 + _t867 = 9 else - _t843 = -1 + _t867 = -1 end - _t842 = _t843 + _t866 = _t867 end - _t841 = _t842 + _t865 = _t866 end - _t840 = _t841 + _t864 = _t865 end - _t839 = _t840 + _t863 = _t864 end - _t838 = _t839 + _t862 = _t863 end - _t837 = _t838 + _t861 = _t862 end - _t836 = _t837 + _t860 = _t861 end - _t835 = _t836 + _t859 = _t860 end - _t834 = _t835 + _t858 = _t859 end - _t833 = _t834 - end - prediction433 = _t833 - if prediction433 == 10 - _t845 = parse_boolean_type(parser) - boolean_type444 = _t845 - _t846 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type444)) - _t844 = _t846 + _t857 = _t858 + end + prediction445 = _t857 + if prediction445 == 10 + _t869 = parse_boolean_type(parser) + boolean_type456 = _t869 + _t870 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type456)) + _t868 = _t870 else - if prediction433 == 9 - _t848 = parse_decimal_type(parser) - decimal_type443 = _t848 - _t849 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type443)) - _t847 = _t849 + if prediction445 == 9 + _t872 = parse_decimal_type(parser) + decimal_type455 = _t872 + _t873 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type455)) + _t871 = _t873 else - if prediction433 == 8 - _t851 = parse_missing_type(parser) - missing_type442 = _t851 - _t852 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type442)) - _t850 = _t852 + if prediction445 == 8 + _t875 = parse_missing_type(parser) + missing_type454 = _t875 + _t876 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type454)) + _t874 = _t876 else - if prediction433 == 7 - _t854 = parse_datetime_type(parser) - datetime_type441 = _t854 - _t855 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type441)) - _t853 = _t855 + if prediction445 == 7 + _t878 = parse_datetime_type(parser) + datetime_type453 = _t878 + _t879 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type453)) + _t877 = _t879 else - if prediction433 == 6 - _t857 = parse_date_type(parser) - date_type440 = _t857 - _t858 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type440)) - _t856 = _t858 + if prediction445 == 6 + _t881 = parse_date_type(parser) + date_type452 = _t881 + _t882 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type452)) + _t880 = _t882 else - if prediction433 == 5 - _t860 = parse_int128_type(parser) - int128_type439 = _t860 - _t861 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type439)) - _t859 = _t861 + if prediction445 == 5 + _t884 = parse_int128_type(parser) + int128_type451 = _t884 + _t885 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type451)) + _t883 = _t885 else - if prediction433 == 4 - _t863 = parse_uint128_type(parser) - uint128_type438 = _t863 - _t864 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type438)) - _t862 = _t864 + if prediction445 == 4 + _t887 = parse_uint128_type(parser) + uint128_type450 = _t887 + _t888 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type450)) + _t886 = _t888 else - if prediction433 == 3 - _t866 = parse_float_type(parser) - float_type437 = _t866 - _t867 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type437)) - _t865 = _t867 + if prediction445 == 3 + _t890 = parse_float_type(parser) + float_type449 = _t890 + _t891 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type449)) + _t889 = _t891 else - if prediction433 == 2 - _t869 = parse_int_type(parser) - int_type436 = _t869 - _t870 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type436)) - _t868 = _t870 + if prediction445 == 2 + _t893 = parse_int_type(parser) + int_type448 = _t893 + _t894 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type448)) + _t892 = _t894 else - if prediction433 == 1 - _t872 = parse_string_type(parser) - string_type435 = _t872 - _t873 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type435)) - _t871 = _t873 + if prediction445 == 1 + _t896 = parse_string_type(parser) + string_type447 = _t896 + _t897 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type447)) + _t895 = _t897 else - if prediction433 == 0 - _t875 = parse_unspecified_type(parser) - unspecified_type434 = _t875 - _t876 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type434)) - _t874 = _t876 + if prediction445 == 0 + _t899 = parse_unspecified_type(parser) + unspecified_type446 = _t899 + _t900 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type446)) + _t898 = _t900 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t871 = _t874 + _t895 = _t898 end - _t868 = _t871 + _t892 = _t895 end - _t865 = _t868 + _t889 = _t892 end - _t862 = _t865 + _t886 = _t889 end - _t859 = _t862 + _t883 = _t886 end - _t856 = _t859 + _t880 = _t883 end - _t853 = _t856 + _t877 = _t880 end - _t850 = _t853 + _t874 = _t877 end - _t847 = _t850 + _t871 = _t874 end - _t844 = _t847 + _t868 = _t871 end - return _t844 + return _t868 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType consume_literal!(parser, "UNKNOWN") - _t877 = Proto.UnspecifiedType() - return _t877 + _t901 = Proto.UnspecifiedType() + return _t901 end function parse_string_type(parser::ParserState)::Proto.StringType consume_literal!(parser, "STRING") - _t878 = Proto.StringType() - return _t878 + _t902 = Proto.StringType() + return _t902 end function parse_int_type(parser::ParserState)::Proto.IntType consume_literal!(parser, "INT") - _t879 = Proto.IntType() - return _t879 + _t903 = Proto.IntType() + return _t903 end function parse_float_type(parser::ParserState)::Proto.FloatType consume_literal!(parser, "FLOAT") - _t880 = Proto.FloatType() - return _t880 + _t904 = Proto.FloatType() + return _t904 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type consume_literal!(parser, "UINT128") - _t881 = Proto.UInt128Type() - return _t881 + _t905 = Proto.UInt128Type() + return _t905 end function parse_int128_type(parser::ParserState)::Proto.Int128Type consume_literal!(parser, "INT128") - _t882 = Proto.Int128Type() - return _t882 + _t906 = Proto.Int128Type() + return _t906 end function parse_date_type(parser::ParserState)::Proto.DateType consume_literal!(parser, "DATE") - _t883 = Proto.DateType() - return _t883 + _t907 = Proto.DateType() + return _t907 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType consume_literal!(parser, "DATETIME") - _t884 = Proto.DateTimeType() - return _t884 + _t908 = Proto.DateTimeType() + return _t908 end function parse_missing_type(parser::ParserState)::Proto.MissingType consume_literal!(parser, "MISSING") - _t885 = Proto.MissingType() - return _t885 + _t909 = Proto.MissingType() + return _t909 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int445 = consume_terminal!(parser, "INT") - int_3446 = consume_terminal!(parser, "INT") + int457 = consume_terminal!(parser, "INT") + int_3458 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t886 = Proto.DecimalType(precision=Int32(int445), scale=Int32(int_3446)) - return _t886 + _t910 = Proto.DecimalType(precision=Int32(int457), scale=Int32(int_3458)) + return _t910 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType consume_literal!(parser, "BOOLEAN") - _t887 = Proto.BooleanType() - return _t887 + _t911 = Proto.BooleanType() + return _t911 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs447 = Proto.Binding[] - cond448 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond448 - _t888 = parse_binding(parser) - item449 = _t888 - push!(xs447, item449) - cond448 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs459 = Proto.Binding[] + cond460 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond460 + _t912 = parse_binding(parser) + item461 = _t912 + push!(xs459, item461) + cond460 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings450 = xs447 - return bindings450 + bindings462 = xs459 + return bindings462 end function parse_formula(parser::ParserState)::Proto.Formula if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t890 = 0 + _t914 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t891 = 11 + _t915 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t892 = 3 + _t916 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t893 = 10 + _t917 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t894 = 9 + _t918 = 9 else if match_lookahead_literal(parser, "or", 1) - _t895 = 5 + _t919 = 5 else if match_lookahead_literal(parser, "not", 1) - _t896 = 6 + _t920 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t897 = 7 + _t921 = 7 else if match_lookahead_literal(parser, "false", 1) - _t898 = 1 + _t922 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t899 = 2 + _t923 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t900 = 12 + _t924 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t901 = 8 + _t925 = 8 else if match_lookahead_literal(parser, "and", 1) - _t902 = 4 + _t926 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t903 = 10 + _t927 = 10 else if match_lookahead_literal(parser, ">", 1) - _t904 = 10 + _t928 = 10 else if match_lookahead_literal(parser, "=", 1) - _t905 = 10 + _t929 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t906 = 10 + _t930 = 10 else if match_lookahead_literal(parser, "<", 1) - _t907 = 10 + _t931 = 10 else if match_lookahead_literal(parser, "/", 1) - _t908 = 10 + _t932 = 10 else if match_lookahead_literal(parser, "-", 1) - _t909 = 10 + _t933 = 10 else if match_lookahead_literal(parser, "+", 1) - _t910 = 10 + _t934 = 10 else if match_lookahead_literal(parser, "*", 1) - _t911 = 10 + _t935 = 10 else - _t911 = -1 + _t935 = -1 end - _t910 = _t911 + _t934 = _t935 end - _t909 = _t910 + _t933 = _t934 end - _t908 = _t909 + _t932 = _t933 end - _t907 = _t908 + _t931 = _t932 end - _t906 = _t907 + _t930 = _t931 end - _t905 = _t906 + _t929 = _t930 end - _t904 = _t905 + _t928 = _t929 end - _t903 = _t904 + _t927 = _t928 end - _t902 = _t903 + _t926 = _t927 end - _t901 = _t902 + _t925 = _t926 end - _t900 = _t901 + _t924 = _t925 end - _t899 = _t900 + _t923 = _t924 end - _t898 = _t899 + _t922 = _t923 end - _t897 = _t898 + _t921 = _t922 end - _t896 = _t897 + _t920 = _t921 end - _t895 = _t896 + _t919 = _t920 end - _t894 = _t895 + _t918 = _t919 end - _t893 = _t894 + _t917 = _t918 end - _t892 = _t893 + _t916 = _t917 end - _t891 = _t892 + _t915 = _t916 end - _t890 = _t891 + _t914 = _t915 end - _t889 = _t890 + _t913 = _t914 else - _t889 = -1 - end - prediction451 = _t889 - if prediction451 == 12 - _t913 = parse_cast(parser) - cast464 = _t913 - _t914 = Proto.Formula(formula_type=OneOf(:cast, cast464)) - _t912 = _t914 + _t913 = -1 + end + prediction463 = _t913 + if prediction463 == 12 + _t937 = parse_cast(parser) + cast476 = _t937 + _t938 = Proto.Formula(formula_type=OneOf(:cast, cast476)) + _t936 = _t938 else - if prediction451 == 11 - _t916 = parse_rel_atom(parser) - rel_atom463 = _t916 - _t917 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom463)) - _t915 = _t917 + if prediction463 == 11 + _t940 = parse_rel_atom(parser) + rel_atom475 = _t940 + _t941 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom475)) + _t939 = _t941 else - if prediction451 == 10 - _t919 = parse_primitive(parser) - primitive462 = _t919 - _t920 = Proto.Formula(formula_type=OneOf(:primitive, primitive462)) - _t918 = _t920 + if prediction463 == 10 + _t943 = parse_primitive(parser) + primitive474 = _t943 + _t944 = Proto.Formula(formula_type=OneOf(:primitive, primitive474)) + _t942 = _t944 else - if prediction451 == 9 - _t922 = parse_pragma(parser) - pragma461 = _t922 - _t923 = Proto.Formula(formula_type=OneOf(:pragma, pragma461)) - _t921 = _t923 + if prediction463 == 9 + _t946 = parse_pragma(parser) + pragma473 = _t946 + _t947 = Proto.Formula(formula_type=OneOf(:pragma, pragma473)) + _t945 = _t947 else - if prediction451 == 8 - _t925 = parse_atom(parser) - atom460 = _t925 - _t926 = Proto.Formula(formula_type=OneOf(:atom, atom460)) - _t924 = _t926 + if prediction463 == 8 + _t949 = parse_atom(parser) + atom472 = _t949 + _t950 = Proto.Formula(formula_type=OneOf(:atom, atom472)) + _t948 = _t950 else - if prediction451 == 7 - _t928 = parse_ffi(parser) - ffi459 = _t928 - _t929 = Proto.Formula(formula_type=OneOf(:ffi, ffi459)) - _t927 = _t929 + if prediction463 == 7 + _t952 = parse_ffi(parser) + ffi471 = _t952 + _t953 = Proto.Formula(formula_type=OneOf(:ffi, ffi471)) + _t951 = _t953 else - if prediction451 == 6 - _t931 = parse_not(parser) - not458 = _t931 - _t932 = Proto.Formula(formula_type=OneOf(:not, not458)) - _t930 = _t932 + if prediction463 == 6 + _t955 = parse_not(parser) + not470 = _t955 + _t956 = Proto.Formula(formula_type=OneOf(:not, not470)) + _t954 = _t956 else - if prediction451 == 5 - _t934 = parse_disjunction(parser) - disjunction457 = _t934 - _t935 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction457)) - _t933 = _t935 + if prediction463 == 5 + _t958 = parse_disjunction(parser) + disjunction469 = _t958 + _t959 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction469)) + _t957 = _t959 else - if prediction451 == 4 - _t937 = parse_conjunction(parser) - conjunction456 = _t937 - _t938 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction456)) - _t936 = _t938 + if prediction463 == 4 + _t961 = parse_conjunction(parser) + conjunction468 = _t961 + _t962 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction468)) + _t960 = _t962 else - if prediction451 == 3 - _t940 = parse_reduce(parser) - reduce455 = _t940 - _t941 = Proto.Formula(formula_type=OneOf(:reduce, reduce455)) - _t939 = _t941 + if prediction463 == 3 + _t964 = parse_reduce(parser) + reduce467 = _t964 + _t965 = Proto.Formula(formula_type=OneOf(:reduce, reduce467)) + _t963 = _t965 else - if prediction451 == 2 - _t943 = parse_exists(parser) - exists454 = _t943 - _t944 = Proto.Formula(formula_type=OneOf(:exists, exists454)) - _t942 = _t944 + if prediction463 == 2 + _t967 = parse_exists(parser) + exists466 = _t967 + _t968 = Proto.Formula(formula_type=OneOf(:exists, exists466)) + _t966 = _t968 else - if prediction451 == 1 - _t946 = parse_false(parser) - false453 = _t946 - _t947 = Proto.Formula(formula_type=OneOf(:disjunction, false453)) - _t945 = _t947 + if prediction463 == 1 + _t970 = parse_false(parser) + false465 = _t970 + _t971 = Proto.Formula(formula_type=OneOf(:disjunction, false465)) + _t969 = _t971 else - if prediction451 == 0 - _t949 = parse_true(parser) - true452 = _t949 - _t950 = Proto.Formula(formula_type=OneOf(:conjunction, true452)) - _t948 = _t950 + if prediction463 == 0 + _t973 = parse_true(parser) + true464 = _t973 + _t974 = Proto.Formula(formula_type=OneOf(:conjunction, true464)) + _t972 = _t974 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t945 = _t948 + _t969 = _t972 end - _t942 = _t945 + _t966 = _t969 end - _t939 = _t942 + _t963 = _t966 end - _t936 = _t939 + _t960 = _t963 end - _t933 = _t936 + _t957 = _t960 end - _t930 = _t933 + _t954 = _t957 end - _t927 = _t930 + _t951 = _t954 end - _t924 = _t927 + _t948 = _t951 end - _t921 = _t924 + _t945 = _t948 end - _t918 = _t921 + _t942 = _t945 end - _t915 = _t918 + _t939 = _t942 end - _t912 = _t915 + _t936 = _t939 end - return _t912 + return _t936 end function parse_true(parser::ParserState)::Proto.Conjunction consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t951 = Proto.Conjunction(args=Proto.Formula[]) - return _t951 + _t975 = Proto.Conjunction(args=Proto.Formula[]) + return _t975 end function parse_false(parser::ParserState)::Proto.Disjunction consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t952 = Proto.Disjunction(args=Proto.Formula[]) - return _t952 + _t976 = Proto.Disjunction(args=Proto.Formula[]) + return _t976 end function parse_exists(parser::ParserState)::Proto.Exists consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t953 = parse_bindings(parser) - bindings465 = _t953 - _t954 = parse_formula(parser) - formula466 = _t954 + _t977 = parse_bindings(parser) + bindings477 = _t977 + _t978 = parse_formula(parser) + formula478 = _t978 consume_literal!(parser, ")") - _t955 = Proto.Abstraction(vars=vcat(bindings465[1], !isnothing(bindings465[2]) ? bindings465[2] : []), value=formula466) - _t956 = Proto.Exists(body=_t955) - return _t956 + _t979 = Proto.Abstraction(vars=vcat(bindings477[1], !isnothing(bindings477[2]) ? bindings477[2] : []), value=formula478) + _t980 = Proto.Exists(body=_t979) + return _t980 end function parse_reduce(parser::ParserState)::Proto.Reduce consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t957 = parse_abstraction(parser) - abstraction467 = _t957 - _t958 = parse_abstraction(parser) - abstraction_3468 = _t958 - _t959 = parse_terms(parser) - terms469 = _t959 - consume_literal!(parser, ")") - _t960 = Proto.Reduce(op=abstraction467, body=abstraction_3468, terms=terms469) - return _t960 + _t981 = parse_abstraction(parser) + abstraction479 = _t981 + _t982 = parse_abstraction(parser) + abstraction_3480 = _t982 + _t983 = parse_terms(parser) + terms481 = _t983 + consume_literal!(parser, ")") + _t984 = Proto.Reduce(op=abstraction479, body=abstraction_3480, terms=terms481) + return _t984 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs470 = Proto.Term[] - cond471 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond471 - _t961 = parse_term(parser) - item472 = _t961 - push!(xs470, item472) - cond471 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + xs482 = Proto.Term[] + cond483 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond483 + _t985 = parse_term(parser) + item484 = _t985 + push!(xs482, item484) + cond483 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - terms473 = xs470 + terms485 = xs482 consume_literal!(parser, ")") - return terms473 + return terms485 end function parse_term(parser::ParserState)::Proto.Term if match_lookahead_literal(parser, "true", 0) - _t962 = 1 + _t986 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t963 = 1 + _t987 = 1 else if match_lookahead_literal(parser, "false", 0) - _t964 = 1 + _t988 = 1 else if match_lookahead_literal(parser, "(", 0) - _t965 = 1 + _t989 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t966 = 1 + _t990 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t967 = 0 + _t991 = 0 else if match_lookahead_terminal(parser, "STRING", 0) - _t968 = 1 + _t992 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t969 = 1 + _t993 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t970 = 1 + _t994 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t971 = 1 + _t995 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t972 = 1 + _t996 = 1 else - _t972 = -1 + _t996 = -1 end - _t971 = _t972 + _t995 = _t996 end - _t970 = _t971 + _t994 = _t995 end - _t969 = _t970 + _t993 = _t994 end - _t968 = _t969 + _t992 = _t993 end - _t967 = _t968 + _t991 = _t992 end - _t966 = _t967 + _t990 = _t991 end - _t965 = _t966 + _t989 = _t990 end - _t964 = _t965 + _t988 = _t989 end - _t963 = _t964 + _t987 = _t988 end - _t962 = _t963 - end - prediction474 = _t962 - if prediction474 == 1 - _t974 = parse_constant(parser) - constant476 = _t974 - _t975 = Proto.Term(term_type=OneOf(:constant, constant476)) - _t973 = _t975 + _t986 = _t987 + end + prediction486 = _t986 + if prediction486 == 1 + _t998 = parse_constant(parser) + constant488 = _t998 + _t999 = Proto.Term(term_type=OneOf(:constant, constant488)) + _t997 = _t999 else - if prediction474 == 0 - _t977 = parse_var(parser) - var475 = _t977 - _t978 = Proto.Term(term_type=OneOf(:var, var475)) - _t976 = _t978 + if prediction486 == 0 + _t1001 = parse_var(parser) + var487 = _t1001 + _t1002 = Proto.Term(term_type=OneOf(:var, var487)) + _t1000 = _t1002 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t973 = _t976 + _t997 = _t1000 end - return _t973 + return _t997 end function parse_var(parser::ParserState)::Proto.Var - symbol477 = consume_terminal!(parser, "SYMBOL") - _t979 = Proto.Var(name=symbol477) - return _t979 + symbol489 = consume_terminal!(parser, "SYMBOL") + _t1003 = Proto.Var(name=symbol489) + return _t1003 end function parse_constant(parser::ParserState)::Proto.Value - _t980 = parse_value(parser) - value478 = _t980 - return value478 + _t1004 = parse_value(parser) + value490 = _t1004 + return value490 end function parse_conjunction(parser::ParserState)::Proto.Conjunction consume_literal!(parser, "(") consume_literal!(parser, "and") - xs479 = Proto.Formula[] - cond480 = match_lookahead_literal(parser, "(", 0) - while cond480 - _t981 = parse_formula(parser) - item481 = _t981 - push!(xs479, item481) - cond480 = match_lookahead_literal(parser, "(", 0) + xs491 = Proto.Formula[] + cond492 = match_lookahead_literal(parser, "(", 0) + while cond492 + _t1005 = parse_formula(parser) + item493 = _t1005 + push!(xs491, item493) + cond492 = match_lookahead_literal(parser, "(", 0) end - formulas482 = xs479 + formulas494 = xs491 consume_literal!(parser, ")") - _t982 = Proto.Conjunction(args=formulas482) - return _t982 + _t1006 = Proto.Conjunction(args=formulas494) + return _t1006 end function parse_disjunction(parser::ParserState)::Proto.Disjunction consume_literal!(parser, "(") consume_literal!(parser, "or") - xs483 = Proto.Formula[] - cond484 = match_lookahead_literal(parser, "(", 0) - while cond484 - _t983 = parse_formula(parser) - item485 = _t983 - push!(xs483, item485) - cond484 = match_lookahead_literal(parser, "(", 0) + xs495 = Proto.Formula[] + cond496 = match_lookahead_literal(parser, "(", 0) + while cond496 + _t1007 = parse_formula(parser) + item497 = _t1007 + push!(xs495, item497) + cond496 = match_lookahead_literal(parser, "(", 0) end - formulas486 = xs483 + formulas498 = xs495 consume_literal!(parser, ")") - _t984 = Proto.Disjunction(args=formulas486) - return _t984 + _t1008 = Proto.Disjunction(args=formulas498) + return _t1008 end function parse_not(parser::ParserState)::Proto.Not consume_literal!(parser, "(") consume_literal!(parser, "not") - _t985 = parse_formula(parser) - formula487 = _t985 + _t1009 = parse_formula(parser) + formula499 = _t1009 consume_literal!(parser, ")") - _t986 = Proto.Not(arg=formula487) - return _t986 + _t1010 = Proto.Not(arg=formula499) + return _t1010 end function parse_ffi(parser::ParserState)::Proto.FFI consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t987 = parse_name(parser) - name488 = _t987 - _t988 = parse_ffi_args(parser) - ffi_args489 = _t988 - _t989 = parse_terms(parser) - terms490 = _t989 + _t1011 = parse_name(parser) + name500 = _t1011 + _t1012 = parse_ffi_args(parser) + ffi_args501 = _t1012 + _t1013 = parse_terms(parser) + terms502 = _t1013 consume_literal!(parser, ")") - _t990 = Proto.FFI(name=name488, args=ffi_args489, terms=terms490) - return _t990 + _t1014 = Proto.FFI(name=name500, args=ffi_args501, terms=terms502) + return _t1014 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol491 = consume_terminal!(parser, "SYMBOL") - return symbol491 + symbol503 = consume_terminal!(parser, "SYMBOL") + return symbol503 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs492 = Proto.Abstraction[] - cond493 = match_lookahead_literal(parser, "(", 0) - while cond493 - _t991 = parse_abstraction(parser) - item494 = _t991 - push!(xs492, item494) - cond493 = match_lookahead_literal(parser, "(", 0) + xs504 = Proto.Abstraction[] + cond505 = match_lookahead_literal(parser, "(", 0) + while cond505 + _t1015 = parse_abstraction(parser) + item506 = _t1015 + push!(xs504, item506) + cond505 = match_lookahead_literal(parser, "(", 0) end - abstractions495 = xs492 + abstractions507 = xs504 consume_literal!(parser, ")") - return abstractions495 + return abstractions507 end function parse_atom(parser::ParserState)::Proto.Atom consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t992 = parse_relation_id(parser) - relation_id496 = _t992 - xs497 = Proto.Term[] - cond498 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond498 - _t993 = parse_term(parser) - item499 = _t993 - push!(xs497, item499) - cond498 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1016 = parse_relation_id(parser) + relation_id508 = _t1016 + xs509 = Proto.Term[] + cond510 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond510 + _t1017 = parse_term(parser) + item511 = _t1017 + push!(xs509, item511) + cond510 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - terms500 = xs497 + terms512 = xs509 consume_literal!(parser, ")") - _t994 = Proto.Atom(name=relation_id496, terms=terms500) - return _t994 + _t1018 = Proto.Atom(name=relation_id508, terms=terms512) + return _t1018 end function parse_pragma(parser::ParserState)::Proto.Pragma consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t995 = parse_name(parser) - name501 = _t995 - xs502 = Proto.Term[] - cond503 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond503 - _t996 = parse_term(parser) - item504 = _t996 - push!(xs502, item504) - cond503 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - end - terms505 = xs502 - consume_literal!(parser, ")") - _t997 = Proto.Pragma(name=name501, terms=terms505) - return _t997 + _t1019 = parse_name(parser) + name513 = _t1019 + xs514 = Proto.Term[] + cond515 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond515 + _t1020 = parse_term(parser) + item516 = _t1020 + push!(xs514, item516) + cond515 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + end + terms517 = xs514 + consume_literal!(parser, ")") + _t1021 = Proto.Pragma(name=name513, terms=terms517) + return _t1021 end function parse_primitive(parser::ParserState)::Proto.Primitive if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t999 = 9 + _t1023 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1000 = 4 + _t1024 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1001 = 3 + _t1025 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1002 = 0 + _t1026 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1003 = 2 + _t1027 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1004 = 1 + _t1028 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1005 = 8 + _t1029 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1006 = 6 + _t1030 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1007 = 5 + _t1031 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1008 = 7 + _t1032 = 7 else - _t1008 = -1 + _t1032 = -1 end - _t1007 = _t1008 + _t1031 = _t1032 end - _t1006 = _t1007 + _t1030 = _t1031 end - _t1005 = _t1006 + _t1029 = _t1030 end - _t1004 = _t1005 + _t1028 = _t1029 end - _t1003 = _t1004 + _t1027 = _t1028 end - _t1002 = _t1003 + _t1026 = _t1027 end - _t1001 = _t1002 + _t1025 = _t1026 end - _t1000 = _t1001 + _t1024 = _t1025 end - _t999 = _t1000 + _t1023 = _t1024 end - _t998 = _t999 + _t1022 = _t1023 else - _t998 = -1 + _t1022 = -1 end - prediction506 = _t998 - if prediction506 == 9 + prediction518 = _t1022 + if prediction518 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1010 = parse_name(parser) - name516 = _t1010 - xs517 = Proto.RelTerm[] - cond518 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond518 - _t1011 = parse_rel_term(parser) - item519 = _t1011 - push!(xs517, item519) - cond518 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1034 = parse_name(parser) + name528 = _t1034 + xs529 = Proto.RelTerm[] + cond530 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond530 + _t1035 = parse_rel_term(parser) + item531 = _t1035 + push!(xs529, item531) + cond530 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - rel_terms520 = xs517 + rel_terms532 = xs529 consume_literal!(parser, ")") - _t1012 = Proto.Primitive(name=name516, terms=rel_terms520) - _t1009 = _t1012 + _t1036 = Proto.Primitive(name=name528, terms=rel_terms532) + _t1033 = _t1036 else - if prediction506 == 8 - _t1014 = parse_divide(parser) - divide515 = _t1014 - _t1013 = divide515 + if prediction518 == 8 + _t1038 = parse_divide(parser) + divide527 = _t1038 + _t1037 = divide527 else - if prediction506 == 7 - _t1016 = parse_multiply(parser) - multiply514 = _t1016 - _t1015 = multiply514 + if prediction518 == 7 + _t1040 = parse_multiply(parser) + multiply526 = _t1040 + _t1039 = multiply526 else - if prediction506 == 6 - _t1018 = parse_minus(parser) - minus513 = _t1018 - _t1017 = minus513 + if prediction518 == 6 + _t1042 = parse_minus(parser) + minus525 = _t1042 + _t1041 = minus525 else - if prediction506 == 5 - _t1020 = parse_add(parser) - add512 = _t1020 - _t1019 = add512 + if prediction518 == 5 + _t1044 = parse_add(parser) + add524 = _t1044 + _t1043 = add524 else - if prediction506 == 4 - _t1022 = parse_gt_eq(parser) - gt_eq511 = _t1022 - _t1021 = gt_eq511 + if prediction518 == 4 + _t1046 = parse_gt_eq(parser) + gt_eq523 = _t1046 + _t1045 = gt_eq523 else - if prediction506 == 3 - _t1024 = parse_gt(parser) - gt510 = _t1024 - _t1023 = gt510 + if prediction518 == 3 + _t1048 = parse_gt(parser) + gt522 = _t1048 + _t1047 = gt522 else - if prediction506 == 2 - _t1026 = parse_lt_eq(parser) - lt_eq509 = _t1026 - _t1025 = lt_eq509 + if prediction518 == 2 + _t1050 = parse_lt_eq(parser) + lt_eq521 = _t1050 + _t1049 = lt_eq521 else - if prediction506 == 1 - _t1028 = parse_lt(parser) - lt508 = _t1028 - _t1027 = lt508 + if prediction518 == 1 + _t1052 = parse_lt(parser) + lt520 = _t1052 + _t1051 = lt520 else - if prediction506 == 0 - _t1030 = parse_eq(parser) - eq507 = _t1030 - _t1029 = eq507 + if prediction518 == 0 + _t1054 = parse_eq(parser) + eq519 = _t1054 + _t1053 = eq519 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1027 = _t1029 + _t1051 = _t1053 end - _t1025 = _t1027 + _t1049 = _t1051 end - _t1023 = _t1025 + _t1047 = _t1049 end - _t1021 = _t1023 + _t1045 = _t1047 end - _t1019 = _t1021 + _t1043 = _t1045 end - _t1017 = _t1019 + _t1041 = _t1043 end - _t1015 = _t1017 + _t1039 = _t1041 end - _t1013 = _t1015 + _t1037 = _t1039 end - _t1009 = _t1013 + _t1033 = _t1037 end - return _t1009 + return _t1033 end function parse_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1031 = parse_term(parser) - term521 = _t1031 - _t1032 = parse_term(parser) - term_3522 = _t1032 + _t1055 = parse_term(parser) + term533 = _t1055 + _t1056 = parse_term(parser) + term_3534 = _t1056 consume_literal!(parser, ")") - _t1033 = Proto.RelTerm(rel_term_type=OneOf(:term, term521)) - _t1034 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3522)) - _t1035 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1033, _t1034]) - return _t1035 + _t1057 = Proto.RelTerm(rel_term_type=OneOf(:term, term533)) + _t1058 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3534)) + _t1059 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1057, _t1058]) + return _t1059 end function parse_lt(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1036 = parse_term(parser) - term523 = _t1036 - _t1037 = parse_term(parser) - term_3524 = _t1037 + _t1060 = parse_term(parser) + term535 = _t1060 + _t1061 = parse_term(parser) + term_3536 = _t1061 consume_literal!(parser, ")") - _t1038 = Proto.RelTerm(rel_term_type=OneOf(:term, term523)) - _t1039 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3524)) - _t1040 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1038, _t1039]) - return _t1040 + _t1062 = Proto.RelTerm(rel_term_type=OneOf(:term, term535)) + _t1063 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3536)) + _t1064 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1062, _t1063]) + return _t1064 end function parse_lt_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1041 = parse_term(parser) - term525 = _t1041 - _t1042 = parse_term(parser) - term_3526 = _t1042 + _t1065 = parse_term(parser) + term537 = _t1065 + _t1066 = parse_term(parser) + term_3538 = _t1066 consume_literal!(parser, ")") - _t1043 = Proto.RelTerm(rel_term_type=OneOf(:term, term525)) - _t1044 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3526)) - _t1045 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1043, _t1044]) - return _t1045 + _t1067 = Proto.RelTerm(rel_term_type=OneOf(:term, term537)) + _t1068 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538)) + _t1069 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1067, _t1068]) + return _t1069 end function parse_gt(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1046 = parse_term(parser) - term527 = _t1046 - _t1047 = parse_term(parser) - term_3528 = _t1047 + _t1070 = parse_term(parser) + term539 = _t1070 + _t1071 = parse_term(parser) + term_3540 = _t1071 consume_literal!(parser, ")") - _t1048 = Proto.RelTerm(rel_term_type=OneOf(:term, term527)) - _t1049 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3528)) - _t1050 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1048, _t1049]) - return _t1050 + _t1072 = Proto.RelTerm(rel_term_type=OneOf(:term, term539)) + _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3540)) + _t1074 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1072, _t1073]) + return _t1074 end function parse_gt_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1051 = parse_term(parser) - term529 = _t1051 - _t1052 = parse_term(parser) - term_3530 = _t1052 + _t1075 = parse_term(parser) + term541 = _t1075 + _t1076 = parse_term(parser) + term_3542 = _t1076 consume_literal!(parser, ")") - _t1053 = Proto.RelTerm(rel_term_type=OneOf(:term, term529)) - _t1054 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3530)) - _t1055 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1053, _t1054]) - return _t1055 + _t1077 = Proto.RelTerm(rel_term_type=OneOf(:term, term541)) + _t1078 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3542)) + _t1079 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1077, _t1078]) + return _t1079 end function parse_add(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1056 = parse_term(parser) - term531 = _t1056 - _t1057 = parse_term(parser) - term_3532 = _t1057 - _t1058 = parse_term(parser) - term_4533 = _t1058 + _t1080 = parse_term(parser) + term543 = _t1080 + _t1081 = parse_term(parser) + term_3544 = _t1081 + _t1082 = parse_term(parser) + term_4545 = _t1082 consume_literal!(parser, ")") - _t1059 = Proto.RelTerm(rel_term_type=OneOf(:term, term531)) - _t1060 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3532)) - _t1061 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4533)) - _t1062 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1059, _t1060, _t1061]) - return _t1062 + _t1083 = Proto.RelTerm(rel_term_type=OneOf(:term, term543)) + _t1084 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3544)) + _t1085 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4545)) + _t1086 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1083, _t1084, _t1085]) + return _t1086 end function parse_minus(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1063 = parse_term(parser) - term534 = _t1063 - _t1064 = parse_term(parser) - term_3535 = _t1064 - _t1065 = parse_term(parser) - term_4536 = _t1065 + _t1087 = parse_term(parser) + term546 = _t1087 + _t1088 = parse_term(parser) + term_3547 = _t1088 + _t1089 = parse_term(parser) + term_4548 = _t1089 consume_literal!(parser, ")") - _t1066 = Proto.RelTerm(rel_term_type=OneOf(:term, term534)) - _t1067 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3535)) - _t1068 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4536)) - _t1069 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1066, _t1067, _t1068]) - return _t1069 + _t1090 = Proto.RelTerm(rel_term_type=OneOf(:term, term546)) + _t1091 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3547)) + _t1092 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4548)) + _t1093 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1090, _t1091, _t1092]) + return _t1093 end function parse_multiply(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1070 = parse_term(parser) - term537 = _t1070 - _t1071 = parse_term(parser) - term_3538 = _t1071 - _t1072 = parse_term(parser) - term_4539 = _t1072 + _t1094 = parse_term(parser) + term549 = _t1094 + _t1095 = parse_term(parser) + term_3550 = _t1095 + _t1096 = parse_term(parser) + term_4551 = _t1096 consume_literal!(parser, ")") - _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term537)) - _t1074 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538)) - _t1075 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4539)) - _t1076 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1073, _t1074, _t1075]) - return _t1076 + _t1097 = Proto.RelTerm(rel_term_type=OneOf(:term, term549)) + _t1098 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3550)) + _t1099 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4551)) + _t1100 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1097, _t1098, _t1099]) + return _t1100 end function parse_divide(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1077 = parse_term(parser) - term540 = _t1077 - _t1078 = parse_term(parser) - term_3541 = _t1078 - _t1079 = parse_term(parser) - term_4542 = _t1079 + _t1101 = parse_term(parser) + term552 = _t1101 + _t1102 = parse_term(parser) + term_3553 = _t1102 + _t1103 = parse_term(parser) + term_4554 = _t1103 consume_literal!(parser, ")") - _t1080 = Proto.RelTerm(rel_term_type=OneOf(:term, term540)) - _t1081 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3541)) - _t1082 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4542)) - _t1083 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1080, _t1081, _t1082]) - return _t1083 + _t1104 = Proto.RelTerm(rel_term_type=OneOf(:term, term552)) + _t1105 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3553)) + _t1106 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4554)) + _t1107 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1104, _t1105, _t1106]) + return _t1107 end function parse_rel_term(parser::ParserState)::Proto.RelTerm if match_lookahead_literal(parser, "true", 0) - _t1084 = 1 + _t1108 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1085 = 1 + _t1109 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1086 = 1 + _t1110 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1087 = 1 + _t1111 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1088 = 0 + _t1112 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1089 = 1 + _t1113 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1090 = 1 + _t1114 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1091 = 1 + _t1115 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1092 = 1 + _t1116 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1093 = 1 + _t1117 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1094 = 1 + _t1118 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1095 = 1 + _t1119 = 1 else - _t1095 = -1 + _t1119 = -1 end - _t1094 = _t1095 + _t1118 = _t1119 end - _t1093 = _t1094 + _t1117 = _t1118 end - _t1092 = _t1093 + _t1116 = _t1117 end - _t1091 = _t1092 + _t1115 = _t1116 end - _t1090 = _t1091 + _t1114 = _t1115 end - _t1089 = _t1090 + _t1113 = _t1114 end - _t1088 = _t1089 + _t1112 = _t1113 end - _t1087 = _t1088 + _t1111 = _t1112 end - _t1086 = _t1087 + _t1110 = _t1111 end - _t1085 = _t1086 + _t1109 = _t1110 end - _t1084 = _t1085 - end - prediction543 = _t1084 - if prediction543 == 1 - _t1097 = parse_term(parser) - term545 = _t1097 - _t1098 = Proto.RelTerm(rel_term_type=OneOf(:term, term545)) - _t1096 = _t1098 + _t1108 = _t1109 + end + prediction555 = _t1108 + if prediction555 == 1 + _t1121 = parse_term(parser) + term557 = _t1121 + _t1122 = Proto.RelTerm(rel_term_type=OneOf(:term, term557)) + _t1120 = _t1122 else - if prediction543 == 0 - _t1100 = parse_specialized_value(parser) - specialized_value544 = _t1100 - _t1101 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value544)) - _t1099 = _t1101 + if prediction555 == 0 + _t1124 = parse_specialized_value(parser) + specialized_value556 = _t1124 + _t1125 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value556)) + _t1123 = _t1125 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1096 = _t1099 + _t1120 = _t1123 end - return _t1096 + return _t1120 end function parse_specialized_value(parser::ParserState)::Proto.Value consume_literal!(parser, "#") - _t1102 = parse_value(parser) - value546 = _t1102 - return value546 + _t1126 = parse_value(parser) + value558 = _t1126 + return value558 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1103 = parse_name(parser) - name547 = _t1103 - xs548 = Proto.RelTerm[] - cond549 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond549 - _t1104 = parse_rel_term(parser) - item550 = _t1104 - push!(xs548, item550) - cond549 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1127 = parse_name(parser) + name559 = _t1127 + xs560 = Proto.RelTerm[] + cond561 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond561 + _t1128 = parse_rel_term(parser) + item562 = _t1128 + push!(xs560, item562) + cond561 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - rel_terms551 = xs548 + rel_terms563 = xs560 consume_literal!(parser, ")") - _t1105 = Proto.RelAtom(name=name547, terms=rel_terms551) - return _t1105 + _t1129 = Proto.RelAtom(name=name559, terms=rel_terms563) + return _t1129 end function parse_cast(parser::ParserState)::Proto.Cast consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1106 = parse_term(parser) - term552 = _t1106 - _t1107 = parse_term(parser) - term_3553 = _t1107 + _t1130 = parse_term(parser) + term564 = _t1130 + _t1131 = parse_term(parser) + term_3565 = _t1131 consume_literal!(parser, ")") - _t1108 = Proto.Cast(input=term552, result=term_3553) - return _t1108 + _t1132 = Proto.Cast(input=term564, result=term_3565) + return _t1132 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs554 = Proto.Attribute[] - cond555 = match_lookahead_literal(parser, "(", 0) - while cond555 - _t1109 = parse_attribute(parser) - item556 = _t1109 - push!(xs554, item556) - cond555 = match_lookahead_literal(parser, "(", 0) + xs566 = Proto.Attribute[] + cond567 = match_lookahead_literal(parser, "(", 0) + while cond567 + _t1133 = parse_attribute(parser) + item568 = _t1133 + push!(xs566, item568) + cond567 = match_lookahead_literal(parser, "(", 0) end - attributes557 = xs554 + attributes569 = xs566 consume_literal!(parser, ")") - return attributes557 + return attributes569 end function parse_attribute(parser::ParserState)::Proto.Attribute consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1110 = parse_name(parser) - name558 = _t1110 - xs559 = Proto.Value[] - cond560 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond560 - _t1111 = parse_value(parser) - item561 = _t1111 - push!(xs559, item561) - cond560 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1134 = parse_name(parser) + name570 = _t1134 + xs571 = Proto.Value[] + cond572 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond572 + _t1135 = parse_value(parser) + item573 = _t1135 + push!(xs571, item573) + cond572 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - values562 = xs559 + values574 = xs571 consume_literal!(parser, ")") - _t1112 = Proto.Attribute(name=name558, args=values562) - return _t1112 + _t1136 = Proto.Attribute(name=name570, args=values574) + return _t1136 end function parse_algorithm(parser::ParserState)::Proto.Algorithm consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs563 = Proto.RelationId[] - cond564 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond564 - _t1113 = parse_relation_id(parser) - item565 = _t1113 - push!(xs563, item565) - cond564 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs575 = Proto.RelationId[] + cond576 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond576 + _t1137 = parse_relation_id(parser) + item577 = _t1137 + push!(xs575, item577) + cond576 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids566 = xs563 - _t1114 = parse_script(parser) - script567 = _t1114 + relation_ids578 = xs575 + _t1138 = parse_script(parser) + script579 = _t1138 consume_literal!(parser, ")") - _t1115 = Proto.Algorithm(var"#global"=relation_ids566, body=script567) - return _t1115 + _t1139 = Proto.Algorithm(var"#global"=relation_ids578, body=script579) + return _t1139 end function parse_script(parser::ParserState)::Proto.Script consume_literal!(parser, "(") consume_literal!(parser, "script") - xs568 = Proto.Construct[] - cond569 = match_lookahead_literal(parser, "(", 0) - while cond569 - _t1116 = parse_construct(parser) - item570 = _t1116 - push!(xs568, item570) - cond569 = match_lookahead_literal(parser, "(", 0) + xs580 = Proto.Construct[] + cond581 = match_lookahead_literal(parser, "(", 0) + while cond581 + _t1140 = parse_construct(parser) + item582 = _t1140 + push!(xs580, item582) + cond581 = match_lookahead_literal(parser, "(", 0) end - constructs571 = xs568 + constructs583 = xs580 consume_literal!(parser, ")") - _t1117 = Proto.Script(constructs=constructs571) - return _t1117 + _t1141 = Proto.Script(constructs=constructs583) + return _t1141 end function parse_construct(parser::ParserState)::Proto.Construct if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1119 = 1 + _t1143 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1120 = 1 + _t1144 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1121 = 1 + _t1145 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1122 = 0 + _t1146 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1123 = 1 + _t1147 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1124 = 1 + _t1148 = 1 else - _t1124 = -1 + _t1148 = -1 end - _t1123 = _t1124 + _t1147 = _t1148 end - _t1122 = _t1123 + _t1146 = _t1147 end - _t1121 = _t1122 + _t1145 = _t1146 end - _t1120 = _t1121 + _t1144 = _t1145 end - _t1119 = _t1120 + _t1143 = _t1144 end - _t1118 = _t1119 + _t1142 = _t1143 else - _t1118 = -1 - end - prediction572 = _t1118 - if prediction572 == 1 - _t1126 = parse_instruction(parser) - instruction574 = _t1126 - _t1127 = Proto.Construct(construct_type=OneOf(:instruction, instruction574)) - _t1125 = _t1127 + _t1142 = -1 + end + prediction584 = _t1142 + if prediction584 == 1 + _t1150 = parse_instruction(parser) + instruction586 = _t1150 + _t1151 = Proto.Construct(construct_type=OneOf(:instruction, instruction586)) + _t1149 = _t1151 else - if prediction572 == 0 - _t1129 = parse_loop(parser) - loop573 = _t1129 - _t1130 = Proto.Construct(construct_type=OneOf(:loop, loop573)) - _t1128 = _t1130 + if prediction584 == 0 + _t1153 = parse_loop(parser) + loop585 = _t1153 + _t1154 = Proto.Construct(construct_type=OneOf(:loop, loop585)) + _t1152 = _t1154 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1125 = _t1128 + _t1149 = _t1152 end - return _t1125 + return _t1149 end function parse_loop(parser::ParserState)::Proto.Loop consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1131 = parse_init(parser) - init575 = _t1131 - _t1132 = parse_script(parser) - script576 = _t1132 + _t1155 = parse_init(parser) + init587 = _t1155 + _t1156 = parse_script(parser) + script588 = _t1156 consume_literal!(parser, ")") - _t1133 = Proto.Loop(init=init575, body=script576) - return _t1133 + _t1157 = Proto.Loop(init=init587, body=script588) + return _t1157 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs577 = Proto.Instruction[] - cond578 = match_lookahead_literal(parser, "(", 0) - while cond578 - _t1134 = parse_instruction(parser) - item579 = _t1134 - push!(xs577, item579) - cond578 = match_lookahead_literal(parser, "(", 0) + xs589 = Proto.Instruction[] + cond590 = match_lookahead_literal(parser, "(", 0) + while cond590 + _t1158 = parse_instruction(parser) + item591 = _t1158 + push!(xs589, item591) + cond590 = match_lookahead_literal(parser, "(", 0) end - instructions580 = xs577 + instructions592 = xs589 consume_literal!(parser, ")") - return instructions580 + return instructions592 end function parse_instruction(parser::ParserState)::Proto.Instruction if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1136 = 1 + _t1160 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1137 = 4 + _t1161 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1138 = 3 + _t1162 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1139 = 2 + _t1163 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1140 = 0 + _t1164 = 0 else - _t1140 = -1 + _t1164 = -1 end - _t1139 = _t1140 + _t1163 = _t1164 end - _t1138 = _t1139 + _t1162 = _t1163 end - _t1137 = _t1138 + _t1161 = _t1162 end - _t1136 = _t1137 + _t1160 = _t1161 end - _t1135 = _t1136 + _t1159 = _t1160 else - _t1135 = -1 - end - prediction581 = _t1135 - if prediction581 == 4 - _t1142 = parse_monus_def(parser) - monus_def586 = _t1142 - _t1143 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def586)) - _t1141 = _t1143 + _t1159 = -1 + end + prediction593 = _t1159 + if prediction593 == 4 + _t1166 = parse_monus_def(parser) + monus_def598 = _t1166 + _t1167 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def598)) + _t1165 = _t1167 else - if prediction581 == 3 - _t1145 = parse_monoid_def(parser) - monoid_def585 = _t1145 - _t1146 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def585)) - _t1144 = _t1146 + if prediction593 == 3 + _t1169 = parse_monoid_def(parser) + monoid_def597 = _t1169 + _t1170 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def597)) + _t1168 = _t1170 else - if prediction581 == 2 - _t1148 = parse_break(parser) - break584 = _t1148 - _t1149 = Proto.Instruction(instr_type=OneOf(:var"#break", break584)) - _t1147 = _t1149 + if prediction593 == 2 + _t1172 = parse_break(parser) + break596 = _t1172 + _t1173 = Proto.Instruction(instr_type=OneOf(:var"#break", break596)) + _t1171 = _t1173 else - if prediction581 == 1 - _t1151 = parse_upsert(parser) - upsert583 = _t1151 - _t1152 = Proto.Instruction(instr_type=OneOf(:upsert, upsert583)) - _t1150 = _t1152 + if prediction593 == 1 + _t1175 = parse_upsert(parser) + upsert595 = _t1175 + _t1176 = Proto.Instruction(instr_type=OneOf(:upsert, upsert595)) + _t1174 = _t1176 else - if prediction581 == 0 - _t1154 = parse_assign(parser) - assign582 = _t1154 - _t1155 = Proto.Instruction(instr_type=OneOf(:assign, assign582)) - _t1153 = _t1155 + if prediction593 == 0 + _t1178 = parse_assign(parser) + assign594 = _t1178 + _t1179 = Proto.Instruction(instr_type=OneOf(:assign, assign594)) + _t1177 = _t1179 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1150 = _t1153 + _t1174 = _t1177 end - _t1147 = _t1150 + _t1171 = _t1174 end - _t1144 = _t1147 + _t1168 = _t1171 end - _t1141 = _t1144 + _t1165 = _t1168 end - return _t1141 + return _t1165 end function parse_assign(parser::ParserState)::Proto.Assign consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1156 = parse_relation_id(parser) - relation_id587 = _t1156 - _t1157 = parse_abstraction(parser) - abstraction588 = _t1157 + _t1180 = parse_relation_id(parser) + relation_id599 = _t1180 + _t1181 = parse_abstraction(parser) + abstraction600 = _t1181 if match_lookahead_literal(parser, "(", 0) - _t1159 = parse_attrs(parser) - _t1158 = _t1159 + _t1183 = parse_attrs(parser) + _t1182 = _t1183 else - _t1158 = nothing + _t1182 = nothing end - attrs589 = _t1158 + attrs601 = _t1182 consume_literal!(parser, ")") - _t1160 = Proto.Assign(name=relation_id587, body=abstraction588, attrs=(!isnothing(attrs589) ? attrs589 : Proto.Attribute[])) - return _t1160 + _t1184 = Proto.Assign(name=relation_id599, body=abstraction600, attrs=(!isnothing(attrs601) ? attrs601 : Proto.Attribute[])) + return _t1184 end function parse_upsert(parser::ParserState)::Proto.Upsert consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1161 = parse_relation_id(parser) - relation_id590 = _t1161 - _t1162 = parse_abstraction_with_arity(parser) - abstraction_with_arity591 = _t1162 + _t1185 = parse_relation_id(parser) + relation_id602 = _t1185 + _t1186 = parse_abstraction_with_arity(parser) + abstraction_with_arity603 = _t1186 if match_lookahead_literal(parser, "(", 0) - _t1164 = parse_attrs(parser) - _t1163 = _t1164 + _t1188 = parse_attrs(parser) + _t1187 = _t1188 else - _t1163 = nothing + _t1187 = nothing end - attrs592 = _t1163 + attrs604 = _t1187 consume_literal!(parser, ")") - _t1165 = Proto.Upsert(name=relation_id590, body=abstraction_with_arity591[1], attrs=(!isnothing(attrs592) ? attrs592 : Proto.Attribute[]), value_arity=abstraction_with_arity591[2]) - return _t1165 + _t1189 = Proto.Upsert(name=relation_id602, body=abstraction_with_arity603[1], attrs=(!isnothing(attrs604) ? attrs604 : Proto.Attribute[]), value_arity=abstraction_with_arity603[2]) + return _t1189 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1166 = parse_bindings(parser) - bindings593 = _t1166 - _t1167 = parse_formula(parser) - formula594 = _t1167 + _t1190 = parse_bindings(parser) + bindings605 = _t1190 + _t1191 = parse_formula(parser) + formula606 = _t1191 consume_literal!(parser, ")") - _t1168 = Proto.Abstraction(vars=vcat(bindings593[1], !isnothing(bindings593[2]) ? bindings593[2] : []), value=formula594) - return (_t1168, length(bindings593[2]),) + _t1192 = Proto.Abstraction(vars=vcat(bindings605[1], !isnothing(bindings605[2]) ? bindings605[2] : []), value=formula606) + return (_t1192, length(bindings605[2]),) end function parse_break(parser::ParserState)::Proto.Break consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1169 = parse_relation_id(parser) - relation_id595 = _t1169 - _t1170 = parse_abstraction(parser) - abstraction596 = _t1170 + _t1193 = parse_relation_id(parser) + relation_id607 = _t1193 + _t1194 = parse_abstraction(parser) + abstraction608 = _t1194 if match_lookahead_literal(parser, "(", 0) - _t1172 = parse_attrs(parser) - _t1171 = _t1172 + _t1196 = parse_attrs(parser) + _t1195 = _t1196 else - _t1171 = nothing + _t1195 = nothing end - attrs597 = _t1171 + attrs609 = _t1195 consume_literal!(parser, ")") - _t1173 = Proto.Break(name=relation_id595, body=abstraction596, attrs=(!isnothing(attrs597) ? attrs597 : Proto.Attribute[])) - return _t1173 + _t1197 = Proto.Break(name=relation_id607, body=abstraction608, attrs=(!isnothing(attrs609) ? attrs609 : Proto.Attribute[])) + return _t1197 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1174 = parse_monoid(parser) - monoid598 = _t1174 - _t1175 = parse_relation_id(parser) - relation_id599 = _t1175 - _t1176 = parse_abstraction_with_arity(parser) - abstraction_with_arity600 = _t1176 + _t1198 = parse_monoid(parser) + monoid610 = _t1198 + _t1199 = parse_relation_id(parser) + relation_id611 = _t1199 + _t1200 = parse_abstraction_with_arity(parser) + abstraction_with_arity612 = _t1200 if match_lookahead_literal(parser, "(", 0) - _t1178 = parse_attrs(parser) - _t1177 = _t1178 + _t1202 = parse_attrs(parser) + _t1201 = _t1202 else - _t1177 = nothing + _t1201 = nothing end - attrs601 = _t1177 + attrs613 = _t1201 consume_literal!(parser, ")") - _t1179 = Proto.MonoidDef(monoid=monoid598, name=relation_id599, body=abstraction_with_arity600[1], attrs=(!isnothing(attrs601) ? attrs601 : Proto.Attribute[]), value_arity=abstraction_with_arity600[2]) - return _t1179 + _t1203 = Proto.MonoidDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[1], attrs=(!isnothing(attrs613) ? attrs613 : Proto.Attribute[]), value_arity=abstraction_with_arity612[2]) + return _t1203 end function parse_monoid(parser::ParserState)::Proto.Monoid if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1181 = 3 + _t1205 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1182 = 0 + _t1206 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1183 = 1 + _t1207 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1184 = 2 + _t1208 = 2 else - _t1184 = -1 + _t1208 = -1 end - _t1183 = _t1184 + _t1207 = _t1208 end - _t1182 = _t1183 + _t1206 = _t1207 end - _t1181 = _t1182 + _t1205 = _t1206 end - _t1180 = _t1181 + _t1204 = _t1205 else - _t1180 = -1 - end - prediction602 = _t1180 - if prediction602 == 3 - _t1186 = parse_sum_monoid(parser) - sum_monoid606 = _t1186 - _t1187 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid606)) - _t1185 = _t1187 + _t1204 = -1 + end + prediction614 = _t1204 + if prediction614 == 3 + _t1210 = parse_sum_monoid(parser) + sum_monoid618 = _t1210 + _t1211 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid618)) + _t1209 = _t1211 else - if prediction602 == 2 - _t1189 = parse_max_monoid(parser) - max_monoid605 = _t1189 - _t1190 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid605)) - _t1188 = _t1190 + if prediction614 == 2 + _t1213 = parse_max_monoid(parser) + max_monoid617 = _t1213 + _t1214 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid617)) + _t1212 = _t1214 else - if prediction602 == 1 - _t1192 = parse_min_monoid(parser) - min_monoid604 = _t1192 - _t1193 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid604)) - _t1191 = _t1193 + if prediction614 == 1 + _t1216 = parse_min_monoid(parser) + min_monoid616 = _t1216 + _t1217 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid616)) + _t1215 = _t1217 else - if prediction602 == 0 - _t1195 = parse_or_monoid(parser) - or_monoid603 = _t1195 - _t1196 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid603)) - _t1194 = _t1196 + if prediction614 == 0 + _t1219 = parse_or_monoid(parser) + or_monoid615 = _t1219 + _t1220 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid615)) + _t1218 = _t1220 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1191 = _t1194 + _t1215 = _t1218 end - _t1188 = _t1191 + _t1212 = _t1215 end - _t1185 = _t1188 + _t1209 = _t1212 end - return _t1185 + return _t1209 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1197 = Proto.OrMonoid() - return _t1197 + _t1221 = Proto.OrMonoid() + return _t1221 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1198 = parse_type(parser) - type607 = _t1198 + _t1222 = parse_type(parser) + type619 = _t1222 consume_literal!(parser, ")") - _t1199 = Proto.MinMonoid(var"#type"=type607) - return _t1199 + _t1223 = Proto.MinMonoid(var"#type"=type619) + return _t1223 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1200 = parse_type(parser) - type608 = _t1200 + _t1224 = parse_type(parser) + type620 = _t1224 consume_literal!(parser, ")") - _t1201 = Proto.MaxMonoid(var"#type"=type608) - return _t1201 + _t1225 = Proto.MaxMonoid(var"#type"=type620) + return _t1225 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1202 = parse_type(parser) - type609 = _t1202 + _t1226 = parse_type(parser) + type621 = _t1226 consume_literal!(parser, ")") - _t1203 = Proto.SumMonoid(var"#type"=type609) - return _t1203 + _t1227 = Proto.SumMonoid(var"#type"=type621) + return _t1227 end function parse_monus_def(parser::ParserState)::Proto.MonusDef consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1204 = parse_monoid(parser) - monoid610 = _t1204 - _t1205 = parse_relation_id(parser) - relation_id611 = _t1205 - _t1206 = parse_abstraction_with_arity(parser) - abstraction_with_arity612 = _t1206 + _t1228 = parse_monoid(parser) + monoid622 = _t1228 + _t1229 = parse_relation_id(parser) + relation_id623 = _t1229 + _t1230 = parse_abstraction_with_arity(parser) + abstraction_with_arity624 = _t1230 if match_lookahead_literal(parser, "(", 0) - _t1208 = parse_attrs(parser) - _t1207 = _t1208 + _t1232 = parse_attrs(parser) + _t1231 = _t1232 else - _t1207 = nothing + _t1231 = nothing end - attrs613 = _t1207 + attrs625 = _t1231 consume_literal!(parser, ")") - _t1209 = Proto.MonusDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[1], attrs=(!isnothing(attrs613) ? attrs613 : Proto.Attribute[]), value_arity=abstraction_with_arity612[2]) - return _t1209 + _t1233 = Proto.MonusDef(monoid=monoid622, name=relation_id623, body=abstraction_with_arity624[1], attrs=(!isnothing(attrs625) ? attrs625 : Proto.Attribute[]), value_arity=abstraction_with_arity624[2]) + return _t1233 end function parse_constraint(parser::ParserState)::Proto.Constraint consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1210 = parse_relation_id(parser) - relation_id614 = _t1210 - _t1211 = parse_abstraction(parser) - abstraction615 = _t1211 - _t1212 = parse_functional_dependency_keys(parser) - functional_dependency_keys616 = _t1212 - _t1213 = parse_functional_dependency_values(parser) - functional_dependency_values617 = _t1213 + _t1234 = parse_relation_id(parser) + relation_id626 = _t1234 + _t1235 = parse_abstraction(parser) + abstraction627 = _t1235 + _t1236 = parse_functional_dependency_keys(parser) + functional_dependency_keys628 = _t1236 + _t1237 = parse_functional_dependency_values(parser) + functional_dependency_values629 = _t1237 consume_literal!(parser, ")") - _t1214 = Proto.FunctionalDependency(guard=abstraction615, keys=functional_dependency_keys616, values=functional_dependency_values617) - _t1215 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1214), name=relation_id614) - return _t1215 + _t1238 = Proto.FunctionalDependency(guard=abstraction627, keys=functional_dependency_keys628, values=functional_dependency_values629) + _t1239 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1238), name=relation_id626) + return _t1239 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs618 = Proto.Var[] - cond619 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond619 - _t1216 = parse_var(parser) - item620 = _t1216 - push!(xs618, item620) - cond619 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs630 = Proto.Var[] + cond631 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond631 + _t1240 = parse_var(parser) + item632 = _t1240 + push!(xs630, item632) + cond631 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars621 = xs618 + vars633 = xs630 consume_literal!(parser, ")") - return vars621 + return vars633 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs622 = Proto.Var[] - cond623 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond623 - _t1217 = parse_var(parser) - item624 = _t1217 - push!(xs622, item624) - cond623 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs634 = Proto.Var[] + cond635 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond635 + _t1241 = parse_var(parser) + item636 = _t1241 + push!(xs634, item636) + cond635 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars625 = xs622 + vars637 = xs634 consume_literal!(parser, ")") - return vars625 + return vars637 end function parse_data(parser::ParserState)::Proto.Data if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "rel_edb", 1) - _t1219 = 0 + _t1243 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1220 = 2 + _t1244 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1221 = 1 + _t1245 = 1 else - _t1221 = -1 + _t1245 = -1 end - _t1220 = _t1221 + _t1244 = _t1245 end - _t1219 = _t1220 + _t1243 = _t1244 end - _t1218 = _t1219 + _t1242 = _t1243 else - _t1218 = -1 - end - prediction626 = _t1218 - if prediction626 == 2 - _t1223 = parse_csv_data(parser) - csv_data629 = _t1223 - _t1224 = Proto.Data(data_type=OneOf(:csv_data, csv_data629)) - _t1222 = _t1224 + _t1242 = -1 + end + prediction638 = _t1242 + if prediction638 == 2 + _t1247 = parse_csv_data(parser) + csv_data641 = _t1247 + _t1248 = Proto.Data(data_type=OneOf(:csv_data, csv_data641)) + _t1246 = _t1248 else - if prediction626 == 1 - _t1226 = parse_betree_relation(parser) - betree_relation628 = _t1226 - _t1227 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation628)) - _t1225 = _t1227 + if prediction638 == 1 + _t1250 = parse_betree_relation(parser) + betree_relation640 = _t1250 + _t1251 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation640)) + _t1249 = _t1251 else - if prediction626 == 0 - _t1229 = parse_rel_edb(parser) - rel_edb627 = _t1229 - _t1230 = Proto.Data(data_type=OneOf(:rel_edb, rel_edb627)) - _t1228 = _t1230 + if prediction638 == 0 + _t1253 = parse_rel_edb(parser) + rel_edb639 = _t1253 + _t1254 = Proto.Data(data_type=OneOf(:rel_edb, rel_edb639)) + _t1252 = _t1254 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1225 = _t1228 + _t1249 = _t1252 end - _t1222 = _t1225 + _t1246 = _t1249 end - return _t1222 + return _t1246 end function parse_rel_edb(parser::ParserState)::Proto.RelEDB consume_literal!(parser, "(") consume_literal!(parser, "rel_edb") - _t1231 = parse_relation_id(parser) - relation_id630 = _t1231 - _t1232 = parse_rel_edb_path(parser) - rel_edb_path631 = _t1232 - _t1233 = parse_rel_edb_types(parser) - rel_edb_types632 = _t1233 + _t1255 = parse_relation_id(parser) + relation_id642 = _t1255 + _t1256 = parse_rel_edb_path(parser) + rel_edb_path643 = _t1256 + _t1257 = parse_rel_edb_types(parser) + rel_edb_types644 = _t1257 consume_literal!(parser, ")") - _t1234 = Proto.RelEDB(target_id=relation_id630, path=rel_edb_path631, types=rel_edb_types632) - return _t1234 + _t1258 = Proto.RelEDB(target_id=relation_id642, path=rel_edb_path643, types=rel_edb_types644) + return _t1258 end function parse_rel_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs633 = String[] - cond634 = match_lookahead_terminal(parser, "STRING", 0) - while cond634 - item635 = consume_terminal!(parser, "STRING") - push!(xs633, item635) - cond634 = match_lookahead_terminal(parser, "STRING", 0) - end - strings636 = xs633 + xs645 = String[] + cond646 = match_lookahead_terminal(parser, "STRING", 0) + while cond646 + item647 = consume_terminal!(parser, "STRING") + push!(xs645, item647) + cond646 = match_lookahead_terminal(parser, "STRING", 0) + end + strings648 = xs645 consume_literal!(parser, "]") - return strings636 + return strings648 end function parse_rel_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs637 = Proto.var"#Type"[] - cond638 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond638 - _t1235 = parse_type(parser) - item639 = _t1235 - push!(xs637, item639) - cond638 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types640 = xs637 + xs649 = Proto.var"#Type"[] + cond650 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond650 + _t1259 = parse_type(parser) + item651 = _t1259 + push!(xs649, item651) + cond650 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types652 = xs649 consume_literal!(parser, "]") - return types640 + return types652 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1236 = parse_relation_id(parser) - relation_id641 = _t1236 - _t1237 = parse_betree_info(parser) - betree_info642 = _t1237 + _t1260 = parse_relation_id(parser) + relation_id653 = _t1260 + _t1261 = parse_betree_info(parser) + betree_info654 = _t1261 consume_literal!(parser, ")") - _t1238 = Proto.BeTreeRelation(name=relation_id641, relation_info=betree_info642) - return _t1238 + _t1262 = Proto.BeTreeRelation(name=relation_id653, relation_info=betree_info654) + return _t1262 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1239 = parse_betree_info_key_types(parser) - betree_info_key_types643 = _t1239 - _t1240 = parse_betree_info_value_types(parser) - betree_info_value_types644 = _t1240 - _t1241 = parse_config_dict(parser) - config_dict645 = _t1241 + _t1263 = parse_betree_info_key_types(parser) + betree_info_key_types655 = _t1263 + _t1264 = parse_betree_info_value_types(parser) + betree_info_value_types656 = _t1264 + _t1265 = parse_config_dict(parser) + config_dict657 = _t1265 consume_literal!(parser, ")") - _t1242 = construct_betree_info(parser, betree_info_key_types643, betree_info_value_types644, config_dict645) - return _t1242 + _t1266 = construct_betree_info(parser, betree_info_key_types655, betree_info_value_types656, config_dict657) + return _t1266 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs646 = Proto.var"#Type"[] - cond647 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond647 - _t1243 = parse_type(parser) - item648 = _t1243 - push!(xs646, item648) - cond647 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs658 = Proto.var"#Type"[] + cond659 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond659 + _t1267 = parse_type(parser) + item660 = _t1267 + push!(xs658, item660) + cond659 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types649 = xs646 + types661 = xs658 consume_literal!(parser, ")") - return types649 + return types661 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs650 = Proto.var"#Type"[] - cond651 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond651 - _t1244 = parse_type(parser) - item652 = _t1244 - push!(xs650, item652) - cond651 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs662 = Proto.var"#Type"[] + cond663 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond663 + _t1268 = parse_type(parser) + item664 = _t1268 + push!(xs662, item664) + cond663 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types653 = xs650 + types665 = xs662 consume_literal!(parser, ")") - return types653 + return types665 end function parse_csv_data(parser::ParserState)::Proto.CSVData consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1245 = parse_csvlocator(parser) - csvlocator654 = _t1245 - _t1246 = parse_csv_config(parser) - csv_config655 = _t1246 - _t1247 = parse_csv_columns(parser) - csv_columns656 = _t1247 - _t1248 = parse_csv_asof(parser) - csv_asof657 = _t1248 + _t1269 = parse_csvlocator(parser) + csvlocator666 = _t1269 + _t1270 = parse_csv_config(parser) + csv_config667 = _t1270 + _t1271 = parse_csv_columns(parser) + csv_columns668 = _t1271 + _t1272 = parse_csv_asof(parser) + csv_asof669 = _t1272 consume_literal!(parser, ")") - _t1249 = Proto.CSVData(locator=csvlocator654, config=csv_config655, columns=csv_columns656, asof=csv_asof657) - return _t1249 + _t1273 = Proto.CSVData(locator=csvlocator666, config=csv_config667, columns=csv_columns668, asof=csv_asof669) + return _t1273 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1251 = parse_csv_locator_paths(parser) - _t1250 = _t1251 + _t1275 = parse_csv_locator_paths(parser) + _t1274 = _t1275 else - _t1250 = nothing + _t1274 = nothing end - csv_locator_paths658 = _t1250 + csv_locator_paths670 = _t1274 if match_lookahead_literal(parser, "(", 0) - _t1253 = parse_csv_locator_inline_data(parser) - _t1252 = _t1253 + _t1277 = parse_csv_locator_inline_data(parser) + _t1276 = _t1277 else - _t1252 = nothing + _t1276 = nothing end - csv_locator_inline_data659 = _t1252 + csv_locator_inline_data671 = _t1276 consume_literal!(parser, ")") - _t1254 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths658) ? csv_locator_paths658 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data659) ? csv_locator_inline_data659 : ""))) - return _t1254 + _t1278 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths670) ? csv_locator_paths670 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data671) ? csv_locator_inline_data671 : ""))) + return _t1278 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs660 = String[] - cond661 = match_lookahead_terminal(parser, "STRING", 0) - while cond661 - item662 = consume_terminal!(parser, "STRING") - push!(xs660, item662) - cond661 = match_lookahead_terminal(parser, "STRING", 0) + xs672 = String[] + cond673 = match_lookahead_terminal(parser, "STRING", 0) + while cond673 + item674 = consume_terminal!(parser, "STRING") + push!(xs672, item674) + cond673 = match_lookahead_terminal(parser, "STRING", 0) end - strings663 = xs660 + strings675 = xs672 consume_literal!(parser, ")") - return strings663 + return strings675 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - string664 = consume_terminal!(parser, "STRING") + string676 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string664 + return string676 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1255 = parse_config_dict(parser) - config_dict665 = _t1255 + _t1279 = parse_config_dict(parser) + config_dict677 = _t1279 consume_literal!(parser, ")") - _t1256 = construct_csv_config(parser, config_dict665) - return _t1256 + _t1280 = construct_csv_config(parser, config_dict677) + return _t1280 end function parse_csv_columns(parser::ParserState)::Vector{Proto.CSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs666 = Proto.CSVColumn[] - cond667 = match_lookahead_literal(parser, "(", 0) - while cond667 - _t1257 = parse_csv_column(parser) - item668 = _t1257 - push!(xs666, item668) - cond667 = match_lookahead_literal(parser, "(", 0) + xs678 = Proto.CSVColumn[] + cond679 = match_lookahead_literal(parser, "(", 0) + while cond679 + _t1281 = parse_csv_column(parser) + item680 = _t1281 + push!(xs678, item680) + cond679 = match_lookahead_literal(parser, "(", 0) end - csv_columns669 = xs666 + csv_columns681 = xs678 consume_literal!(parser, ")") - return csv_columns669 + return csv_columns681 end function parse_csv_column(parser::ParserState)::Proto.CSVColumn consume_literal!(parser, "(") consume_literal!(parser, "column") - string670 = consume_terminal!(parser, "STRING") - _t1258 = parse_relation_id(parser) - relation_id671 = _t1258 - consume_literal!(parser, "[") - xs672 = Proto.var"#Type"[] - cond673 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond673 - _t1259 = parse_type(parser) - item674 = _t1259 - push!(xs672, item674) - cond673 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + _t1282 = parse_csv_column_path(parser) + csv_column_path682 = _t1282 + if ((match_lookahead_literal(parser, ":", 0) || match_lookahead_literal(parser, "[", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1284 = parse_csv_column_tail(parser) + _t1283 = _t1284 + else + _t1283 = nothing end - types675 = xs672 - consume_literal!(parser, "]") + csv_column_tail683 = _t1283 consume_literal!(parser, ")") - _t1260 = Proto.CSVColumn(column_name=string670, target_id=relation_id671, types=types675) - return _t1260 + _t1285 = construct_csv_column(parser, csv_column_path682, csv_column_tail683) + return _t1285 +end + +function parse_csv_column_path(parser::ParserState)::Vector{String} + if match_lookahead_literal(parser, "[", 0) + _t1286 = 1 + else + if match_lookahead_terminal(parser, "STRING", 0) + _t1287 = 0 + else + _t1287 = -1 + end + _t1286 = _t1287 + end + prediction684 = _t1286 + if prediction684 == 1 + consume_literal!(parser, "[") + xs686 = String[] + cond687 = match_lookahead_terminal(parser, "STRING", 0) + while cond687 + item688 = consume_terminal!(parser, "STRING") + push!(xs686, item688) + cond687 = match_lookahead_terminal(parser, "STRING", 0) + end + strings689 = xs686 + consume_literal!(parser, "]") + _t1288 = strings689 + else + if prediction684 == 0 + string685 = consume_terminal!(parser, "STRING") + _t1289 = String[string685] + else + throw(ParseError("Unexpected token in csv_column_path" * ": " * string(lookahead(parser, 0)))) + end + _t1288 = _t1289 + end + return _t1288 +end + +function parse_csv_column_tail(parser::ParserState)::Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}} + if match_lookahead_literal(parser, "[", 0) + _t1290 = 1 + else + if match_lookahead_literal(parser, ":", 0) + _t1291 = 0 + else + if match_lookahead_terminal(parser, "UINT128", 0) + _t1292 = 0 + else + _t1292 = -1 + end + _t1291 = _t1292 + end + _t1290 = _t1291 + end + prediction690 = _t1290 + if prediction690 == 1 + consume_literal!(parser, "[") + xs696 = Proto.var"#Type"[] + cond697 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond697 + _t1294 = parse_type(parser) + item698 = _t1294 + push!(xs696, item698) + cond697 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types699 = xs696 + consume_literal!(parser, "]") + _t1293 = (nothing, types699,) + else + if prediction690 == 0 + _t1296 = parse_relation_id(parser) + relation_id691 = _t1296 + consume_literal!(parser, "[") + xs692 = Proto.var"#Type"[] + cond693 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond693 + _t1297 = parse_type(parser) + item694 = _t1297 + push!(xs692, item694) + cond693 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types695 = xs692 + consume_literal!(parser, "]") + _t1295 = (relation_id691, types695,) + else + throw(ParseError("Unexpected token in csv_column_tail" * ": " * string(lookahead(parser, 0)))) + end + _t1293 = _t1295 + end + return _t1293 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string676 = consume_terminal!(parser, "STRING") + string700 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string676 + return string700 end function parse_undefine(parser::ParserState)::Proto.Undefine consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t1261 = parse_fragment_id(parser) - fragment_id677 = _t1261 + _t1298 = parse_fragment_id(parser) + fragment_id701 = _t1298 consume_literal!(parser, ")") - _t1262 = Proto.Undefine(fragment_id=fragment_id677) - return _t1262 + _t1299 = Proto.Undefine(fragment_id=fragment_id701) + return _t1299 end function parse_context(parser::ParserState)::Proto.Context consume_literal!(parser, "(") consume_literal!(parser, "context") - xs678 = Proto.RelationId[] - cond679 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond679 - _t1263 = parse_relation_id(parser) - item680 = _t1263 - push!(xs678, item680) - cond679 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs702 = Proto.RelationId[] + cond703 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond703 + _t1300 = parse_relation_id(parser) + item704 = _t1300 + push!(xs702, item704) + cond703 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids681 = xs678 + relation_ids705 = xs702 consume_literal!(parser, ")") - _t1264 = Proto.Context(relations=relation_ids681) - return _t1264 + _t1301 = Proto.Context(relations=relation_ids705) + return _t1301 end function parse_snapshot(parser::ParserState)::Proto.Snapshot consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t1265 = parse_rel_edb_path(parser) - rel_edb_path682 = _t1265 - _t1266 = parse_relation_id(parser) - relation_id683 = _t1266 + _t1302 = parse_rel_edb_path(parser) + rel_edb_path706 = _t1302 + _t1303 = parse_relation_id(parser) + relation_id707 = _t1303 consume_literal!(parser, ")") - _t1267 = Proto.Snapshot(destination_path=rel_edb_path682, source_relation=relation_id683) - return _t1267 + _t1304 = Proto.Snapshot(destination_path=rel_edb_path706, source_relation=relation_id707) + return _t1304 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs684 = Proto.Read[] - cond685 = match_lookahead_literal(parser, "(", 0) - while cond685 - _t1268 = parse_read(parser) - item686 = _t1268 - push!(xs684, item686) - cond685 = match_lookahead_literal(parser, "(", 0) + xs708 = Proto.Read[] + cond709 = match_lookahead_literal(parser, "(", 0) + while cond709 + _t1305 = parse_read(parser) + item710 = _t1305 + push!(xs708, item710) + cond709 = match_lookahead_literal(parser, "(", 0) end - reads687 = xs684 + reads711 = xs708 consume_literal!(parser, ")") - return reads687 + return reads711 end function parse_read(parser::ParserState)::Proto.Read if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t1270 = 2 + _t1307 = 2 else if match_lookahead_literal(parser, "output", 1) - _t1271 = 1 + _t1308 = 1 else if match_lookahead_literal(parser, "export", 1) - _t1272 = 4 + _t1309 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t1273 = 0 + _t1310 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t1274 = 3 + _t1311 = 3 else - _t1274 = -1 + _t1311 = -1 end - _t1273 = _t1274 + _t1310 = _t1311 end - _t1272 = _t1273 + _t1309 = _t1310 end - _t1271 = _t1272 + _t1308 = _t1309 end - _t1270 = _t1271 + _t1307 = _t1308 end - _t1269 = _t1270 + _t1306 = _t1307 else - _t1269 = -1 - end - prediction688 = _t1269 - if prediction688 == 4 - _t1276 = parse_export(parser) - export693 = _t1276 - _t1277 = Proto.Read(read_type=OneOf(:var"#export", export693)) - _t1275 = _t1277 + _t1306 = -1 + end + prediction712 = _t1306 + if prediction712 == 4 + _t1313 = parse_export(parser) + export717 = _t1313 + _t1314 = Proto.Read(read_type=OneOf(:var"#export", export717)) + _t1312 = _t1314 else - if prediction688 == 3 - _t1279 = parse_abort(parser) - abort692 = _t1279 - _t1280 = Proto.Read(read_type=OneOf(:abort, abort692)) - _t1278 = _t1280 + if prediction712 == 3 + _t1316 = parse_abort(parser) + abort716 = _t1316 + _t1317 = Proto.Read(read_type=OneOf(:abort, abort716)) + _t1315 = _t1317 else - if prediction688 == 2 - _t1282 = parse_what_if(parser) - what_if691 = _t1282 - _t1283 = Proto.Read(read_type=OneOf(:what_if, what_if691)) - _t1281 = _t1283 + if prediction712 == 2 + _t1319 = parse_what_if(parser) + what_if715 = _t1319 + _t1320 = Proto.Read(read_type=OneOf(:what_if, what_if715)) + _t1318 = _t1320 else - if prediction688 == 1 - _t1285 = parse_output(parser) - output690 = _t1285 - _t1286 = Proto.Read(read_type=OneOf(:output, output690)) - _t1284 = _t1286 + if prediction712 == 1 + _t1322 = parse_output(parser) + output714 = _t1322 + _t1323 = Proto.Read(read_type=OneOf(:output, output714)) + _t1321 = _t1323 else - if prediction688 == 0 - _t1288 = parse_demand(parser) - demand689 = _t1288 - _t1289 = Proto.Read(read_type=OneOf(:demand, demand689)) - _t1287 = _t1289 + if prediction712 == 0 + _t1325 = parse_demand(parser) + demand713 = _t1325 + _t1326 = Proto.Read(read_type=OneOf(:demand, demand713)) + _t1324 = _t1326 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t1284 = _t1287 + _t1321 = _t1324 end - _t1281 = _t1284 + _t1318 = _t1321 end - _t1278 = _t1281 + _t1315 = _t1318 end - _t1275 = _t1278 + _t1312 = _t1315 end - return _t1275 + return _t1312 end function parse_demand(parser::ParserState)::Proto.Demand consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t1290 = parse_relation_id(parser) - relation_id694 = _t1290 + _t1327 = parse_relation_id(parser) + relation_id718 = _t1327 consume_literal!(parser, ")") - _t1291 = Proto.Demand(relation_id=relation_id694) - return _t1291 + _t1328 = Proto.Demand(relation_id=relation_id718) + return _t1328 end function parse_output(parser::ParserState)::Proto.Output consume_literal!(parser, "(") consume_literal!(parser, "output") - _t1292 = parse_name(parser) - name695 = _t1292 - _t1293 = parse_relation_id(parser) - relation_id696 = _t1293 + _t1329 = parse_name(parser) + name719 = _t1329 + _t1330 = parse_relation_id(parser) + relation_id720 = _t1330 consume_literal!(parser, ")") - _t1294 = Proto.Output(name=name695, relation_id=relation_id696) - return _t1294 + _t1331 = Proto.Output(name=name719, relation_id=relation_id720) + return _t1331 end function parse_what_if(parser::ParserState)::Proto.WhatIf consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t1295 = parse_name(parser) - name697 = _t1295 - _t1296 = parse_epoch(parser) - epoch698 = _t1296 + _t1332 = parse_name(parser) + name721 = _t1332 + _t1333 = parse_epoch(parser) + epoch722 = _t1333 consume_literal!(parser, ")") - _t1297 = Proto.WhatIf(branch=name697, epoch=epoch698) - return _t1297 + _t1334 = Proto.WhatIf(branch=name721, epoch=epoch722) + return _t1334 end function parse_abort(parser::ParserState)::Proto.Abort consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t1299 = parse_name(parser) - _t1298 = _t1299 + _t1336 = parse_name(parser) + _t1335 = _t1336 else - _t1298 = nothing + _t1335 = nothing end - name699 = _t1298 - _t1300 = parse_relation_id(parser) - relation_id700 = _t1300 + name723 = _t1335 + _t1337 = parse_relation_id(parser) + relation_id724 = _t1337 consume_literal!(parser, ")") - _t1301 = Proto.Abort(name=(!isnothing(name699) ? name699 : "abort"), relation_id=relation_id700) - return _t1301 + _t1338 = Proto.Abort(name=(!isnothing(name723) ? name723 : "abort"), relation_id=relation_id724) + return _t1338 end function parse_export(parser::ParserState)::Proto.Export consume_literal!(parser, "(") consume_literal!(parser, "export") - _t1302 = parse_export_csv_config(parser) - export_csv_config701 = _t1302 + _t1339 = parse_export_csv_config(parser) + export_csv_config725 = _t1339 consume_literal!(parser, ")") - _t1303 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config701)) - return _t1303 + _t1340 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config725)) + return _t1340 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t1304 = parse_export_csv_path(parser) - export_csv_path702 = _t1304 - _t1305 = parse_export_csv_columns(parser) - export_csv_columns703 = _t1305 - _t1306 = parse_config_dict(parser) - config_dict704 = _t1306 - consume_literal!(parser, ")") - _t1307 = export_csv_config(parser, export_csv_path702, export_csv_columns703, config_dict704) - return _t1307 + _t1341 = parse_export_csv_path(parser) + export_csv_path726 = _t1341 + _t1342 = parse_export_csv_columns(parser) + export_csv_columns727 = _t1342 + _t1343 = parse_config_dict(parser) + config_dict728 = _t1343 + consume_literal!(parser, ")") + _t1344 = export_csv_config(parser, export_csv_path726, export_csv_columns727, config_dict728) + return _t1344 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string705 = consume_terminal!(parser, "STRING") + string729 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string705 + return string729 end function parse_export_csv_columns(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs706 = Proto.ExportCSVColumn[] - cond707 = match_lookahead_literal(parser, "(", 0) - while cond707 - _t1308 = parse_export_csv_column(parser) - item708 = _t1308 - push!(xs706, item708) - cond707 = match_lookahead_literal(parser, "(", 0) + xs730 = Proto.ExportCSVColumn[] + cond731 = match_lookahead_literal(parser, "(", 0) + while cond731 + _t1345 = parse_export_csv_column(parser) + item732 = _t1345 + push!(xs730, item732) + cond731 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns709 = xs706 + export_csv_columns733 = xs730 consume_literal!(parser, ")") - return export_csv_columns709 + return export_csv_columns733 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn consume_literal!(parser, "(") consume_literal!(parser, "column") - string710 = consume_terminal!(parser, "STRING") - _t1309 = parse_relation_id(parser) - relation_id711 = _t1309 + string734 = consume_terminal!(parser, "STRING") + _t1346 = parse_relation_id(parser) + relation_id735 = _t1346 consume_literal!(parser, ")") - _t1310 = Proto.ExportCSVColumn(column_name=string710, column_data=relation_id711) - return _t1310 + _t1347 = Proto.ExportCSVColumn(column_name=string734, column_data=relation_id735) + return _t1347 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index de46a505..76fd7f5c 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -338,151 +338,160 @@ end # --- Helper functions --- function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1686 = Proto.Value(value=OneOf(:int_value, Int64(v))) - return _t1686 + _t1732 = Proto.Value(value=OneOf(:int_value, Int64(v))) + return _t1732 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1687 = Proto.Value(value=OneOf(:int_value, v)) - return _t1687 + _t1733 = Proto.Value(value=OneOf(:int_value, v)) + return _t1733 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1688 = Proto.Value(value=OneOf(:float_value, v)) - return _t1688 + _t1734 = Proto.Value(value=OneOf(:float_value, v)) + return _t1734 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1689 = Proto.Value(value=OneOf(:string_value, v)) - return _t1689 + _t1735 = Proto.Value(value=OneOf(:string_value, v)) + return _t1735 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1690 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1690 + _t1736 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1736 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1691 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1691 + _t1737 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1737 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 - _t1692 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1692,)) + _t1738 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1738,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1693 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1693,)) + _t1739 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1739,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1694 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1694,)) + _t1740 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1740,)) end end end - _t1695 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1695,)) + _t1741 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1741,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1696 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1696,)) - _t1697 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1697,)) + _t1742 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1742,)) + _t1743 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1743,)) if msg.new_line != "" - _t1698 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1698,)) - end - _t1699 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1699,)) - _t1700 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1700,)) - _t1701 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1701,)) + _t1744 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1744,)) + end + _t1745 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1745,)) + _t1746 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1746,)) + _t1747 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1747,)) if msg.comment != "" - _t1702 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1702,)) + _t1748 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1748,)) end for missing_string in msg.missing_strings - _t1703 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1703,)) - end - _t1704 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1704,)) - _t1705 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1705,)) - _t1706 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1706,)) + _t1749 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1749,)) + end + _t1750 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1750,)) + _t1751 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1751,)) + _t1752 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1752,)) return sort(result) end function deconstruct_betree_info_config(pp::PrettyPrinter, msg::Proto.BeTreeInfo)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1707 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1707,)) - _t1708 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1708,)) - _t1709 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1709,)) - _t1710 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1710,)) + _t1753 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1753,)) + _t1754 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1754,)) + _t1755 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1755,)) + _t1756 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1756,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1711 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1711,)) + _t1757 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1757,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1712 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1712,)) + _t1758 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1758,)) end end - _t1713 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1713,)) - _t1714 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1714,)) + _t1759 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1759,)) + _t1760 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1760,)) 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) - _t1715 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1715,)) + _t1761 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1761,)) end if !isnothing(msg.compression) - _t1716 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1716,)) + _t1762 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1762,)) end if !isnothing(msg.syntax_header_row) - _t1717 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1717,)) + _t1763 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1763,)) end if !isnothing(msg.syntax_missing_string) - _t1718 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1718,)) + _t1764 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1764,)) end if !isnothing(msg.syntax_delim) - _t1719 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1719,)) + _t1765 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1765,)) end if !isnothing(msg.syntax_quotechar) - _t1720 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1720,)) + _t1766 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1766,)) end if !isnothing(msg.syntax_escapechar) - _t1721 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1721,)) + _t1767 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1767,)) end return sort(result) end +function deconstruct_csv_column_tail(pp::PrettyPrinter, col::Proto.CSVColumn)::Union{Nothing, Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}} + if (_has_proto_field(col, Symbol("target_id")) || !isempty(col.types)) + return (col.target_id, col.types,) + else + _t1768 = nothing + end + return nothing +end + function deconstruct_relation_id_string(pp::PrettyPrinter, msg::Proto.RelationId)::String name = relation_id_to_string(pp, msg) return name @@ -493,7 +502,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1722 = nothing + _t1769 = nothing end return nothing end @@ -512,51 +521,51 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat638 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat638) - write(pp, flat638) + flat654 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat654) + write(pp, flat654) return nothing else - function _t1258(_dollar_dollar) + function _t1290(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1259 = _dollar_dollar.configure + _t1291 = _dollar_dollar.configure else - _t1259 = nothing + _t1291 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1260 = _dollar_dollar.sync + _t1292 = _dollar_dollar.sync else - _t1260 = nothing + _t1292 = nothing end - return (_t1259, _t1260, _dollar_dollar.epochs,) + return (_t1291, _t1292, _dollar_dollar.epochs,) end - _t1261 = _t1258(msg) - fields629 = _t1261 - unwrapped_fields630 = fields629 + _t1293 = _t1290(msg) + fields645 = _t1293 + unwrapped_fields646 = fields645 write(pp, "(") write(pp, "transaction") indent_sexp!(pp) - field631 = unwrapped_fields630[1] - if !isnothing(field631) + field647 = unwrapped_fields646[1] + if !isnothing(field647) newline(pp) - opt_val632 = field631 - pretty_configure(pp, opt_val632) + opt_val648 = field647 + pretty_configure(pp, opt_val648) end - field633 = unwrapped_fields630[2] - if !isnothing(field633) + field649 = unwrapped_fields646[2] + if !isnothing(field649) newline(pp) - opt_val634 = field633 - pretty_sync(pp, opt_val634) + opt_val650 = field649 + pretty_sync(pp, opt_val650) end - field635 = unwrapped_fields630[3] - if !isempty(field635) + field651 = unwrapped_fields646[3] + if !isempty(field651) newline(pp) - for (i1262, elem636) in enumerate(field635) - i637 = i1262 - 1 - if (i637 > 0) + for (i1294, elem652) in enumerate(field651) + i653 = i1294 - 1 + if (i653 > 0) newline(pp) end - pretty_epoch(pp, elem636) + pretty_epoch(pp, elem652) end end dedent!(pp) @@ -566,23 +575,23 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat641 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat641) - write(pp, flat641) + flat657 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat657) + write(pp, flat657) return nothing else - function _t1263(_dollar_dollar) - _t1264 = deconstruct_configure(pp, _dollar_dollar) - return _t1264 + function _t1295(_dollar_dollar) + _t1296 = deconstruct_configure(pp, _dollar_dollar) + return _t1296 end - _t1265 = _t1263(msg) - fields639 = _t1265 - unwrapped_fields640 = fields639 + _t1297 = _t1295(msg) + fields655 = _t1297 + unwrapped_fields656 = fields655 write(pp, "(") write(pp, "configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields640) + pretty_config_dict(pp, unwrapped_fields656) dedent!(pp) write(pp, ")") end @@ -590,22 +599,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat645 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat645) - write(pp, flat645) + flat661 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat661) + write(pp, flat661) return nothing else - fields642 = msg + fields658 = msg write(pp, "{") indent!(pp) - if !isempty(fields642) + if !isempty(fields658) newline(pp) - for (i1266, elem643) in enumerate(fields642) - i644 = i1266 - 1 - if (i644 > 0) + for (i1298, elem659) in enumerate(fields658) + i660 = i1298 - 1 + if (i660 > 0) newline(pp) end - pretty_config_key_value(pp, elem643) + pretty_config_key_value(pp, elem659) end end dedent!(pp) @@ -615,160 +624,160 @@ 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}) - flat650 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat650) - write(pp, flat650) + flat666 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat666) + write(pp, flat666) return nothing else - function _t1267(_dollar_dollar) + function _t1299(_dollar_dollar) return (_dollar_dollar[1], _dollar_dollar[2],) end - _t1268 = _t1267(msg) - fields646 = _t1268 - unwrapped_fields647 = fields646 + _t1300 = _t1299(msg) + fields662 = _t1300 + unwrapped_fields663 = fields662 write(pp, ":") - field648 = unwrapped_fields647[1] - write(pp, field648) + field664 = unwrapped_fields663[1] + write(pp, field664) write(pp, " ") - field649 = unwrapped_fields647[2] - pretty_value(pp, field649) + field665 = unwrapped_fields663[2] + pretty_value(pp, field665) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat670 = try_flat(pp, msg, pretty_value) - if !isnothing(flat670) - write(pp, flat670) + flat686 = try_flat(pp, msg, pretty_value) + if !isnothing(flat686) + write(pp, flat686) return nothing else - function _t1269(_dollar_dollar) + function _t1301(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1270 = _get_oneof_field(_dollar_dollar, :date_value) + _t1302 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1270 = nothing + _t1302 = nothing end - return _t1270 + return _t1302 end - _t1271 = _t1269(msg) - deconstruct_result668 = _t1271 - if !isnothing(deconstruct_result668) - unwrapped669 = deconstruct_result668 - pretty_date(pp, unwrapped669) + _t1303 = _t1301(msg) + deconstruct_result684 = _t1303 + if !isnothing(deconstruct_result684) + unwrapped685 = deconstruct_result684 + pretty_date(pp, unwrapped685) else - function _t1272(_dollar_dollar) + function _t1304(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1273 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1305 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1273 = nothing + _t1305 = nothing end - return _t1273 + return _t1305 end - _t1274 = _t1272(msg) - deconstruct_result666 = _t1274 - if !isnothing(deconstruct_result666) - unwrapped667 = deconstruct_result666 - pretty_datetime(pp, unwrapped667) + _t1306 = _t1304(msg) + deconstruct_result682 = _t1306 + if !isnothing(deconstruct_result682) + unwrapped683 = deconstruct_result682 + pretty_datetime(pp, unwrapped683) else - function _t1275(_dollar_dollar) + function _t1307(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1276 = _get_oneof_field(_dollar_dollar, :string_value) + _t1308 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1276 = nothing + _t1308 = nothing end - return _t1276 + return _t1308 end - _t1277 = _t1275(msg) - deconstruct_result664 = _t1277 - if !isnothing(deconstruct_result664) - unwrapped665 = deconstruct_result664 - write(pp, format_string(pp, unwrapped665)) + _t1309 = _t1307(msg) + deconstruct_result680 = _t1309 + if !isnothing(deconstruct_result680) + unwrapped681 = deconstruct_result680 + write(pp, format_string(pp, unwrapped681)) else - function _t1278(_dollar_dollar) + function _t1310(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1279 = _get_oneof_field(_dollar_dollar, :int_value) + _t1311 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1279 = nothing + _t1311 = nothing end - return _t1279 + return _t1311 end - _t1280 = _t1278(msg) - deconstruct_result662 = _t1280 - if !isnothing(deconstruct_result662) - unwrapped663 = deconstruct_result662 - write(pp, format_int(pp, unwrapped663)) + _t1312 = _t1310(msg) + deconstruct_result678 = _t1312 + if !isnothing(deconstruct_result678) + unwrapped679 = deconstruct_result678 + write(pp, format_int(pp, unwrapped679)) else - function _t1281(_dollar_dollar) + function _t1313(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1282 = _get_oneof_field(_dollar_dollar, :float_value) + _t1314 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1282 = nothing + _t1314 = nothing end - return _t1282 + return _t1314 end - _t1283 = _t1281(msg) - deconstruct_result660 = _t1283 - if !isnothing(deconstruct_result660) - unwrapped661 = deconstruct_result660 - write(pp, format_float(pp, unwrapped661)) + _t1315 = _t1313(msg) + deconstruct_result676 = _t1315 + if !isnothing(deconstruct_result676) + unwrapped677 = deconstruct_result676 + write(pp, format_float(pp, unwrapped677)) else - function _t1284(_dollar_dollar) + function _t1316(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1285 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1317 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1285 = nothing + _t1317 = nothing end - return _t1285 + return _t1317 end - _t1286 = _t1284(msg) - deconstruct_result658 = _t1286 - if !isnothing(deconstruct_result658) - unwrapped659 = deconstruct_result658 - write(pp, format_uint128(pp, unwrapped659)) + _t1318 = _t1316(msg) + deconstruct_result674 = _t1318 + if !isnothing(deconstruct_result674) + unwrapped675 = deconstruct_result674 + write(pp, format_uint128(pp, unwrapped675)) else - function _t1287(_dollar_dollar) + function _t1319(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1288 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1320 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1288 = nothing + _t1320 = nothing end - return _t1288 + return _t1320 end - _t1289 = _t1287(msg) - deconstruct_result656 = _t1289 - if !isnothing(deconstruct_result656) - unwrapped657 = deconstruct_result656 - write(pp, format_int128(pp, unwrapped657)) + _t1321 = _t1319(msg) + deconstruct_result672 = _t1321 + if !isnothing(deconstruct_result672) + unwrapped673 = deconstruct_result672 + write(pp, format_int128(pp, unwrapped673)) else - function _t1290(_dollar_dollar) + function _t1322(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1291 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1323 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1291 = nothing + _t1323 = nothing end - return _t1291 + return _t1323 end - _t1292 = _t1290(msg) - deconstruct_result654 = _t1292 - if !isnothing(deconstruct_result654) - unwrapped655 = deconstruct_result654 - write(pp, format_decimal(pp, unwrapped655)) + _t1324 = _t1322(msg) + deconstruct_result670 = _t1324 + if !isnothing(deconstruct_result670) + unwrapped671 = deconstruct_result670 + write(pp, format_decimal(pp, unwrapped671)) else - function _t1293(_dollar_dollar) + function _t1325(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1294 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1326 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1294 = nothing + _t1326 = nothing end - return _t1294 + return _t1326 end - _t1295 = _t1293(msg) - deconstruct_result652 = _t1295 - if !isnothing(deconstruct_result652) - unwrapped653 = deconstruct_result652 - pretty_boolean_value(pp, unwrapped653) + _t1327 = _t1325(msg) + deconstruct_result668 = _t1327 + if !isnothing(deconstruct_result668) + unwrapped669 = deconstruct_result668 + pretty_boolean_value(pp, unwrapped669) else - fields651 = msg + fields667 = msg write(pp, "missing") end end @@ -784,29 +793,29 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat676 = try_flat(pp, msg, pretty_date) - if !isnothing(flat676) - write(pp, flat676) + flat692 = try_flat(pp, msg, pretty_date) + if !isnothing(flat692) + write(pp, flat692) return nothing else - function _t1296(_dollar_dollar) + function _t1328(_dollar_dollar) return (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) end - _t1297 = _t1296(msg) - fields671 = _t1297 - unwrapped_fields672 = fields671 + _t1329 = _t1328(msg) + fields687 = _t1329 + unwrapped_fields688 = fields687 write(pp, "(") write(pp, "date") indent_sexp!(pp) newline(pp) - field673 = unwrapped_fields672[1] - write(pp, format_int(pp, field673)) + field689 = unwrapped_fields688[1] + write(pp, format_int(pp, field689)) newline(pp) - field674 = unwrapped_fields672[2] - write(pp, format_int(pp, field674)) + field690 = unwrapped_fields688[2] + write(pp, format_int(pp, field690)) newline(pp) - field675 = unwrapped_fields672[3] - write(pp, format_int(pp, field675)) + field691 = unwrapped_fields688[3] + write(pp, format_int(pp, field691)) dedent!(pp) write(pp, ")") end @@ -814,43 +823,43 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat687 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat687) - write(pp, flat687) + flat703 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat703) + write(pp, flat703) return nothing else - function _t1298(_dollar_dollar) + function _t1330(_dollar_dollar) return (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),) end - _t1299 = _t1298(msg) - fields677 = _t1299 - unwrapped_fields678 = fields677 + _t1331 = _t1330(msg) + fields693 = _t1331 + unwrapped_fields694 = fields693 write(pp, "(") write(pp, "datetime") indent_sexp!(pp) newline(pp) - field679 = unwrapped_fields678[1] - write(pp, format_int(pp, field679)) + field695 = unwrapped_fields694[1] + write(pp, format_int(pp, field695)) newline(pp) - field680 = unwrapped_fields678[2] - write(pp, format_int(pp, field680)) + field696 = unwrapped_fields694[2] + write(pp, format_int(pp, field696)) newline(pp) - field681 = unwrapped_fields678[3] - write(pp, format_int(pp, field681)) + field697 = unwrapped_fields694[3] + write(pp, format_int(pp, field697)) newline(pp) - field682 = unwrapped_fields678[4] - write(pp, format_int(pp, field682)) + field698 = unwrapped_fields694[4] + write(pp, format_int(pp, field698)) newline(pp) - field683 = unwrapped_fields678[5] - write(pp, format_int(pp, field683)) + field699 = unwrapped_fields694[5] + write(pp, format_int(pp, field699)) newline(pp) - field684 = unwrapped_fields678[6] - write(pp, format_int(pp, field684)) - field685 = unwrapped_fields678[7] - if !isnothing(field685) + field700 = unwrapped_fields694[6] + write(pp, format_int(pp, field700)) + field701 = unwrapped_fields694[7] + if !isnothing(field701) newline(pp) - opt_val686 = field685 - write(pp, format_int(pp, opt_val686)) + opt_val702 = field701 + write(pp, format_int(pp, opt_val702)) end dedent!(pp) write(pp, ")") @@ -859,32 +868,32 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) - function _t1300(_dollar_dollar) + function _t1332(_dollar_dollar) if _dollar_dollar - _t1301 = () + _t1333 = () else - _t1301 = nothing + _t1333 = nothing end - return _t1301 + return _t1333 end - _t1302 = _t1300(msg) - deconstruct_result690 = _t1302 - if !isnothing(deconstruct_result690) - unwrapped691 = deconstruct_result690 + _t1334 = _t1332(msg) + deconstruct_result706 = _t1334 + if !isnothing(deconstruct_result706) + unwrapped707 = deconstruct_result706 write(pp, "true") else - function _t1303(_dollar_dollar) + function _t1335(_dollar_dollar) if !_dollar_dollar - _t1304 = () + _t1336 = () else - _t1304 = nothing + _t1336 = nothing end - return _t1304 + return _t1336 end - _t1305 = _t1303(msg) - deconstruct_result688 = _t1305 - if !isnothing(deconstruct_result688) - unwrapped689 = deconstruct_result688 + _t1337 = _t1335(msg) + deconstruct_result704 = _t1337 + if !isnothing(deconstruct_result704) + unwrapped705 = deconstruct_result704 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -894,28 +903,28 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat696 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat696) - write(pp, flat696) + flat712 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat712) + write(pp, flat712) return nothing else - function _t1306(_dollar_dollar) + function _t1338(_dollar_dollar) return _dollar_dollar.fragments end - _t1307 = _t1306(msg) - fields692 = _t1307 - unwrapped_fields693 = fields692 + _t1339 = _t1338(msg) + fields708 = _t1339 + unwrapped_fields709 = fields708 write(pp, "(") write(pp, "sync") indent_sexp!(pp) - if !isempty(unwrapped_fields693) + if !isempty(unwrapped_fields709) newline(pp) - for (i1308, elem694) in enumerate(unwrapped_fields693) - i695 = i1308 - 1 - if (i695 > 0) + for (i1340, elem710) in enumerate(unwrapped_fields709) + i711 = i1340 - 1 + if (i711 > 0) newline(pp) end - pretty_fragment_id(pp, elem694) + pretty_fragment_id(pp, elem710) end end dedent!(pp) @@ -925,59 +934,59 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat699 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat699) - write(pp, flat699) + flat715 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat715) + write(pp, flat715) return nothing else - function _t1309(_dollar_dollar) + function _t1341(_dollar_dollar) return fragment_id_to_string(pp, _dollar_dollar) end - _t1310 = _t1309(msg) - fields697 = _t1310 - unwrapped_fields698 = fields697 + _t1342 = _t1341(msg) + fields713 = _t1342 + unwrapped_fields714 = fields713 write(pp, ":") - write(pp, unwrapped_fields698) + write(pp, unwrapped_fields714) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat706 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat706) - write(pp, flat706) + flat722 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat722) + write(pp, flat722) return nothing else - function _t1311(_dollar_dollar) + function _t1343(_dollar_dollar) if !isempty(_dollar_dollar.writes) - _t1312 = _dollar_dollar.writes + _t1344 = _dollar_dollar.writes else - _t1312 = nothing + _t1344 = nothing end if !isempty(_dollar_dollar.reads) - _t1313 = _dollar_dollar.reads + _t1345 = _dollar_dollar.reads else - _t1313 = nothing + _t1345 = nothing end - return (_t1312, _t1313,) + return (_t1344, _t1345,) end - _t1314 = _t1311(msg) - fields700 = _t1314 - unwrapped_fields701 = fields700 + _t1346 = _t1343(msg) + fields716 = _t1346 + unwrapped_fields717 = fields716 write(pp, "(") write(pp, "epoch") indent_sexp!(pp) - field702 = unwrapped_fields701[1] - if !isnothing(field702) + field718 = unwrapped_fields717[1] + if !isnothing(field718) newline(pp) - opt_val703 = field702 - pretty_epoch_writes(pp, opt_val703) + opt_val719 = field718 + pretty_epoch_writes(pp, opt_val719) end - field704 = unwrapped_fields701[2] - if !isnothing(field704) + field720 = unwrapped_fields717[2] + if !isnothing(field720) newline(pp) - opt_val705 = field704 - pretty_epoch_reads(pp, opt_val705) + opt_val721 = field720 + pretty_epoch_reads(pp, opt_val721) end dedent!(pp) write(pp, ")") @@ -986,23 +995,23 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat710 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat710) - write(pp, flat710) + flat726 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat726) + write(pp, flat726) return nothing else - fields707 = msg + fields723 = msg write(pp, "(") write(pp, "writes") indent_sexp!(pp) - if !isempty(fields707) + if !isempty(fields723) newline(pp) - for (i1315, elem708) in enumerate(fields707) - i709 = i1315 - 1 - if (i709 > 0) + for (i1347, elem724) in enumerate(fields723) + i725 = i1347 - 1 + if (i725 > 0) newline(pp) end - pretty_write(pp, elem708) + pretty_write(pp, elem724) end end dedent!(pp) @@ -1012,66 +1021,66 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat719 = try_flat(pp, msg, pretty_write) - if !isnothing(flat719) - write(pp, flat719) + flat735 = try_flat(pp, msg, pretty_write) + if !isnothing(flat735) + write(pp, flat735) return nothing else - function _t1316(_dollar_dollar) + function _t1348(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1317 = _get_oneof_field(_dollar_dollar, :define) + _t1349 = _get_oneof_field(_dollar_dollar, :define) else - _t1317 = nothing + _t1349 = nothing end - return _t1317 + return _t1349 end - _t1318 = _t1316(msg) - deconstruct_result717 = _t1318 - if !isnothing(deconstruct_result717) - unwrapped718 = deconstruct_result717 - pretty_define(pp, unwrapped718) + _t1350 = _t1348(msg) + deconstruct_result733 = _t1350 + if !isnothing(deconstruct_result733) + unwrapped734 = deconstruct_result733 + pretty_define(pp, unwrapped734) else - function _t1319(_dollar_dollar) + function _t1351(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1320 = _get_oneof_field(_dollar_dollar, :undefine) + _t1352 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1320 = nothing + _t1352 = nothing end - return _t1320 + return _t1352 end - _t1321 = _t1319(msg) - deconstruct_result715 = _t1321 - if !isnothing(deconstruct_result715) - unwrapped716 = deconstruct_result715 - pretty_undefine(pp, unwrapped716) + _t1353 = _t1351(msg) + deconstruct_result731 = _t1353 + if !isnothing(deconstruct_result731) + unwrapped732 = deconstruct_result731 + pretty_undefine(pp, unwrapped732) else - function _t1322(_dollar_dollar) + function _t1354(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1323 = _get_oneof_field(_dollar_dollar, :context) + _t1355 = _get_oneof_field(_dollar_dollar, :context) else - _t1323 = nothing + _t1355 = nothing end - return _t1323 + return _t1355 end - _t1324 = _t1322(msg) - deconstruct_result713 = _t1324 - if !isnothing(deconstruct_result713) - unwrapped714 = deconstruct_result713 - pretty_context(pp, unwrapped714) + _t1356 = _t1354(msg) + deconstruct_result729 = _t1356 + if !isnothing(deconstruct_result729) + unwrapped730 = deconstruct_result729 + pretty_context(pp, unwrapped730) else - function _t1325(_dollar_dollar) + function _t1357(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1326 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1358 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1326 = nothing + _t1358 = nothing end - return _t1326 + return _t1358 end - _t1327 = _t1325(msg) - deconstruct_result711 = _t1327 - if !isnothing(deconstruct_result711) - unwrapped712 = deconstruct_result711 - pretty_snapshot(pp, unwrapped712) + _t1359 = _t1357(msg) + deconstruct_result727 = _t1359 + if !isnothing(deconstruct_result727) + unwrapped728 = deconstruct_result727 + pretty_snapshot(pp, unwrapped728) else throw(ParseError("No matching rule for write")) end @@ -1083,22 +1092,22 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat722 = try_flat(pp, msg, pretty_define) - if !isnothing(flat722) - write(pp, flat722) + flat738 = try_flat(pp, msg, pretty_define) + if !isnothing(flat738) + write(pp, flat738) return nothing else - function _t1328(_dollar_dollar) + function _t1360(_dollar_dollar) return _dollar_dollar.fragment end - _t1329 = _t1328(msg) - fields720 = _t1329 - unwrapped_fields721 = fields720 + _t1361 = _t1360(msg) + fields736 = _t1361 + unwrapped_fields737 = fields736 write(pp, "(") write(pp, "define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields721) + pretty_fragment(pp, unwrapped_fields737) dedent!(pp) write(pp, ")") end @@ -1106,33 +1115,33 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat729 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat729) - write(pp, flat729) + flat745 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat745) + write(pp, flat745) return nothing else - function _t1330(_dollar_dollar) + function _t1362(_dollar_dollar) start_pretty_fragment(pp, _dollar_dollar) return (_dollar_dollar.id, _dollar_dollar.declarations,) end - _t1331 = _t1330(msg) - fields723 = _t1331 - unwrapped_fields724 = fields723 + _t1363 = _t1362(msg) + fields739 = _t1363 + unwrapped_fields740 = fields739 write(pp, "(") write(pp, "fragment") indent_sexp!(pp) newline(pp) - field725 = unwrapped_fields724[1] - pretty_new_fragment_id(pp, field725) - field726 = unwrapped_fields724[2] - if !isempty(field726) + field741 = unwrapped_fields740[1] + pretty_new_fragment_id(pp, field741) + field742 = unwrapped_fields740[2] + if !isempty(field742) newline(pp) - for (i1332, elem727) in enumerate(field726) - i728 = i1332 - 1 - if (i728 > 0) + for (i1364, elem743) in enumerate(field742) + i744 = i1364 - 1 + if (i744 > 0) newline(pp) end - pretty_declaration(pp, elem727) + pretty_declaration(pp, elem743) end end dedent!(pp) @@ -1142,78 +1151,78 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat731 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat731) - write(pp, flat731) + flat747 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat747) + write(pp, flat747) return nothing else - fields730 = msg - pretty_fragment_id(pp, fields730) + fields746 = msg + pretty_fragment_id(pp, fields746) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat740 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat740) - write(pp, flat740) + flat756 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat756) + write(pp, flat756) return nothing else - function _t1333(_dollar_dollar) + function _t1365(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1334 = _get_oneof_field(_dollar_dollar, :def) + _t1366 = _get_oneof_field(_dollar_dollar, :def) else - _t1334 = nothing + _t1366 = nothing end - return _t1334 + return _t1366 end - _t1335 = _t1333(msg) - deconstruct_result738 = _t1335 - if !isnothing(deconstruct_result738) - unwrapped739 = deconstruct_result738 - pretty_def(pp, unwrapped739) + _t1367 = _t1365(msg) + deconstruct_result754 = _t1367 + if !isnothing(deconstruct_result754) + unwrapped755 = deconstruct_result754 + pretty_def(pp, unwrapped755) else - function _t1336(_dollar_dollar) + function _t1368(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1337 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1369 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1337 = nothing + _t1369 = nothing end - return _t1337 + return _t1369 end - _t1338 = _t1336(msg) - deconstruct_result736 = _t1338 - if !isnothing(deconstruct_result736) - unwrapped737 = deconstruct_result736 - pretty_algorithm(pp, unwrapped737) + _t1370 = _t1368(msg) + deconstruct_result752 = _t1370 + if !isnothing(deconstruct_result752) + unwrapped753 = deconstruct_result752 + pretty_algorithm(pp, unwrapped753) else - function _t1339(_dollar_dollar) + function _t1371(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1340 = _get_oneof_field(_dollar_dollar, :constraint) + _t1372 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1340 = nothing + _t1372 = nothing end - return _t1340 + return _t1372 end - _t1341 = _t1339(msg) - deconstruct_result734 = _t1341 - if !isnothing(deconstruct_result734) - unwrapped735 = deconstruct_result734 - pretty_constraint(pp, unwrapped735) + _t1373 = _t1371(msg) + deconstruct_result750 = _t1373 + if !isnothing(deconstruct_result750) + unwrapped751 = deconstruct_result750 + pretty_constraint(pp, unwrapped751) else - function _t1342(_dollar_dollar) + function _t1374(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1343 = _get_oneof_field(_dollar_dollar, :data) + _t1375 = _get_oneof_field(_dollar_dollar, :data) else - _t1343 = nothing + _t1375 = nothing end - return _t1343 + return _t1375 end - _t1344 = _t1342(msg) - deconstruct_result732 = _t1344 - if !isnothing(deconstruct_result732) - unwrapped733 = deconstruct_result732 - pretty_data(pp, unwrapped733) + _t1376 = _t1374(msg) + deconstruct_result748 = _t1376 + if !isnothing(deconstruct_result748) + unwrapped749 = deconstruct_result748 + pretty_data(pp, unwrapped749) else throw(ParseError("No matching rule for declaration")) end @@ -1225,36 +1234,36 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat747 = try_flat(pp, msg, pretty_def) - if !isnothing(flat747) - write(pp, flat747) + flat763 = try_flat(pp, msg, pretty_def) + if !isnothing(flat763) + write(pp, flat763) return nothing else - function _t1345(_dollar_dollar) + function _t1377(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1346 = _dollar_dollar.attrs + _t1378 = _dollar_dollar.attrs else - _t1346 = nothing + _t1378 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1346,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1378,) end - _t1347 = _t1345(msg) - fields741 = _t1347 - unwrapped_fields742 = fields741 + _t1379 = _t1377(msg) + fields757 = _t1379 + unwrapped_fields758 = fields757 write(pp, "(") write(pp, "def") indent_sexp!(pp) newline(pp) - field743 = unwrapped_fields742[1] - pretty_relation_id(pp, field743) + field759 = unwrapped_fields758[1] + pretty_relation_id(pp, field759) newline(pp) - field744 = unwrapped_fields742[2] - pretty_abstraction(pp, field744) - field745 = unwrapped_fields742[3] - if !isnothing(field745) + field760 = unwrapped_fields758[2] + pretty_abstraction(pp, field760) + field761 = unwrapped_fields758[3] + if !isnothing(field761) newline(pp) - opt_val746 = field745 - pretty_attrs(pp, opt_val746) + opt_val762 = field761 + pretty_attrs(pp, opt_val762) end dedent!(pp) write(pp, ")") @@ -1263,36 +1272,36 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat752 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat752) - write(pp, flat752) + flat768 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat768) + write(pp, flat768) return nothing else - function _t1348(_dollar_dollar) + function _t1380(_dollar_dollar) if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1350 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1349 = _t1350 + _t1382 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1381 = _t1382 else - _t1349 = nothing + _t1381 = nothing end - return _t1349 + return _t1381 end - _t1351 = _t1348(msg) - deconstruct_result750 = _t1351 - if !isnothing(deconstruct_result750) - unwrapped751 = deconstruct_result750 + _t1383 = _t1380(msg) + deconstruct_result766 = _t1383 + if !isnothing(deconstruct_result766) + unwrapped767 = deconstruct_result766 write(pp, ":") - write(pp, unwrapped751) + write(pp, unwrapped767) else - function _t1352(_dollar_dollar) - _t1353 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - return _t1353 + function _t1384(_dollar_dollar) + _t1385 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + return _t1385 end - _t1354 = _t1352(msg) - deconstruct_result748 = _t1354 - if !isnothing(deconstruct_result748) - unwrapped749 = deconstruct_result748 - write(pp, format_uint128(pp, unwrapped749)) + _t1386 = _t1384(msg) + deconstruct_result764 = _t1386 + if !isnothing(deconstruct_result764) + unwrapped765 = deconstruct_result764 + write(pp, format_uint128(pp, unwrapped765)) else throw(ParseError("No matching rule for relation_id")) end @@ -1302,25 +1311,25 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat757 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat757) - write(pp, flat757) + flat773 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat773) + write(pp, flat773) return nothing else - function _t1355(_dollar_dollar) - _t1356 = deconstruct_bindings(pp, _dollar_dollar) - return (_t1356, _dollar_dollar.value,) + function _t1387(_dollar_dollar) + _t1388 = deconstruct_bindings(pp, _dollar_dollar) + return (_t1388, _dollar_dollar.value,) end - _t1357 = _t1355(msg) - fields753 = _t1357 - unwrapped_fields754 = fields753 + _t1389 = _t1387(msg) + fields769 = _t1389 + unwrapped_fields770 = fields769 write(pp, "(") indent!(pp) - field755 = unwrapped_fields754[1] - pretty_bindings(pp, field755) + field771 = unwrapped_fields770[1] + pretty_bindings(pp, field771) newline(pp) - field756 = unwrapped_fields754[2] - pretty_formula(pp, field756) + field772 = unwrapped_fields770[2] + pretty_formula(pp, field772) dedent!(pp) write(pp, ")") end @@ -1328,37 +1337,37 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat765 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat765) - write(pp, flat765) + flat781 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat781) + write(pp, flat781) return nothing else - function _t1358(_dollar_dollar) + function _t1390(_dollar_dollar) if !isempty(_dollar_dollar[2]) - _t1359 = _dollar_dollar[2] + _t1391 = _dollar_dollar[2] else - _t1359 = nothing + _t1391 = nothing end - return (_dollar_dollar[1], _t1359,) + return (_dollar_dollar[1], _t1391,) end - _t1360 = _t1358(msg) - fields758 = _t1360 - unwrapped_fields759 = fields758 + _t1392 = _t1390(msg) + fields774 = _t1392 + unwrapped_fields775 = fields774 write(pp, "[") indent!(pp) - field760 = unwrapped_fields759[1] - for (i1361, elem761) in enumerate(field760) - i762 = i1361 - 1 - if (i762 > 0) + field776 = unwrapped_fields775[1] + for (i1393, elem777) in enumerate(field776) + i778 = i1393 - 1 + if (i778 > 0) newline(pp) end - pretty_binding(pp, elem761) + pretty_binding(pp, elem777) end - field763 = unwrapped_fields759[2] - if !isnothing(field763) + field779 = unwrapped_fields775[2] + if !isnothing(field779) newline(pp) - opt_val764 = field763 - pretty_value_bindings(pp, opt_val764) + opt_val780 = field779 + pretty_value_bindings(pp, opt_val780) end dedent!(pp) write(pp, "]") @@ -1367,185 +1376,185 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat770 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat770) - write(pp, flat770) + flat786 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat786) + write(pp, flat786) return nothing else - function _t1362(_dollar_dollar) + function _t1394(_dollar_dollar) return (_dollar_dollar.var.name, _dollar_dollar.var"#type",) end - _t1363 = _t1362(msg) - fields766 = _t1363 - unwrapped_fields767 = fields766 - field768 = unwrapped_fields767[1] - write(pp, field768) + _t1395 = _t1394(msg) + fields782 = _t1395 + unwrapped_fields783 = fields782 + field784 = unwrapped_fields783[1] + write(pp, field784) write(pp, "::") - field769 = unwrapped_fields767[2] - pretty_type(pp, field769) + field785 = unwrapped_fields783[2] + pretty_type(pp, field785) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat793 = try_flat(pp, msg, pretty_type) - if !isnothing(flat793) - write(pp, flat793) + flat809 = try_flat(pp, msg, pretty_type) + if !isnothing(flat809) + write(pp, flat809) return nothing else - function _t1364(_dollar_dollar) + function _t1396(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1365 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1397 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1365 = nothing + _t1397 = nothing end - return _t1365 + return _t1397 end - _t1366 = _t1364(msg) - deconstruct_result791 = _t1366 - if !isnothing(deconstruct_result791) - unwrapped792 = deconstruct_result791 - pretty_unspecified_type(pp, unwrapped792) + _t1398 = _t1396(msg) + deconstruct_result807 = _t1398 + if !isnothing(deconstruct_result807) + unwrapped808 = deconstruct_result807 + pretty_unspecified_type(pp, unwrapped808) else - function _t1367(_dollar_dollar) + function _t1399(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1368 = _get_oneof_field(_dollar_dollar, :string_type) + _t1400 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1368 = nothing + _t1400 = nothing end - return _t1368 + return _t1400 end - _t1369 = _t1367(msg) - deconstruct_result789 = _t1369 - if !isnothing(deconstruct_result789) - unwrapped790 = deconstruct_result789 - pretty_string_type(pp, unwrapped790) + _t1401 = _t1399(msg) + deconstruct_result805 = _t1401 + if !isnothing(deconstruct_result805) + unwrapped806 = deconstruct_result805 + pretty_string_type(pp, unwrapped806) else - function _t1370(_dollar_dollar) + function _t1402(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1371 = _get_oneof_field(_dollar_dollar, :int_type) + _t1403 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1371 = nothing + _t1403 = nothing end - return _t1371 + return _t1403 end - _t1372 = _t1370(msg) - deconstruct_result787 = _t1372 - if !isnothing(deconstruct_result787) - unwrapped788 = deconstruct_result787 - pretty_int_type(pp, unwrapped788) + _t1404 = _t1402(msg) + deconstruct_result803 = _t1404 + if !isnothing(deconstruct_result803) + unwrapped804 = deconstruct_result803 + pretty_int_type(pp, unwrapped804) else - function _t1373(_dollar_dollar) + function _t1405(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1374 = _get_oneof_field(_dollar_dollar, :float_type) + _t1406 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1374 = nothing + _t1406 = nothing end - return _t1374 + return _t1406 end - _t1375 = _t1373(msg) - deconstruct_result785 = _t1375 - if !isnothing(deconstruct_result785) - unwrapped786 = deconstruct_result785 - pretty_float_type(pp, unwrapped786) + _t1407 = _t1405(msg) + deconstruct_result801 = _t1407 + if !isnothing(deconstruct_result801) + unwrapped802 = deconstruct_result801 + pretty_float_type(pp, unwrapped802) else - function _t1376(_dollar_dollar) + function _t1408(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1377 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1409 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1377 = nothing + _t1409 = nothing end - return _t1377 + return _t1409 end - _t1378 = _t1376(msg) - deconstruct_result783 = _t1378 - if !isnothing(deconstruct_result783) - unwrapped784 = deconstruct_result783 - pretty_uint128_type(pp, unwrapped784) + _t1410 = _t1408(msg) + deconstruct_result799 = _t1410 + if !isnothing(deconstruct_result799) + unwrapped800 = deconstruct_result799 + pretty_uint128_type(pp, unwrapped800) else - function _t1379(_dollar_dollar) + function _t1411(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1380 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1412 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1380 = nothing + _t1412 = nothing end - return _t1380 + return _t1412 end - _t1381 = _t1379(msg) - deconstruct_result781 = _t1381 - if !isnothing(deconstruct_result781) - unwrapped782 = deconstruct_result781 - pretty_int128_type(pp, unwrapped782) + _t1413 = _t1411(msg) + deconstruct_result797 = _t1413 + if !isnothing(deconstruct_result797) + unwrapped798 = deconstruct_result797 + pretty_int128_type(pp, unwrapped798) else - function _t1382(_dollar_dollar) + function _t1414(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1383 = _get_oneof_field(_dollar_dollar, :date_type) + _t1415 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1383 = nothing + _t1415 = nothing end - return _t1383 + return _t1415 end - _t1384 = _t1382(msg) - deconstruct_result779 = _t1384 - if !isnothing(deconstruct_result779) - unwrapped780 = deconstruct_result779 - pretty_date_type(pp, unwrapped780) + _t1416 = _t1414(msg) + deconstruct_result795 = _t1416 + if !isnothing(deconstruct_result795) + unwrapped796 = deconstruct_result795 + pretty_date_type(pp, unwrapped796) else - function _t1385(_dollar_dollar) + function _t1417(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1386 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1418 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1386 = nothing + _t1418 = nothing end - return _t1386 + return _t1418 end - _t1387 = _t1385(msg) - deconstruct_result777 = _t1387 - if !isnothing(deconstruct_result777) - unwrapped778 = deconstruct_result777 - pretty_datetime_type(pp, unwrapped778) + _t1419 = _t1417(msg) + deconstruct_result793 = _t1419 + if !isnothing(deconstruct_result793) + unwrapped794 = deconstruct_result793 + pretty_datetime_type(pp, unwrapped794) else - function _t1388(_dollar_dollar) + function _t1420(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1389 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1421 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1389 = nothing + _t1421 = nothing end - return _t1389 + return _t1421 end - _t1390 = _t1388(msg) - deconstruct_result775 = _t1390 - if !isnothing(deconstruct_result775) - unwrapped776 = deconstruct_result775 - pretty_missing_type(pp, unwrapped776) + _t1422 = _t1420(msg) + deconstruct_result791 = _t1422 + if !isnothing(deconstruct_result791) + unwrapped792 = deconstruct_result791 + pretty_missing_type(pp, unwrapped792) else - function _t1391(_dollar_dollar) + function _t1423(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1392 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1424 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1392 = nothing + _t1424 = nothing end - return _t1392 + return _t1424 end - _t1393 = _t1391(msg) - deconstruct_result773 = _t1393 - if !isnothing(deconstruct_result773) - unwrapped774 = deconstruct_result773 - pretty_decimal_type(pp, unwrapped774) + _t1425 = _t1423(msg) + deconstruct_result789 = _t1425 + if !isnothing(deconstruct_result789) + unwrapped790 = deconstruct_result789 + pretty_decimal_type(pp, unwrapped790) else - function _t1394(_dollar_dollar) + function _t1426(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1395 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1427 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1395 = nothing + _t1427 = nothing end - return _t1395 + return _t1427 end - _t1396 = _t1394(msg) - deconstruct_result771 = _t1396 - if !isnothing(deconstruct_result771) - unwrapped772 = deconstruct_result771 - pretty_boolean_type(pp, unwrapped772) + _t1428 = _t1426(msg) + deconstruct_result787 = _t1428 + if !isnothing(deconstruct_result787) + unwrapped788 = deconstruct_result787 + pretty_boolean_type(pp, unwrapped788) else throw(ParseError("No matching rule for type")) end @@ -1564,80 +1573,80 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields794 = msg + fields810 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields795 = msg + fields811 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields796 = msg + fields812 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields797 = msg + fields813 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields798 = msg + fields814 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields799 = msg + fields815 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields800 = msg + fields816 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields801 = msg + fields817 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields802 = msg + fields818 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat807 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat807) - write(pp, flat807) + flat823 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat823) + write(pp, flat823) return nothing else - function _t1397(_dollar_dollar) + function _t1429(_dollar_dollar) return (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) end - _t1398 = _t1397(msg) - fields803 = _t1398 - unwrapped_fields804 = fields803 + _t1430 = _t1429(msg) + fields819 = _t1430 + unwrapped_fields820 = fields819 write(pp, "(") write(pp, "DECIMAL") indent_sexp!(pp) newline(pp) - field805 = unwrapped_fields804[1] - write(pp, format_int(pp, field805)) + field821 = unwrapped_fields820[1] + write(pp, format_int(pp, field821)) newline(pp) - field806 = unwrapped_fields804[2] - write(pp, format_int(pp, field806)) + field822 = unwrapped_fields820[2] + write(pp, format_int(pp, field822)) dedent!(pp) write(pp, ")") end @@ -1645,27 +1654,27 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields808 = msg + fields824 = msg write(pp, "BOOLEAN") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat812 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat812) - write(pp, flat812) + flat828 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat828) + write(pp, flat828) return nothing else - fields809 = msg + fields825 = msg write(pp, "|") - if !isempty(fields809) + if !isempty(fields825) write(pp, " ") - for (i1399, elem810) in enumerate(fields809) - i811 = i1399 - 1 - if (i811 > 0) + for (i1431, elem826) in enumerate(fields825) + i827 = i1431 - 1 + if (i827 > 0) newline(pp) end - pretty_binding(pp, elem810) + pretty_binding(pp, elem826) end end end @@ -1673,192 +1682,192 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat839 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat839) - write(pp, flat839) + flat855 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat855) + write(pp, flat855) return nothing else - function _t1400(_dollar_dollar) + function _t1432(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1401 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1433 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1401 = nothing + _t1433 = nothing end - return _t1401 + return _t1433 end - _t1402 = _t1400(msg) - deconstruct_result837 = _t1402 - if !isnothing(deconstruct_result837) - unwrapped838 = deconstruct_result837 - pretty_true(pp, unwrapped838) + _t1434 = _t1432(msg) + deconstruct_result853 = _t1434 + if !isnothing(deconstruct_result853) + unwrapped854 = deconstruct_result853 + pretty_true(pp, unwrapped854) else - function _t1403(_dollar_dollar) + function _t1435(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1404 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1436 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1404 = nothing + _t1436 = nothing end - return _t1404 + return _t1436 end - _t1405 = _t1403(msg) - deconstruct_result835 = _t1405 - if !isnothing(deconstruct_result835) - unwrapped836 = deconstruct_result835 - pretty_false(pp, unwrapped836) + _t1437 = _t1435(msg) + deconstruct_result851 = _t1437 + if !isnothing(deconstruct_result851) + unwrapped852 = deconstruct_result851 + pretty_false(pp, unwrapped852) else - function _t1406(_dollar_dollar) + function _t1438(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1407 = _get_oneof_field(_dollar_dollar, :exists) + _t1439 = _get_oneof_field(_dollar_dollar, :exists) else - _t1407 = nothing + _t1439 = nothing end - return _t1407 + return _t1439 end - _t1408 = _t1406(msg) - deconstruct_result833 = _t1408 - if !isnothing(deconstruct_result833) - unwrapped834 = deconstruct_result833 - pretty_exists(pp, unwrapped834) + _t1440 = _t1438(msg) + deconstruct_result849 = _t1440 + if !isnothing(deconstruct_result849) + unwrapped850 = deconstruct_result849 + pretty_exists(pp, unwrapped850) else - function _t1409(_dollar_dollar) + function _t1441(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1410 = _get_oneof_field(_dollar_dollar, :reduce) + _t1442 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1410 = nothing + _t1442 = nothing end - return _t1410 + return _t1442 end - _t1411 = _t1409(msg) - deconstruct_result831 = _t1411 - if !isnothing(deconstruct_result831) - unwrapped832 = deconstruct_result831 - pretty_reduce(pp, unwrapped832) + _t1443 = _t1441(msg) + deconstruct_result847 = _t1443 + if !isnothing(deconstruct_result847) + unwrapped848 = deconstruct_result847 + pretty_reduce(pp, unwrapped848) else - function _t1412(_dollar_dollar) + function _t1444(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1413 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1445 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1413 = nothing + _t1445 = nothing end - return _t1413 + return _t1445 end - _t1414 = _t1412(msg) - deconstruct_result829 = _t1414 - if !isnothing(deconstruct_result829) - unwrapped830 = deconstruct_result829 - pretty_conjunction(pp, unwrapped830) + _t1446 = _t1444(msg) + deconstruct_result845 = _t1446 + if !isnothing(deconstruct_result845) + unwrapped846 = deconstruct_result845 + pretty_conjunction(pp, unwrapped846) else - function _t1415(_dollar_dollar) + function _t1447(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1416 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1448 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1416 = nothing + _t1448 = nothing end - return _t1416 + return _t1448 end - _t1417 = _t1415(msg) - deconstruct_result827 = _t1417 - if !isnothing(deconstruct_result827) - unwrapped828 = deconstruct_result827 - pretty_disjunction(pp, unwrapped828) + _t1449 = _t1447(msg) + deconstruct_result843 = _t1449 + if !isnothing(deconstruct_result843) + unwrapped844 = deconstruct_result843 + pretty_disjunction(pp, unwrapped844) else - function _t1418(_dollar_dollar) + function _t1450(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1419 = _get_oneof_field(_dollar_dollar, :not) + _t1451 = _get_oneof_field(_dollar_dollar, :not) else - _t1419 = nothing + _t1451 = nothing end - return _t1419 + return _t1451 end - _t1420 = _t1418(msg) - deconstruct_result825 = _t1420 - if !isnothing(deconstruct_result825) - unwrapped826 = deconstruct_result825 - pretty_not(pp, unwrapped826) + _t1452 = _t1450(msg) + deconstruct_result841 = _t1452 + if !isnothing(deconstruct_result841) + unwrapped842 = deconstruct_result841 + pretty_not(pp, unwrapped842) else - function _t1421(_dollar_dollar) + function _t1453(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1422 = _get_oneof_field(_dollar_dollar, :ffi) + _t1454 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1422 = nothing + _t1454 = nothing end - return _t1422 + return _t1454 end - _t1423 = _t1421(msg) - deconstruct_result823 = _t1423 - if !isnothing(deconstruct_result823) - unwrapped824 = deconstruct_result823 - pretty_ffi(pp, unwrapped824) + _t1455 = _t1453(msg) + deconstruct_result839 = _t1455 + if !isnothing(deconstruct_result839) + unwrapped840 = deconstruct_result839 + pretty_ffi(pp, unwrapped840) else - function _t1424(_dollar_dollar) + function _t1456(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1425 = _get_oneof_field(_dollar_dollar, :atom) + _t1457 = _get_oneof_field(_dollar_dollar, :atom) else - _t1425 = nothing + _t1457 = nothing end - return _t1425 + return _t1457 end - _t1426 = _t1424(msg) - deconstruct_result821 = _t1426 - if !isnothing(deconstruct_result821) - unwrapped822 = deconstruct_result821 - pretty_atom(pp, unwrapped822) + _t1458 = _t1456(msg) + deconstruct_result837 = _t1458 + if !isnothing(deconstruct_result837) + unwrapped838 = deconstruct_result837 + pretty_atom(pp, unwrapped838) else - function _t1427(_dollar_dollar) + function _t1459(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1428 = _get_oneof_field(_dollar_dollar, :pragma) + _t1460 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1428 = nothing + _t1460 = nothing end - return _t1428 + return _t1460 end - _t1429 = _t1427(msg) - deconstruct_result819 = _t1429 - if !isnothing(deconstruct_result819) - unwrapped820 = deconstruct_result819 - pretty_pragma(pp, unwrapped820) + _t1461 = _t1459(msg) + deconstruct_result835 = _t1461 + if !isnothing(deconstruct_result835) + unwrapped836 = deconstruct_result835 + pretty_pragma(pp, unwrapped836) else - function _t1430(_dollar_dollar) + function _t1462(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1431 = _get_oneof_field(_dollar_dollar, :primitive) + _t1463 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1431 = nothing + _t1463 = nothing end - return _t1431 + return _t1463 end - _t1432 = _t1430(msg) - deconstruct_result817 = _t1432 - if !isnothing(deconstruct_result817) - unwrapped818 = deconstruct_result817 - pretty_primitive(pp, unwrapped818) + _t1464 = _t1462(msg) + deconstruct_result833 = _t1464 + if !isnothing(deconstruct_result833) + unwrapped834 = deconstruct_result833 + pretty_primitive(pp, unwrapped834) else - function _t1433(_dollar_dollar) + function _t1465(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1434 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1466 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1434 = nothing + _t1466 = nothing end - return _t1434 + return _t1466 end - _t1435 = _t1433(msg) - deconstruct_result815 = _t1435 - if !isnothing(deconstruct_result815) - unwrapped816 = deconstruct_result815 - pretty_rel_atom(pp, unwrapped816) + _t1467 = _t1465(msg) + deconstruct_result831 = _t1467 + if !isnothing(deconstruct_result831) + unwrapped832 = deconstruct_result831 + pretty_rel_atom(pp, unwrapped832) else - function _t1436(_dollar_dollar) + function _t1468(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1437 = _get_oneof_field(_dollar_dollar, :cast) + _t1469 = _get_oneof_field(_dollar_dollar, :cast) else - _t1437 = nothing + _t1469 = nothing end - return _t1437 + return _t1469 end - _t1438 = _t1436(msg) - deconstruct_result813 = _t1438 - if !isnothing(deconstruct_result813) - unwrapped814 = deconstruct_result813 - pretty_cast(pp, unwrapped814) + _t1470 = _t1468(msg) + deconstruct_result829 = _t1470 + if !isnothing(deconstruct_result829) + unwrapped830 = deconstruct_result829 + pretty_cast(pp, unwrapped830) else throw(ParseError("No matching rule for formula")) end @@ -1879,7 +1888,7 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields840 = msg + fields856 = msg write(pp, "(") write(pp, "true") write(pp, ")") @@ -1887,7 +1896,7 @@ function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields841 = msg + fields857 = msg write(pp, "(") write(pp, "false") write(pp, ")") @@ -1895,27 +1904,27 @@ function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat846 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat846) - write(pp, flat846) + flat862 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat862) + write(pp, flat862) return nothing else - function _t1439(_dollar_dollar) - _t1440 = deconstruct_bindings(pp, _dollar_dollar.body) - return (_t1440, _dollar_dollar.body.value,) + function _t1471(_dollar_dollar) + _t1472 = deconstruct_bindings(pp, _dollar_dollar.body) + return (_t1472, _dollar_dollar.body.value,) end - _t1441 = _t1439(msg) - fields842 = _t1441 - unwrapped_fields843 = fields842 + _t1473 = _t1471(msg) + fields858 = _t1473 + unwrapped_fields859 = fields858 write(pp, "(") write(pp, "exists") indent_sexp!(pp) newline(pp) - field844 = unwrapped_fields843[1] - pretty_bindings(pp, field844) + field860 = unwrapped_fields859[1] + pretty_bindings(pp, field860) newline(pp) - field845 = unwrapped_fields843[2] - pretty_formula(pp, field845) + field861 = unwrapped_fields859[2] + pretty_formula(pp, field861) dedent!(pp) write(pp, ")") end @@ -1923,29 +1932,29 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat852 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat852) - write(pp, flat852) + flat868 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat868) + write(pp, flat868) return nothing else - function _t1442(_dollar_dollar) + function _t1474(_dollar_dollar) return (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) end - _t1443 = _t1442(msg) - fields847 = _t1443 - unwrapped_fields848 = fields847 + _t1475 = _t1474(msg) + fields863 = _t1475 + unwrapped_fields864 = fields863 write(pp, "(") write(pp, "reduce") indent_sexp!(pp) newline(pp) - field849 = unwrapped_fields848[1] - pretty_abstraction(pp, field849) + field865 = unwrapped_fields864[1] + pretty_abstraction(pp, field865) newline(pp) - field850 = unwrapped_fields848[2] - pretty_abstraction(pp, field850) + field866 = unwrapped_fields864[2] + pretty_abstraction(pp, field866) newline(pp) - field851 = unwrapped_fields848[3] - pretty_terms(pp, field851) + field867 = unwrapped_fields864[3] + pretty_terms(pp, field867) dedent!(pp) write(pp, ")") end @@ -1953,23 +1962,23 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat856 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat856) - write(pp, flat856) + flat872 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat872) + write(pp, flat872) return nothing else - fields853 = msg + fields869 = msg write(pp, "(") write(pp, "terms") indent_sexp!(pp) - if !isempty(fields853) + if !isempty(fields869) newline(pp) - for (i1444, elem854) in enumerate(fields853) - i855 = i1444 - 1 - if (i855 > 0) + for (i1476, elem870) in enumerate(fields869) + i871 = i1476 - 1 + if (i871 > 0) newline(pp) end - pretty_term(pp, elem854) + pretty_term(pp, elem870) end end dedent!(pp) @@ -1979,38 +1988,38 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat861 = try_flat(pp, msg, pretty_term) - if !isnothing(flat861) - write(pp, flat861) + flat877 = try_flat(pp, msg, pretty_term) + if !isnothing(flat877) + write(pp, flat877) return nothing else - function _t1445(_dollar_dollar) + function _t1477(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1446 = _get_oneof_field(_dollar_dollar, :var) + _t1478 = _get_oneof_field(_dollar_dollar, :var) else - _t1446 = nothing + _t1478 = nothing end - return _t1446 + return _t1478 end - _t1447 = _t1445(msg) - deconstruct_result859 = _t1447 - if !isnothing(deconstruct_result859) - unwrapped860 = deconstruct_result859 - pretty_var(pp, unwrapped860) + _t1479 = _t1477(msg) + deconstruct_result875 = _t1479 + if !isnothing(deconstruct_result875) + unwrapped876 = deconstruct_result875 + pretty_var(pp, unwrapped876) else - function _t1448(_dollar_dollar) + function _t1480(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1449 = _get_oneof_field(_dollar_dollar, :constant) + _t1481 = _get_oneof_field(_dollar_dollar, :constant) else - _t1449 = nothing + _t1481 = nothing end - return _t1449 + return _t1481 end - _t1450 = _t1448(msg) - deconstruct_result857 = _t1450 - if !isnothing(deconstruct_result857) - unwrapped858 = deconstruct_result857 - pretty_constant(pp, unwrapped858) + _t1482 = _t1480(msg) + deconstruct_result873 = _t1482 + if !isnothing(deconstruct_result873) + unwrapped874 = deconstruct_result873 + pretty_constant(pp, unwrapped874) else throw(ParseError("No matching rule for term")) end @@ -2020,57 +2029,57 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat864 = try_flat(pp, msg, pretty_var) - if !isnothing(flat864) - write(pp, flat864) + flat880 = try_flat(pp, msg, pretty_var) + if !isnothing(flat880) + write(pp, flat880) return nothing else - function _t1451(_dollar_dollar) + function _t1483(_dollar_dollar) return _dollar_dollar.name end - _t1452 = _t1451(msg) - fields862 = _t1452 - unwrapped_fields863 = fields862 - write(pp, unwrapped_fields863) + _t1484 = _t1483(msg) + fields878 = _t1484 + unwrapped_fields879 = fields878 + write(pp, unwrapped_fields879) end return nothing end function pretty_constant(pp::PrettyPrinter, msg::Proto.Value) - flat866 = try_flat(pp, msg, pretty_constant) - if !isnothing(flat866) - write(pp, flat866) + flat882 = try_flat(pp, msg, pretty_constant) + if !isnothing(flat882) + write(pp, flat882) return nothing else - fields865 = msg - pretty_value(pp, fields865) + fields881 = msg + pretty_value(pp, fields881) end return nothing end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat871 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat871) - write(pp, flat871) + flat887 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat887) + write(pp, flat887) return nothing else - function _t1453(_dollar_dollar) + function _t1485(_dollar_dollar) return _dollar_dollar.args end - _t1454 = _t1453(msg) - fields867 = _t1454 - unwrapped_fields868 = fields867 + _t1486 = _t1485(msg) + fields883 = _t1486 + unwrapped_fields884 = fields883 write(pp, "(") write(pp, "and") indent_sexp!(pp) - if !isempty(unwrapped_fields868) + if !isempty(unwrapped_fields884) newline(pp) - for (i1455, elem869) in enumerate(unwrapped_fields868) - i870 = i1455 - 1 - if (i870 > 0) + for (i1487, elem885) in enumerate(unwrapped_fields884) + i886 = i1487 - 1 + if (i886 > 0) newline(pp) end - pretty_formula(pp, elem869) + pretty_formula(pp, elem885) end end dedent!(pp) @@ -2080,28 +2089,28 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat876 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat876) - write(pp, flat876) + flat892 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat892) + write(pp, flat892) return nothing else - function _t1456(_dollar_dollar) + function _t1488(_dollar_dollar) return _dollar_dollar.args end - _t1457 = _t1456(msg) - fields872 = _t1457 - unwrapped_fields873 = fields872 + _t1489 = _t1488(msg) + fields888 = _t1489 + unwrapped_fields889 = fields888 write(pp, "(") write(pp, "or") indent_sexp!(pp) - if !isempty(unwrapped_fields873) + if !isempty(unwrapped_fields889) newline(pp) - for (i1458, elem874) in enumerate(unwrapped_fields873) - i875 = i1458 - 1 - if (i875 > 0) + for (i1490, elem890) in enumerate(unwrapped_fields889) + i891 = i1490 - 1 + if (i891 > 0) newline(pp) end - pretty_formula(pp, elem874) + pretty_formula(pp, elem890) end end dedent!(pp) @@ -2111,22 +2120,22 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat879 = try_flat(pp, msg, pretty_not) - if !isnothing(flat879) - write(pp, flat879) + flat895 = try_flat(pp, msg, pretty_not) + if !isnothing(flat895) + write(pp, flat895) return nothing else - function _t1459(_dollar_dollar) + function _t1491(_dollar_dollar) return _dollar_dollar.arg end - _t1460 = _t1459(msg) - fields877 = _t1460 - unwrapped_fields878 = fields877 + _t1492 = _t1491(msg) + fields893 = _t1492 + unwrapped_fields894 = fields893 write(pp, "(") write(pp, "not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields878) + pretty_formula(pp, unwrapped_fields894) dedent!(pp) write(pp, ")") end @@ -2134,29 +2143,29 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat885 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat885) - write(pp, flat885) + flat901 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat901) + write(pp, flat901) return nothing else - function _t1461(_dollar_dollar) + function _t1493(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) end - _t1462 = _t1461(msg) - fields880 = _t1462 - unwrapped_fields881 = fields880 + _t1494 = _t1493(msg) + fields896 = _t1494 + unwrapped_fields897 = fields896 write(pp, "(") write(pp, "ffi") indent_sexp!(pp) newline(pp) - field882 = unwrapped_fields881[1] - pretty_name(pp, field882) + field898 = unwrapped_fields897[1] + pretty_name(pp, field898) newline(pp) - field883 = unwrapped_fields881[2] - pretty_ffi_args(pp, field883) + field899 = unwrapped_fields897[2] + pretty_ffi_args(pp, field899) newline(pp) - field884 = unwrapped_fields881[3] - pretty_terms(pp, field884) + field900 = unwrapped_fields897[3] + pretty_terms(pp, field900) dedent!(pp) write(pp, ")") end @@ -2164,36 +2173,36 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat887 = try_flat(pp, msg, pretty_name) - if !isnothing(flat887) - write(pp, flat887) + flat903 = try_flat(pp, msg, pretty_name) + if !isnothing(flat903) + write(pp, flat903) return nothing else - fields886 = msg + fields902 = msg write(pp, ":") - write(pp, fields886) + write(pp, fields902) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat891 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat891) - write(pp, flat891) + flat907 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat907) + write(pp, flat907) return nothing else - fields888 = msg + fields904 = msg write(pp, "(") write(pp, "args") indent_sexp!(pp) - if !isempty(fields888) + if !isempty(fields904) newline(pp) - for (i1463, elem889) in enumerate(fields888) - i890 = i1463 - 1 - if (i890 > 0) + for (i1495, elem905) in enumerate(fields904) + i906 = i1495 - 1 + if (i906 > 0) newline(pp) end - pretty_abstraction(pp, elem889) + pretty_abstraction(pp, elem905) end end dedent!(pp) @@ -2203,32 +2212,32 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat898 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat898) - write(pp, flat898) + flat914 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat914) + write(pp, flat914) return nothing else - function _t1464(_dollar_dollar) + function _t1496(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1465 = _t1464(msg) - fields892 = _t1465 - unwrapped_fields893 = fields892 + _t1497 = _t1496(msg) + fields908 = _t1497 + unwrapped_fields909 = fields908 write(pp, "(") write(pp, "atom") indent_sexp!(pp) newline(pp) - field894 = unwrapped_fields893[1] - pretty_relation_id(pp, field894) - field895 = unwrapped_fields893[2] - if !isempty(field895) + field910 = unwrapped_fields909[1] + pretty_relation_id(pp, field910) + field911 = unwrapped_fields909[2] + if !isempty(field911) newline(pp) - for (i1466, elem896) in enumerate(field895) - i897 = i1466 - 1 - if (i897 > 0) + for (i1498, elem912) in enumerate(field911) + i913 = i1498 - 1 + if (i913 > 0) newline(pp) end - pretty_term(pp, elem896) + pretty_term(pp, elem912) end end dedent!(pp) @@ -2238,32 +2247,32 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat905 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat905) - write(pp, flat905) + flat921 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat921) + write(pp, flat921) return nothing else - function _t1467(_dollar_dollar) + function _t1499(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1468 = _t1467(msg) - fields899 = _t1468 - unwrapped_fields900 = fields899 + _t1500 = _t1499(msg) + fields915 = _t1500 + unwrapped_fields916 = fields915 write(pp, "(") write(pp, "pragma") indent_sexp!(pp) newline(pp) - field901 = unwrapped_fields900[1] - pretty_name(pp, field901) - field902 = unwrapped_fields900[2] - if !isempty(field902) + field917 = unwrapped_fields916[1] + pretty_name(pp, field917) + field918 = unwrapped_fields916[2] + if !isempty(field918) newline(pp) - for (i1469, elem903) in enumerate(field902) - i904 = i1469 - 1 - if (i904 > 0) + for (i1501, elem919) in enumerate(field918) + i920 = i1501 - 1 + if (i920 > 0) newline(pp) end - pretty_term(pp, elem903) + pretty_term(pp, elem919) end end dedent!(pp) @@ -2273,149 +2282,149 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat921 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat921) - write(pp, flat921) + flat937 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat937) + write(pp, flat937) return nothing else - function _t1470(_dollar_dollar) + function _t1502(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_eq" - _t1471 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1503 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1471 = nothing + _t1503 = nothing end - return _t1471 + return _t1503 end - _t1472 = _t1470(msg) - guard_result920 = _t1472 - if !isnothing(guard_result920) + _t1504 = _t1502(msg) + guard_result936 = _t1504 + if !isnothing(guard_result936) pretty_eq(pp, msg) else - function _t1473(_dollar_dollar) + function _t1505(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1474 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1506 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1474 = nothing + _t1506 = nothing end - return _t1474 + return _t1506 end - _t1475 = _t1473(msg) - guard_result919 = _t1475 - if !isnothing(guard_result919) + _t1507 = _t1505(msg) + guard_result935 = _t1507 + if !isnothing(guard_result935) pretty_lt(pp, msg) else - function _t1476(_dollar_dollar) + function _t1508(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1477 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1509 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1477 = nothing + _t1509 = nothing end - return _t1477 + return _t1509 end - _t1478 = _t1476(msg) - guard_result918 = _t1478 - if !isnothing(guard_result918) + _t1510 = _t1508(msg) + guard_result934 = _t1510 + if !isnothing(guard_result934) pretty_lt_eq(pp, msg) else - function _t1479(_dollar_dollar) + function _t1511(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1480 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1512 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1480 = nothing + _t1512 = nothing end - return _t1480 + return _t1512 end - _t1481 = _t1479(msg) - guard_result917 = _t1481 - if !isnothing(guard_result917) + _t1513 = _t1511(msg) + guard_result933 = _t1513 + if !isnothing(guard_result933) pretty_gt(pp, msg) else - function _t1482(_dollar_dollar) + function _t1514(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1483 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1515 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1483 = nothing + _t1515 = nothing end - return _t1483 + return _t1515 end - _t1484 = _t1482(msg) - guard_result916 = _t1484 - if !isnothing(guard_result916) + _t1516 = _t1514(msg) + guard_result932 = _t1516 + if !isnothing(guard_result932) pretty_gt_eq(pp, msg) else - function _t1485(_dollar_dollar) + function _t1517(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1486 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1518 = (_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 - _t1486 = nothing + _t1518 = nothing end - return _t1486 + return _t1518 end - _t1487 = _t1485(msg) - guard_result915 = _t1487 - if !isnothing(guard_result915) + _t1519 = _t1517(msg) + guard_result931 = _t1519 + if !isnothing(guard_result931) pretty_add(pp, msg) else - function _t1488(_dollar_dollar) + function _t1520(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1489 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1521 = (_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 - _t1489 = nothing + _t1521 = nothing end - return _t1489 + return _t1521 end - _t1490 = _t1488(msg) - guard_result914 = _t1490 - if !isnothing(guard_result914) + _t1522 = _t1520(msg) + guard_result930 = _t1522 + if !isnothing(guard_result930) pretty_minus(pp, msg) else - function _t1491(_dollar_dollar) + function _t1523(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1492 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1524 = (_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 - _t1492 = nothing + _t1524 = nothing end - return _t1492 + return _t1524 end - _t1493 = _t1491(msg) - guard_result913 = _t1493 - if !isnothing(guard_result913) + _t1525 = _t1523(msg) + guard_result929 = _t1525 + if !isnothing(guard_result929) pretty_multiply(pp, msg) else - function _t1494(_dollar_dollar) + function _t1526(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1495 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1527 = (_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 - _t1495 = nothing + _t1527 = nothing end - return _t1495 + return _t1527 end - _t1496 = _t1494(msg) - guard_result912 = _t1496 - if !isnothing(guard_result912) + _t1528 = _t1526(msg) + guard_result928 = _t1528 + if !isnothing(guard_result928) pretty_divide(pp, msg) else - function _t1497(_dollar_dollar) + function _t1529(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1498 = _t1497(msg) - fields906 = _t1498 - unwrapped_fields907 = fields906 + _t1530 = _t1529(msg) + fields922 = _t1530 + unwrapped_fields923 = fields922 write(pp, "(") write(pp, "primitive") indent_sexp!(pp) newline(pp) - field908 = unwrapped_fields907[1] - pretty_name(pp, field908) - field909 = unwrapped_fields907[2] - if !isempty(field909) + field924 = unwrapped_fields923[1] + pretty_name(pp, field924) + field925 = unwrapped_fields923[2] + if !isempty(field925) newline(pp) - for (i1499, elem910) in enumerate(field909) - i911 = i1499 - 1 - if (i911 > 0) + for (i1531, elem926) in enumerate(field925) + i927 = i1531 - 1 + if (i927 > 0) newline(pp) end - pretty_rel_term(pp, elem910) + pretty_rel_term(pp, elem926) end end dedent!(pp) @@ -2434,31 +2443,31 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat926 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat926) - write(pp, flat926) + flat942 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat942) + write(pp, flat942) return nothing else - function _t1500(_dollar_dollar) + function _t1532(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_eq" - _t1501 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1533 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1501 = nothing + _t1533 = nothing end - return _t1501 + return _t1533 end - _t1502 = _t1500(msg) - fields922 = _t1502 - unwrapped_fields923 = fields922 + _t1534 = _t1532(msg) + fields938 = _t1534 + unwrapped_fields939 = fields938 write(pp, "(") write(pp, "=") indent_sexp!(pp) newline(pp) - field924 = unwrapped_fields923[1] - pretty_term(pp, field924) + field940 = unwrapped_fields939[1] + pretty_term(pp, field940) newline(pp) - field925 = unwrapped_fields923[2] - pretty_term(pp, field925) + field941 = unwrapped_fields939[2] + pretty_term(pp, field941) dedent!(pp) write(pp, ")") end @@ -2466,31 +2475,31 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat931 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat931) - write(pp, flat931) + flat947 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat947) + write(pp, flat947) return nothing else - function _t1503(_dollar_dollar) + function _t1535(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1504 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1536 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1504 = nothing + _t1536 = nothing end - return _t1504 + return _t1536 end - _t1505 = _t1503(msg) - fields927 = _t1505 - unwrapped_fields928 = fields927 + _t1537 = _t1535(msg) + fields943 = _t1537 + unwrapped_fields944 = fields943 write(pp, "(") write(pp, "<") indent_sexp!(pp) newline(pp) - field929 = unwrapped_fields928[1] - pretty_term(pp, field929) + field945 = unwrapped_fields944[1] + pretty_term(pp, field945) newline(pp) - field930 = unwrapped_fields928[2] - pretty_term(pp, field930) + field946 = unwrapped_fields944[2] + pretty_term(pp, field946) dedent!(pp) write(pp, ")") end @@ -2498,31 +2507,31 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat936 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat936) - write(pp, flat936) + flat952 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat952) + write(pp, flat952) return nothing else - function _t1506(_dollar_dollar) + function _t1538(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1507 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1539 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1507 = nothing + _t1539 = nothing end - return _t1507 + return _t1539 end - _t1508 = _t1506(msg) - fields932 = _t1508 - unwrapped_fields933 = fields932 + _t1540 = _t1538(msg) + fields948 = _t1540 + unwrapped_fields949 = fields948 write(pp, "(") write(pp, "<=") indent_sexp!(pp) newline(pp) - field934 = unwrapped_fields933[1] - pretty_term(pp, field934) + field950 = unwrapped_fields949[1] + pretty_term(pp, field950) newline(pp) - field935 = unwrapped_fields933[2] - pretty_term(pp, field935) + field951 = unwrapped_fields949[2] + pretty_term(pp, field951) dedent!(pp) write(pp, ")") end @@ -2530,31 +2539,31 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat941 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat941) - write(pp, flat941) + flat957 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat957) + write(pp, flat957) return nothing else - function _t1509(_dollar_dollar) + function _t1541(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1510 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1542 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1510 = nothing + _t1542 = nothing end - return _t1510 + return _t1542 end - _t1511 = _t1509(msg) - fields937 = _t1511 - unwrapped_fields938 = fields937 + _t1543 = _t1541(msg) + fields953 = _t1543 + unwrapped_fields954 = fields953 write(pp, "(") write(pp, ">") indent_sexp!(pp) newline(pp) - field939 = unwrapped_fields938[1] - pretty_term(pp, field939) + field955 = unwrapped_fields954[1] + pretty_term(pp, field955) newline(pp) - field940 = unwrapped_fields938[2] - pretty_term(pp, field940) + field956 = unwrapped_fields954[2] + pretty_term(pp, field956) dedent!(pp) write(pp, ")") end @@ -2562,31 +2571,31 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat946 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat946) - write(pp, flat946) + flat962 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat962) + write(pp, flat962) return nothing else - function _t1512(_dollar_dollar) + function _t1544(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1513 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1545 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1513 = nothing + _t1545 = nothing end - return _t1513 + return _t1545 end - _t1514 = _t1512(msg) - fields942 = _t1514 - unwrapped_fields943 = fields942 + _t1546 = _t1544(msg) + fields958 = _t1546 + unwrapped_fields959 = fields958 write(pp, "(") write(pp, ">=") indent_sexp!(pp) newline(pp) - field944 = unwrapped_fields943[1] - pretty_term(pp, field944) + field960 = unwrapped_fields959[1] + pretty_term(pp, field960) newline(pp) - field945 = unwrapped_fields943[2] - pretty_term(pp, field945) + field961 = unwrapped_fields959[2] + pretty_term(pp, field961) dedent!(pp) write(pp, ")") end @@ -2594,34 +2603,34 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat952 = try_flat(pp, msg, pretty_add) - if !isnothing(flat952) - write(pp, flat952) + flat968 = try_flat(pp, msg, pretty_add) + if !isnothing(flat968) + write(pp, flat968) return nothing else - function _t1515(_dollar_dollar) + function _t1547(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1516 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1548 = (_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 - _t1516 = nothing + _t1548 = nothing end - return _t1516 + return _t1548 end - _t1517 = _t1515(msg) - fields947 = _t1517 - unwrapped_fields948 = fields947 + _t1549 = _t1547(msg) + fields963 = _t1549 + unwrapped_fields964 = fields963 write(pp, "(") write(pp, "+") indent_sexp!(pp) newline(pp) - field949 = unwrapped_fields948[1] - pretty_term(pp, field949) + field965 = unwrapped_fields964[1] + pretty_term(pp, field965) newline(pp) - field950 = unwrapped_fields948[2] - pretty_term(pp, field950) + field966 = unwrapped_fields964[2] + pretty_term(pp, field966) newline(pp) - field951 = unwrapped_fields948[3] - pretty_term(pp, field951) + field967 = unwrapped_fields964[3] + pretty_term(pp, field967) dedent!(pp) write(pp, ")") end @@ -2629,34 +2638,34 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat958 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat958) - write(pp, flat958) + flat974 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat974) + write(pp, flat974) return nothing else - function _t1518(_dollar_dollar) + function _t1550(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1519 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1551 = (_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 - _t1519 = nothing + _t1551 = nothing end - return _t1519 + return _t1551 end - _t1520 = _t1518(msg) - fields953 = _t1520 - unwrapped_fields954 = fields953 + _t1552 = _t1550(msg) + fields969 = _t1552 + unwrapped_fields970 = fields969 write(pp, "(") write(pp, "-") indent_sexp!(pp) newline(pp) - field955 = unwrapped_fields954[1] - pretty_term(pp, field955) + field971 = unwrapped_fields970[1] + pretty_term(pp, field971) newline(pp) - field956 = unwrapped_fields954[2] - pretty_term(pp, field956) + field972 = unwrapped_fields970[2] + pretty_term(pp, field972) newline(pp) - field957 = unwrapped_fields954[3] - pretty_term(pp, field957) + field973 = unwrapped_fields970[3] + pretty_term(pp, field973) dedent!(pp) write(pp, ")") end @@ -2664,34 +2673,34 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat964 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat964) - write(pp, flat964) + flat980 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat980) + write(pp, flat980) return nothing else - function _t1521(_dollar_dollar) + function _t1553(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1522 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1554 = (_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 - _t1522 = nothing + _t1554 = nothing end - return _t1522 + return _t1554 end - _t1523 = _t1521(msg) - fields959 = _t1523 - unwrapped_fields960 = fields959 + _t1555 = _t1553(msg) + fields975 = _t1555 + unwrapped_fields976 = fields975 write(pp, "(") write(pp, "*") indent_sexp!(pp) newline(pp) - field961 = unwrapped_fields960[1] - pretty_term(pp, field961) + field977 = unwrapped_fields976[1] + pretty_term(pp, field977) newline(pp) - field962 = unwrapped_fields960[2] - pretty_term(pp, field962) + field978 = unwrapped_fields976[2] + pretty_term(pp, field978) newline(pp) - field963 = unwrapped_fields960[3] - pretty_term(pp, field963) + field979 = unwrapped_fields976[3] + pretty_term(pp, field979) dedent!(pp) write(pp, ")") end @@ -2699,34 +2708,34 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat970 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat970) - write(pp, flat970) + flat986 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat986) + write(pp, flat986) return nothing else - function _t1524(_dollar_dollar) + function _t1556(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1525 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1557 = (_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 - _t1525 = nothing + _t1557 = nothing end - return _t1525 + return _t1557 end - _t1526 = _t1524(msg) - fields965 = _t1526 - unwrapped_fields966 = fields965 + _t1558 = _t1556(msg) + fields981 = _t1558 + unwrapped_fields982 = fields981 write(pp, "(") write(pp, "/") indent_sexp!(pp) newline(pp) - field967 = unwrapped_fields966[1] - pretty_term(pp, field967) + field983 = unwrapped_fields982[1] + pretty_term(pp, field983) newline(pp) - field968 = unwrapped_fields966[2] - pretty_term(pp, field968) + field984 = unwrapped_fields982[2] + pretty_term(pp, field984) newline(pp) - field969 = unwrapped_fields966[3] - pretty_term(pp, field969) + field985 = unwrapped_fields982[3] + pretty_term(pp, field985) dedent!(pp) write(pp, ")") end @@ -2734,38 +2743,38 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat975 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat975) - write(pp, flat975) + flat991 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat991) + write(pp, flat991) return nothing else - function _t1527(_dollar_dollar) + function _t1559(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1528 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1560 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1528 = nothing + _t1560 = nothing end - return _t1528 + return _t1560 end - _t1529 = _t1527(msg) - deconstruct_result973 = _t1529 - if !isnothing(deconstruct_result973) - unwrapped974 = deconstruct_result973 - pretty_specialized_value(pp, unwrapped974) + _t1561 = _t1559(msg) + deconstruct_result989 = _t1561 + if !isnothing(deconstruct_result989) + unwrapped990 = deconstruct_result989 + pretty_specialized_value(pp, unwrapped990) else - function _t1530(_dollar_dollar) + function _t1562(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1531 = _get_oneof_field(_dollar_dollar, :term) + _t1563 = _get_oneof_field(_dollar_dollar, :term) else - _t1531 = nothing + _t1563 = nothing end - return _t1531 + return _t1563 end - _t1532 = _t1530(msg) - deconstruct_result971 = _t1532 - if !isnothing(deconstruct_result971) - unwrapped972 = deconstruct_result971 - pretty_term(pp, unwrapped972) + _t1564 = _t1562(msg) + deconstruct_result987 = _t1564 + if !isnothing(deconstruct_result987) + unwrapped988 = deconstruct_result987 + pretty_term(pp, unwrapped988) else throw(ParseError("No matching rule for rel_term")) end @@ -2775,45 +2784,45 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat977 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat977) - write(pp, flat977) + flat993 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat993) + write(pp, flat993) return nothing else - fields976 = msg + fields992 = msg write(pp, "#") - pretty_value(pp, fields976) + pretty_value(pp, fields992) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat984 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat984) - write(pp, flat984) + flat1000 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1000) + write(pp, flat1000) return nothing else - function _t1533(_dollar_dollar) + function _t1565(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1534 = _t1533(msg) - fields978 = _t1534 - unwrapped_fields979 = fields978 + _t1566 = _t1565(msg) + fields994 = _t1566 + unwrapped_fields995 = fields994 write(pp, "(") write(pp, "relatom") indent_sexp!(pp) newline(pp) - field980 = unwrapped_fields979[1] - pretty_name(pp, field980) - field981 = unwrapped_fields979[2] - if !isempty(field981) + field996 = unwrapped_fields995[1] + pretty_name(pp, field996) + field997 = unwrapped_fields995[2] + if !isempty(field997) newline(pp) - for (i1535, elem982) in enumerate(field981) - i983 = i1535 - 1 - if (i983 > 0) + for (i1567, elem998) in enumerate(field997) + i999 = i1567 - 1 + if (i999 > 0) newline(pp) end - pretty_rel_term(pp, elem982) + pretty_rel_term(pp, elem998) end end dedent!(pp) @@ -2823,26 +2832,26 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat989 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat989) - write(pp, flat989) + flat1005 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1005) + write(pp, flat1005) return nothing else - function _t1536(_dollar_dollar) + function _t1568(_dollar_dollar) return (_dollar_dollar.input, _dollar_dollar.result,) end - _t1537 = _t1536(msg) - fields985 = _t1537 - unwrapped_fields986 = fields985 + _t1569 = _t1568(msg) + fields1001 = _t1569 + unwrapped_fields1002 = fields1001 write(pp, "(") write(pp, "cast") indent_sexp!(pp) newline(pp) - field987 = unwrapped_fields986[1] - pretty_term(pp, field987) + field1003 = unwrapped_fields1002[1] + pretty_term(pp, field1003) newline(pp) - field988 = unwrapped_fields986[2] - pretty_term(pp, field988) + field1004 = unwrapped_fields1002[2] + pretty_term(pp, field1004) dedent!(pp) write(pp, ")") end @@ -2850,23 +2859,23 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat993 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat993) - write(pp, flat993) + flat1009 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1009) + write(pp, flat1009) return nothing else - fields990 = msg + fields1006 = msg write(pp, "(") write(pp, "attrs") indent_sexp!(pp) - if !isempty(fields990) + if !isempty(fields1006) newline(pp) - for (i1538, elem991) in enumerate(fields990) - i992 = i1538 - 1 - if (i992 > 0) + for (i1570, elem1007) in enumerate(fields1006) + i1008 = i1570 - 1 + if (i1008 > 0) newline(pp) end - pretty_attribute(pp, elem991) + pretty_attribute(pp, elem1007) end end dedent!(pp) @@ -2876,32 +2885,32 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1000 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1000) - write(pp, flat1000) + flat1016 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1016) + write(pp, flat1016) return nothing else - function _t1539(_dollar_dollar) + function _t1571(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.args,) end - _t1540 = _t1539(msg) - fields994 = _t1540 - unwrapped_fields995 = fields994 + _t1572 = _t1571(msg) + fields1010 = _t1572 + unwrapped_fields1011 = fields1010 write(pp, "(") write(pp, "attribute") indent_sexp!(pp) newline(pp) - field996 = unwrapped_fields995[1] - pretty_name(pp, field996) - field997 = unwrapped_fields995[2] - if !isempty(field997) + field1012 = unwrapped_fields1011[1] + pretty_name(pp, field1012) + field1013 = unwrapped_fields1011[2] + if !isempty(field1013) newline(pp) - for (i1541, elem998) in enumerate(field997) - i999 = i1541 - 1 - if (i999 > 0) + for (i1573, elem1014) in enumerate(field1013) + i1015 = i1573 - 1 + if (i1015 > 0) newline(pp) end - pretty_value(pp, elem998) + pretty_value(pp, elem1014) end end dedent!(pp) @@ -2911,34 +2920,34 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1007 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1007) - write(pp, flat1007) + flat1023 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1023) + write(pp, flat1023) return nothing else - function _t1542(_dollar_dollar) + function _t1574(_dollar_dollar) return (_dollar_dollar.var"#global", _dollar_dollar.body,) end - _t1543 = _t1542(msg) - fields1001 = _t1543 - unwrapped_fields1002 = fields1001 + _t1575 = _t1574(msg) + fields1017 = _t1575 + unwrapped_fields1018 = fields1017 write(pp, "(") write(pp, "algorithm") indent_sexp!(pp) - field1003 = unwrapped_fields1002[1] - if !isempty(field1003) + field1019 = unwrapped_fields1018[1] + if !isempty(field1019) newline(pp) - for (i1544, elem1004) in enumerate(field1003) - i1005 = i1544 - 1 - if (i1005 > 0) + for (i1576, elem1020) in enumerate(field1019) + i1021 = i1576 - 1 + if (i1021 > 0) newline(pp) end - pretty_relation_id(pp, elem1004) + pretty_relation_id(pp, elem1020) end end newline(pp) - field1006 = unwrapped_fields1002[2] - pretty_script(pp, field1006) + field1022 = unwrapped_fields1018[2] + pretty_script(pp, field1022) dedent!(pp) write(pp, ")") end @@ -2946,28 +2955,28 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1012 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1012) - write(pp, flat1012) + flat1028 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1028) + write(pp, flat1028) return nothing else - function _t1545(_dollar_dollar) + function _t1577(_dollar_dollar) return _dollar_dollar.constructs end - _t1546 = _t1545(msg) - fields1008 = _t1546 - unwrapped_fields1009 = fields1008 + _t1578 = _t1577(msg) + fields1024 = _t1578 + unwrapped_fields1025 = fields1024 write(pp, "(") write(pp, "script") indent_sexp!(pp) - if !isempty(unwrapped_fields1009) + if !isempty(unwrapped_fields1025) newline(pp) - for (i1547, elem1010) in enumerate(unwrapped_fields1009) - i1011 = i1547 - 1 - if (i1011 > 0) + for (i1579, elem1026) in enumerate(unwrapped_fields1025) + i1027 = i1579 - 1 + if (i1027 > 0) newline(pp) end - pretty_construct(pp, elem1010) + pretty_construct(pp, elem1026) end end dedent!(pp) @@ -2977,38 +2986,38 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1017 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1017) - write(pp, flat1017) + flat1033 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1033) + write(pp, flat1033) return nothing else - function _t1548(_dollar_dollar) + function _t1580(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1549 = _get_oneof_field(_dollar_dollar, :loop) + _t1581 = _get_oneof_field(_dollar_dollar, :loop) else - _t1549 = nothing + _t1581 = nothing end - return _t1549 + return _t1581 end - _t1550 = _t1548(msg) - deconstruct_result1015 = _t1550 - if !isnothing(deconstruct_result1015) - unwrapped1016 = deconstruct_result1015 - pretty_loop(pp, unwrapped1016) + _t1582 = _t1580(msg) + deconstruct_result1031 = _t1582 + if !isnothing(deconstruct_result1031) + unwrapped1032 = deconstruct_result1031 + pretty_loop(pp, unwrapped1032) else - function _t1551(_dollar_dollar) + function _t1583(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1552 = _get_oneof_field(_dollar_dollar, :instruction) + _t1584 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1552 = nothing + _t1584 = nothing end - return _t1552 + return _t1584 end - _t1553 = _t1551(msg) - deconstruct_result1013 = _t1553 - if !isnothing(deconstruct_result1013) - unwrapped1014 = deconstruct_result1013 - pretty_instruction(pp, unwrapped1014) + _t1585 = _t1583(msg) + deconstruct_result1029 = _t1585 + if !isnothing(deconstruct_result1029) + unwrapped1030 = deconstruct_result1029 + pretty_instruction(pp, unwrapped1030) else throw(ParseError("No matching rule for construct")) end @@ -3018,26 +3027,26 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1022 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1022) - write(pp, flat1022) + flat1038 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1038) + write(pp, flat1038) return nothing else - function _t1554(_dollar_dollar) + function _t1586(_dollar_dollar) return (_dollar_dollar.init, _dollar_dollar.body,) end - _t1555 = _t1554(msg) - fields1018 = _t1555 - unwrapped_fields1019 = fields1018 + _t1587 = _t1586(msg) + fields1034 = _t1587 + unwrapped_fields1035 = fields1034 write(pp, "(") write(pp, "loop") indent_sexp!(pp) newline(pp) - field1020 = unwrapped_fields1019[1] - pretty_init(pp, field1020) + field1036 = unwrapped_fields1035[1] + pretty_init(pp, field1036) newline(pp) - field1021 = unwrapped_fields1019[2] - pretty_script(pp, field1021) + field1037 = unwrapped_fields1035[2] + pretty_script(pp, field1037) dedent!(pp) write(pp, ")") end @@ -3045,23 +3054,23 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1026 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1026) - write(pp, flat1026) + flat1042 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1042) + write(pp, flat1042) return nothing else - fields1023 = msg + fields1039 = msg write(pp, "(") write(pp, "init") indent_sexp!(pp) - if !isempty(fields1023) + if !isempty(fields1039) newline(pp) - for (i1556, elem1024) in enumerate(fields1023) - i1025 = i1556 - 1 - if (i1025 > 0) + for (i1588, elem1040) in enumerate(fields1039) + i1041 = i1588 - 1 + if (i1041 > 0) newline(pp) end - pretty_instruction(pp, elem1024) + pretty_instruction(pp, elem1040) end end dedent!(pp) @@ -3071,80 +3080,80 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1037 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1037) - write(pp, flat1037) + flat1053 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1053) + write(pp, flat1053) return nothing else - function _t1557(_dollar_dollar) + function _t1589(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1558 = _get_oneof_field(_dollar_dollar, :assign) + _t1590 = _get_oneof_field(_dollar_dollar, :assign) else - _t1558 = nothing + _t1590 = nothing end - return _t1558 + return _t1590 end - _t1559 = _t1557(msg) - deconstruct_result1035 = _t1559 - if !isnothing(deconstruct_result1035) - unwrapped1036 = deconstruct_result1035 - pretty_assign(pp, unwrapped1036) + _t1591 = _t1589(msg) + deconstruct_result1051 = _t1591 + if !isnothing(deconstruct_result1051) + unwrapped1052 = deconstruct_result1051 + pretty_assign(pp, unwrapped1052) else - function _t1560(_dollar_dollar) + function _t1592(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1561 = _get_oneof_field(_dollar_dollar, :upsert) + _t1593 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1561 = nothing + _t1593 = nothing end - return _t1561 + return _t1593 end - _t1562 = _t1560(msg) - deconstruct_result1033 = _t1562 - if !isnothing(deconstruct_result1033) - unwrapped1034 = deconstruct_result1033 - pretty_upsert(pp, unwrapped1034) + _t1594 = _t1592(msg) + deconstruct_result1049 = _t1594 + if !isnothing(deconstruct_result1049) + unwrapped1050 = deconstruct_result1049 + pretty_upsert(pp, unwrapped1050) else - function _t1563(_dollar_dollar) + function _t1595(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1564 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1596 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1564 = nothing + _t1596 = nothing end - return _t1564 + return _t1596 end - _t1565 = _t1563(msg) - deconstruct_result1031 = _t1565 - if !isnothing(deconstruct_result1031) - unwrapped1032 = deconstruct_result1031 - pretty_break(pp, unwrapped1032) + _t1597 = _t1595(msg) + deconstruct_result1047 = _t1597 + if !isnothing(deconstruct_result1047) + unwrapped1048 = deconstruct_result1047 + pretty_break(pp, unwrapped1048) else - function _t1566(_dollar_dollar) + function _t1598(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1567 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1599 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1567 = nothing + _t1599 = nothing end - return _t1567 + return _t1599 end - _t1568 = _t1566(msg) - deconstruct_result1029 = _t1568 - if !isnothing(deconstruct_result1029) - unwrapped1030 = deconstruct_result1029 - pretty_monoid_def(pp, unwrapped1030) + _t1600 = _t1598(msg) + deconstruct_result1045 = _t1600 + if !isnothing(deconstruct_result1045) + unwrapped1046 = deconstruct_result1045 + pretty_monoid_def(pp, unwrapped1046) else - function _t1569(_dollar_dollar) + function _t1601(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1570 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1602 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1570 = nothing + _t1602 = nothing end - return _t1570 + return _t1602 end - _t1571 = _t1569(msg) - deconstruct_result1027 = _t1571 - if !isnothing(deconstruct_result1027) - unwrapped1028 = deconstruct_result1027 - pretty_monus_def(pp, unwrapped1028) + _t1603 = _t1601(msg) + deconstruct_result1043 = _t1603 + if !isnothing(deconstruct_result1043) + unwrapped1044 = deconstruct_result1043 + pretty_monus_def(pp, unwrapped1044) else throw(ParseError("No matching rule for instruction")) end @@ -3157,36 +3166,36 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1044 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1044) - write(pp, flat1044) + flat1060 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1060) + write(pp, flat1060) return nothing else - function _t1572(_dollar_dollar) + function _t1604(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1573 = _dollar_dollar.attrs + _t1605 = _dollar_dollar.attrs else - _t1573 = nothing + _t1605 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1573,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1605,) end - _t1574 = _t1572(msg) - fields1038 = _t1574 - unwrapped_fields1039 = fields1038 + _t1606 = _t1604(msg) + fields1054 = _t1606 + unwrapped_fields1055 = fields1054 write(pp, "(") write(pp, "assign") indent_sexp!(pp) newline(pp) - field1040 = unwrapped_fields1039[1] - pretty_relation_id(pp, field1040) + field1056 = unwrapped_fields1055[1] + pretty_relation_id(pp, field1056) newline(pp) - field1041 = unwrapped_fields1039[2] - pretty_abstraction(pp, field1041) - field1042 = unwrapped_fields1039[3] - if !isnothing(field1042) + field1057 = unwrapped_fields1055[2] + pretty_abstraction(pp, field1057) + field1058 = unwrapped_fields1055[3] + if !isnothing(field1058) newline(pp) - opt_val1043 = field1042 - pretty_attrs(pp, opt_val1043) + opt_val1059 = field1058 + pretty_attrs(pp, opt_val1059) end dedent!(pp) write(pp, ")") @@ -3195,36 +3204,36 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1051 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1051) - write(pp, flat1051) + flat1067 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1067) + write(pp, flat1067) return nothing else - function _t1575(_dollar_dollar) + function _t1607(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1576 = _dollar_dollar.attrs + _t1608 = _dollar_dollar.attrs else - _t1576 = nothing + _t1608 = nothing end - return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1576,) + return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1608,) end - _t1577 = _t1575(msg) - fields1045 = _t1577 - unwrapped_fields1046 = fields1045 + _t1609 = _t1607(msg) + fields1061 = _t1609 + unwrapped_fields1062 = fields1061 write(pp, "(") write(pp, "upsert") indent_sexp!(pp) newline(pp) - field1047 = unwrapped_fields1046[1] - pretty_relation_id(pp, field1047) + field1063 = unwrapped_fields1062[1] + pretty_relation_id(pp, field1063) newline(pp) - field1048 = unwrapped_fields1046[2] - pretty_abstraction_with_arity(pp, field1048) - field1049 = unwrapped_fields1046[3] - if !isnothing(field1049) + field1064 = unwrapped_fields1062[2] + pretty_abstraction_with_arity(pp, field1064) + field1065 = unwrapped_fields1062[3] + if !isnothing(field1065) newline(pp) - opt_val1050 = field1049 - pretty_attrs(pp, opt_val1050) + opt_val1066 = field1065 + pretty_attrs(pp, opt_val1066) end dedent!(pp) write(pp, ")") @@ -3233,25 +3242,25 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1056 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1056) - write(pp, flat1056) + flat1072 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1072) + write(pp, flat1072) return nothing else - function _t1578(_dollar_dollar) - _t1579 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - return (_t1579, _dollar_dollar[1].value,) + function _t1610(_dollar_dollar) + _t1611 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + return (_t1611, _dollar_dollar[1].value,) end - _t1580 = _t1578(msg) - fields1052 = _t1580 - unwrapped_fields1053 = fields1052 + _t1612 = _t1610(msg) + fields1068 = _t1612 + unwrapped_fields1069 = fields1068 write(pp, "(") indent!(pp) - field1054 = unwrapped_fields1053[1] - pretty_bindings(pp, field1054) + field1070 = unwrapped_fields1069[1] + pretty_bindings(pp, field1070) newline(pp) - field1055 = unwrapped_fields1053[2] - pretty_formula(pp, field1055) + field1071 = unwrapped_fields1069[2] + pretty_formula(pp, field1071) dedent!(pp) write(pp, ")") end @@ -3259,36 +3268,36 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1063 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1063) - write(pp, flat1063) + flat1079 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1079) + write(pp, flat1079) return nothing else - function _t1581(_dollar_dollar) + function _t1613(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1582 = _dollar_dollar.attrs + _t1614 = _dollar_dollar.attrs else - _t1582 = nothing + _t1614 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1582,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1614,) end - _t1583 = _t1581(msg) - fields1057 = _t1583 - unwrapped_fields1058 = fields1057 + _t1615 = _t1613(msg) + fields1073 = _t1615 + unwrapped_fields1074 = fields1073 write(pp, "(") write(pp, "break") indent_sexp!(pp) newline(pp) - field1059 = unwrapped_fields1058[1] - pretty_relation_id(pp, field1059) + field1075 = unwrapped_fields1074[1] + pretty_relation_id(pp, field1075) newline(pp) - field1060 = unwrapped_fields1058[2] - pretty_abstraction(pp, field1060) - field1061 = unwrapped_fields1058[3] - if !isnothing(field1061) + field1076 = unwrapped_fields1074[2] + pretty_abstraction(pp, field1076) + field1077 = unwrapped_fields1074[3] + if !isnothing(field1077) newline(pp) - opt_val1062 = field1061 - pretty_attrs(pp, opt_val1062) + opt_val1078 = field1077 + pretty_attrs(pp, opt_val1078) end dedent!(pp) write(pp, ")") @@ -3297,39 +3306,39 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1071 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1071) - write(pp, flat1071) + flat1087 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1087) + write(pp, flat1087) return nothing else - function _t1584(_dollar_dollar) + function _t1616(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1585 = _dollar_dollar.attrs + _t1617 = _dollar_dollar.attrs else - _t1585 = nothing + _t1617 = nothing end - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1585,) + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1617,) end - _t1586 = _t1584(msg) - fields1064 = _t1586 - unwrapped_fields1065 = fields1064 + _t1618 = _t1616(msg) + fields1080 = _t1618 + unwrapped_fields1081 = fields1080 write(pp, "(") write(pp, "monoid") indent_sexp!(pp) newline(pp) - field1066 = unwrapped_fields1065[1] - pretty_monoid(pp, field1066) + field1082 = unwrapped_fields1081[1] + pretty_monoid(pp, field1082) newline(pp) - field1067 = unwrapped_fields1065[2] - pretty_relation_id(pp, field1067) + field1083 = unwrapped_fields1081[2] + pretty_relation_id(pp, field1083) newline(pp) - field1068 = unwrapped_fields1065[3] - pretty_abstraction_with_arity(pp, field1068) - field1069 = unwrapped_fields1065[4] - if !isnothing(field1069) + field1084 = unwrapped_fields1081[3] + pretty_abstraction_with_arity(pp, field1084) + field1085 = unwrapped_fields1081[4] + if !isnothing(field1085) newline(pp) - opt_val1070 = field1069 - pretty_attrs(pp, opt_val1070) + opt_val1086 = field1085 + pretty_attrs(pp, opt_val1086) end dedent!(pp) write(pp, ")") @@ -3338,66 +3347,66 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1080 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1080) - write(pp, flat1080) + flat1096 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1096) + write(pp, flat1096) return nothing else - function _t1587(_dollar_dollar) + function _t1619(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1588 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1620 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1588 = nothing + _t1620 = nothing end - return _t1588 + return _t1620 end - _t1589 = _t1587(msg) - deconstruct_result1078 = _t1589 - if !isnothing(deconstruct_result1078) - unwrapped1079 = deconstruct_result1078 - pretty_or_monoid(pp, unwrapped1079) + _t1621 = _t1619(msg) + deconstruct_result1094 = _t1621 + if !isnothing(deconstruct_result1094) + unwrapped1095 = deconstruct_result1094 + pretty_or_monoid(pp, unwrapped1095) else - function _t1590(_dollar_dollar) + function _t1622(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1591 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1623 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1591 = nothing + _t1623 = nothing end - return _t1591 + return _t1623 end - _t1592 = _t1590(msg) - deconstruct_result1076 = _t1592 - if !isnothing(deconstruct_result1076) - unwrapped1077 = deconstruct_result1076 - pretty_min_monoid(pp, unwrapped1077) + _t1624 = _t1622(msg) + deconstruct_result1092 = _t1624 + if !isnothing(deconstruct_result1092) + unwrapped1093 = deconstruct_result1092 + pretty_min_monoid(pp, unwrapped1093) else - function _t1593(_dollar_dollar) + function _t1625(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1594 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1626 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1594 = nothing + _t1626 = nothing end - return _t1594 + return _t1626 end - _t1595 = _t1593(msg) - deconstruct_result1074 = _t1595 - if !isnothing(deconstruct_result1074) - unwrapped1075 = deconstruct_result1074 - pretty_max_monoid(pp, unwrapped1075) + _t1627 = _t1625(msg) + deconstruct_result1090 = _t1627 + if !isnothing(deconstruct_result1090) + unwrapped1091 = deconstruct_result1090 + pretty_max_monoid(pp, unwrapped1091) else - function _t1596(_dollar_dollar) + function _t1628(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1597 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1629 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1597 = nothing + _t1629 = nothing end - return _t1597 + return _t1629 end - _t1598 = _t1596(msg) - deconstruct_result1072 = _t1598 - if !isnothing(deconstruct_result1072) - unwrapped1073 = deconstruct_result1072 - pretty_sum_monoid(pp, unwrapped1073) + _t1630 = _t1628(msg) + deconstruct_result1088 = _t1630 + if !isnothing(deconstruct_result1088) + unwrapped1089 = deconstruct_result1088 + pretty_sum_monoid(pp, unwrapped1089) else throw(ParseError("No matching rule for monoid")) end @@ -3409,7 +3418,7 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1081 = msg + fields1097 = msg write(pp, "(") write(pp, "or") write(pp, ")") @@ -3417,22 +3426,22 @@ function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1084 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1084) - write(pp, flat1084) + flat1100 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1100) + write(pp, flat1100) return nothing else - function _t1599(_dollar_dollar) + function _t1631(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1600 = _t1599(msg) - fields1082 = _t1600 - unwrapped_fields1083 = fields1082 + _t1632 = _t1631(msg) + fields1098 = _t1632 + unwrapped_fields1099 = fields1098 write(pp, "(") write(pp, "min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1083) + pretty_type(pp, unwrapped_fields1099) dedent!(pp) write(pp, ")") end @@ -3440,22 +3449,22 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1087 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1087) - write(pp, flat1087) + flat1103 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1103) + write(pp, flat1103) return nothing else - function _t1601(_dollar_dollar) + function _t1633(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1602 = _t1601(msg) - fields1085 = _t1602 - unwrapped_fields1086 = fields1085 + _t1634 = _t1633(msg) + fields1101 = _t1634 + unwrapped_fields1102 = fields1101 write(pp, "(") write(pp, "max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1086) + pretty_type(pp, unwrapped_fields1102) dedent!(pp) write(pp, ")") end @@ -3463,22 +3472,22 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1090 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1090) - write(pp, flat1090) + flat1106 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1106) + write(pp, flat1106) return nothing else - function _t1603(_dollar_dollar) + function _t1635(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1604 = _t1603(msg) - fields1088 = _t1604 - unwrapped_fields1089 = fields1088 + _t1636 = _t1635(msg) + fields1104 = _t1636 + unwrapped_fields1105 = fields1104 write(pp, "(") write(pp, "sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1089) + pretty_type(pp, unwrapped_fields1105) dedent!(pp) write(pp, ")") end @@ -3486,39 +3495,39 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1098 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1098) - write(pp, flat1098) + flat1114 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1114) + write(pp, flat1114) return nothing else - function _t1605(_dollar_dollar) + function _t1637(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1606 = _dollar_dollar.attrs + _t1638 = _dollar_dollar.attrs else - _t1606 = nothing + _t1638 = nothing end - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1606,) + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1638,) end - _t1607 = _t1605(msg) - fields1091 = _t1607 - unwrapped_fields1092 = fields1091 + _t1639 = _t1637(msg) + fields1107 = _t1639 + unwrapped_fields1108 = fields1107 write(pp, "(") write(pp, "monus") indent_sexp!(pp) newline(pp) - field1093 = unwrapped_fields1092[1] - pretty_monoid(pp, field1093) + field1109 = unwrapped_fields1108[1] + pretty_monoid(pp, field1109) newline(pp) - field1094 = unwrapped_fields1092[2] - pretty_relation_id(pp, field1094) + field1110 = unwrapped_fields1108[2] + pretty_relation_id(pp, field1110) newline(pp) - field1095 = unwrapped_fields1092[3] - pretty_abstraction_with_arity(pp, field1095) - field1096 = unwrapped_fields1092[4] - if !isnothing(field1096) + field1111 = unwrapped_fields1108[3] + pretty_abstraction_with_arity(pp, field1111) + field1112 = unwrapped_fields1108[4] + if !isnothing(field1112) newline(pp) - opt_val1097 = field1096 - pretty_attrs(pp, opt_val1097) + opt_val1113 = field1112 + pretty_attrs(pp, opt_val1113) end dedent!(pp) write(pp, ")") @@ -3527,32 +3536,32 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1105 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1105) - write(pp, flat1105) + flat1121 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1121) + write(pp, flat1121) return nothing else - function _t1608(_dollar_dollar) + function _t1640(_dollar_dollar) return (_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,) end - _t1609 = _t1608(msg) - fields1099 = _t1609 - unwrapped_fields1100 = fields1099 + _t1641 = _t1640(msg) + fields1115 = _t1641 + unwrapped_fields1116 = fields1115 write(pp, "(") write(pp, "functional_dependency") indent_sexp!(pp) newline(pp) - field1101 = unwrapped_fields1100[1] - pretty_relation_id(pp, field1101) + field1117 = unwrapped_fields1116[1] + pretty_relation_id(pp, field1117) newline(pp) - field1102 = unwrapped_fields1100[2] - pretty_abstraction(pp, field1102) + field1118 = unwrapped_fields1116[2] + pretty_abstraction(pp, field1118) newline(pp) - field1103 = unwrapped_fields1100[3] - pretty_functional_dependency_keys(pp, field1103) + field1119 = unwrapped_fields1116[3] + pretty_functional_dependency_keys(pp, field1119) newline(pp) - field1104 = unwrapped_fields1100[4] - pretty_functional_dependency_values(pp, field1104) + field1120 = unwrapped_fields1116[4] + pretty_functional_dependency_values(pp, field1120) dedent!(pp) write(pp, ")") end @@ -3560,23 +3569,23 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1109 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1109) - write(pp, flat1109) + flat1125 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1125) + write(pp, flat1125) return nothing else - fields1106 = msg + fields1122 = msg write(pp, "(") write(pp, "keys") indent_sexp!(pp) - if !isempty(fields1106) + if !isempty(fields1122) newline(pp) - for (i1610, elem1107) in enumerate(fields1106) - i1108 = i1610 - 1 - if (i1108 > 0) + for (i1642, elem1123) in enumerate(fields1122) + i1124 = i1642 - 1 + if (i1124 > 0) newline(pp) end - pretty_var(pp, elem1107) + pretty_var(pp, elem1123) end end dedent!(pp) @@ -3586,23 +3595,23 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1113 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1113) - write(pp, flat1113) + flat1129 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1129) + write(pp, flat1129) return nothing else - fields1110 = msg + fields1126 = msg write(pp, "(") write(pp, "values") indent_sexp!(pp) - if !isempty(fields1110) + if !isempty(fields1126) newline(pp) - for (i1611, elem1111) in enumerate(fields1110) - i1112 = i1611 - 1 - if (i1112 > 0) + for (i1643, elem1127) in enumerate(fields1126) + i1128 = i1643 - 1 + if (i1128 > 0) newline(pp) end - pretty_var(pp, elem1111) + pretty_var(pp, elem1127) end end dedent!(pp) @@ -3612,52 +3621,52 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1120 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1120) - write(pp, flat1120) + flat1136 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1136) + write(pp, flat1136) return nothing else - function _t1612(_dollar_dollar) + function _t1644(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("rel_edb")) - _t1613 = _get_oneof_field(_dollar_dollar, :rel_edb) + _t1645 = _get_oneof_field(_dollar_dollar, :rel_edb) else - _t1613 = nothing + _t1645 = nothing end - return _t1613 + return _t1645 end - _t1614 = _t1612(msg) - deconstruct_result1118 = _t1614 - if !isnothing(deconstruct_result1118) - unwrapped1119 = deconstruct_result1118 - pretty_rel_edb(pp, unwrapped1119) + _t1646 = _t1644(msg) + deconstruct_result1134 = _t1646 + if !isnothing(deconstruct_result1134) + unwrapped1135 = deconstruct_result1134 + pretty_rel_edb(pp, unwrapped1135) else - function _t1615(_dollar_dollar) + function _t1647(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1616 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1648 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1616 = nothing + _t1648 = nothing end - return _t1616 + return _t1648 end - _t1617 = _t1615(msg) - deconstruct_result1116 = _t1617 - if !isnothing(deconstruct_result1116) - unwrapped1117 = deconstruct_result1116 - pretty_betree_relation(pp, unwrapped1117) + _t1649 = _t1647(msg) + deconstruct_result1132 = _t1649 + if !isnothing(deconstruct_result1132) + unwrapped1133 = deconstruct_result1132 + pretty_betree_relation(pp, unwrapped1133) else - function _t1618(_dollar_dollar) + function _t1650(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1619 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1651 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1619 = nothing + _t1651 = nothing end - return _t1619 + return _t1651 end - _t1620 = _t1618(msg) - deconstruct_result1114 = _t1620 - if !isnothing(deconstruct_result1114) - unwrapped1115 = deconstruct_result1114 - pretty_csv_data(pp, unwrapped1115) + _t1652 = _t1650(msg) + deconstruct_result1130 = _t1652 + if !isnothing(deconstruct_result1130) + unwrapped1131 = deconstruct_result1130 + pretty_csv_data(pp, unwrapped1131) else throw(ParseError("No matching rule for data")) end @@ -3668,29 +3677,29 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_rel_edb(pp::PrettyPrinter, msg::Proto.RelEDB) - flat1126 = try_flat(pp, msg, pretty_rel_edb) - if !isnothing(flat1126) - write(pp, flat1126) + flat1142 = try_flat(pp, msg, pretty_rel_edb) + if !isnothing(flat1142) + write(pp, flat1142) return nothing else - function _t1621(_dollar_dollar) + function _t1653(_dollar_dollar) return (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) end - _t1622 = _t1621(msg) - fields1121 = _t1622 - unwrapped_fields1122 = fields1121 + _t1654 = _t1653(msg) + fields1137 = _t1654 + unwrapped_fields1138 = fields1137 write(pp, "(") write(pp, "rel_edb") indent_sexp!(pp) newline(pp) - field1123 = unwrapped_fields1122[1] - pretty_relation_id(pp, field1123) + field1139 = unwrapped_fields1138[1] + pretty_relation_id(pp, field1139) newline(pp) - field1124 = unwrapped_fields1122[2] - pretty_rel_edb_path(pp, field1124) + field1140 = unwrapped_fields1138[2] + pretty_rel_edb_path(pp, field1140) newline(pp) - field1125 = unwrapped_fields1122[3] - pretty_rel_edb_types(pp, field1125) + field1141 = unwrapped_fields1138[3] + pretty_rel_edb_types(pp, field1141) dedent!(pp) write(pp, ")") end @@ -3698,20 +3707,20 @@ function pretty_rel_edb(pp::PrettyPrinter, msg::Proto.RelEDB) end function pretty_rel_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1130 = try_flat(pp, msg, pretty_rel_edb_path) - if !isnothing(flat1130) - write(pp, flat1130) + flat1146 = try_flat(pp, msg, pretty_rel_edb_path) + if !isnothing(flat1146) + write(pp, flat1146) return nothing else - fields1127 = msg + fields1143 = msg write(pp, "[") indent!(pp) - for (i1623, elem1128) in enumerate(fields1127) - i1129 = i1623 - 1 - if (i1129 > 0) + for (i1655, elem1144) in enumerate(fields1143) + i1145 = i1655 - 1 + if (i1145 > 0) newline(pp) end - write(pp, format_string(pp, elem1128)) + write(pp, format_string(pp, elem1144)) end dedent!(pp) write(pp, "]") @@ -3720,20 +3729,20 @@ function pretty_rel_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_rel_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1134 = try_flat(pp, msg, pretty_rel_edb_types) - if !isnothing(flat1134) - write(pp, flat1134) + flat1150 = try_flat(pp, msg, pretty_rel_edb_types) + if !isnothing(flat1150) + write(pp, flat1150) return nothing else - fields1131 = msg + fields1147 = msg write(pp, "[") indent!(pp) - for (i1624, elem1132) in enumerate(fields1131) - i1133 = i1624 - 1 - if (i1133 > 0) + for (i1656, elem1148) in enumerate(fields1147) + i1149 = i1656 - 1 + if (i1149 > 0) newline(pp) end - pretty_type(pp, elem1132) + pretty_type(pp, elem1148) end dedent!(pp) write(pp, "]") @@ -3742,26 +3751,26 @@ function pretty_rel_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1139 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1139) - write(pp, flat1139) + flat1155 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1155) + write(pp, flat1155) return nothing else - function _t1625(_dollar_dollar) + function _t1657(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.relation_info,) end - _t1626 = _t1625(msg) - fields1135 = _t1626 - unwrapped_fields1136 = fields1135 + _t1658 = _t1657(msg) + fields1151 = _t1658 + unwrapped_fields1152 = fields1151 write(pp, "(") write(pp, "betree_relation") indent_sexp!(pp) newline(pp) - field1137 = unwrapped_fields1136[1] - pretty_relation_id(pp, field1137) + field1153 = unwrapped_fields1152[1] + pretty_relation_id(pp, field1153) newline(pp) - field1138 = unwrapped_fields1136[2] - pretty_betree_info(pp, field1138) + field1154 = unwrapped_fields1152[2] + pretty_betree_info(pp, field1154) dedent!(pp) write(pp, ")") end @@ -3769,30 +3778,30 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1145 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1145) - write(pp, flat1145) + flat1161 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1161) + write(pp, flat1161) return nothing else - function _t1627(_dollar_dollar) - _t1628 = deconstruct_betree_info_config(pp, _dollar_dollar) - return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1628,) + function _t1659(_dollar_dollar) + _t1660 = deconstruct_betree_info_config(pp, _dollar_dollar) + return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1660,) end - _t1629 = _t1627(msg) - fields1140 = _t1629 - unwrapped_fields1141 = fields1140 + _t1661 = _t1659(msg) + fields1156 = _t1661 + unwrapped_fields1157 = fields1156 write(pp, "(") write(pp, "betree_info") indent_sexp!(pp) newline(pp) - field1142 = unwrapped_fields1141[1] - pretty_betree_info_key_types(pp, field1142) + field1158 = unwrapped_fields1157[1] + pretty_betree_info_key_types(pp, field1158) newline(pp) - field1143 = unwrapped_fields1141[2] - pretty_betree_info_value_types(pp, field1143) + field1159 = unwrapped_fields1157[2] + pretty_betree_info_value_types(pp, field1159) newline(pp) - field1144 = unwrapped_fields1141[3] - pretty_config_dict(pp, field1144) + field1160 = unwrapped_fields1157[3] + pretty_config_dict(pp, field1160) dedent!(pp) write(pp, ")") end @@ -3800,23 +3809,23 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1149 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1149) - write(pp, flat1149) + flat1165 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1165) + write(pp, flat1165) return nothing else - fields1146 = msg + fields1162 = msg write(pp, "(") write(pp, "key_types") indent_sexp!(pp) - if !isempty(fields1146) + if !isempty(fields1162) newline(pp) - for (i1630, elem1147) in enumerate(fields1146) - i1148 = i1630 - 1 - if (i1148 > 0) + for (i1662, elem1163) in enumerate(fields1162) + i1164 = i1662 - 1 + if (i1164 > 0) newline(pp) end - pretty_type(pp, elem1147) + pretty_type(pp, elem1163) end end dedent!(pp) @@ -3826,23 +3835,23 @@ 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"}) - flat1153 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1153) - write(pp, flat1153) + flat1169 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1169) + write(pp, flat1169) return nothing else - fields1150 = msg + fields1166 = msg write(pp, "(") write(pp, "value_types") indent_sexp!(pp) - if !isempty(fields1150) + if !isempty(fields1166) newline(pp) - for (i1631, elem1151) in enumerate(fields1150) - i1152 = i1631 - 1 - if (i1152 > 0) + for (i1663, elem1167) in enumerate(fields1166) + i1168 = i1663 - 1 + if (i1168 > 0) newline(pp) end - pretty_type(pp, elem1151) + pretty_type(pp, elem1167) end end dedent!(pp) @@ -3852,32 +3861,32 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1160 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1160) - write(pp, flat1160) + flat1176 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1176) + write(pp, flat1176) return nothing else - function _t1632(_dollar_dollar) + function _t1664(_dollar_dollar) return (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) end - _t1633 = _t1632(msg) - fields1154 = _t1633 - unwrapped_fields1155 = fields1154 + _t1665 = _t1664(msg) + fields1170 = _t1665 + unwrapped_fields1171 = fields1170 write(pp, "(") write(pp, "csv_data") indent_sexp!(pp) newline(pp) - field1156 = unwrapped_fields1155[1] - pretty_csvlocator(pp, field1156) + field1172 = unwrapped_fields1171[1] + pretty_csvlocator(pp, field1172) newline(pp) - field1157 = unwrapped_fields1155[2] - pretty_csv_config(pp, field1157) + field1173 = unwrapped_fields1171[2] + pretty_csv_config(pp, field1173) newline(pp) - field1158 = unwrapped_fields1155[3] - pretty_csv_columns(pp, field1158) + field1174 = unwrapped_fields1171[3] + pretty_csv_columns(pp, field1174) newline(pp) - field1159 = unwrapped_fields1155[4] - pretty_csv_asof(pp, field1159) + field1175 = unwrapped_fields1171[4] + pretty_csv_asof(pp, field1175) dedent!(pp) write(pp, ")") end @@ -3885,41 +3894,41 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1167 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1167) - write(pp, flat1167) + flat1183 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1183) + write(pp, flat1183) return nothing else - function _t1634(_dollar_dollar) + function _t1666(_dollar_dollar) if !isempty(_dollar_dollar.paths) - _t1635 = _dollar_dollar.paths + _t1667 = _dollar_dollar.paths else - _t1635 = nothing + _t1667 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1636 = String(copy(_dollar_dollar.inline_data)) + _t1668 = String(copy(_dollar_dollar.inline_data)) else - _t1636 = nothing + _t1668 = nothing end - return (_t1635, _t1636,) + return (_t1667, _t1668,) end - _t1637 = _t1634(msg) - fields1161 = _t1637 - unwrapped_fields1162 = fields1161 + _t1669 = _t1666(msg) + fields1177 = _t1669 + unwrapped_fields1178 = fields1177 write(pp, "(") write(pp, "csv_locator") indent_sexp!(pp) - field1163 = unwrapped_fields1162[1] - if !isnothing(field1163) + field1179 = unwrapped_fields1178[1] + if !isnothing(field1179) newline(pp) - opt_val1164 = field1163 - pretty_csv_locator_paths(pp, opt_val1164) + opt_val1180 = field1179 + pretty_csv_locator_paths(pp, opt_val1180) end - field1165 = unwrapped_fields1162[2] - if !isnothing(field1165) + field1181 = unwrapped_fields1178[2] + if !isnothing(field1181) newline(pp) - opt_val1166 = field1165 - pretty_csv_locator_inline_data(pp, opt_val1166) + opt_val1182 = field1181 + pretty_csv_locator_inline_data(pp, opt_val1182) end dedent!(pp) write(pp, ")") @@ -3928,23 +3937,23 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1171 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1171) - write(pp, flat1171) + flat1187 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1187) + write(pp, flat1187) return nothing else - fields1168 = msg + fields1184 = msg write(pp, "(") write(pp, "paths") indent_sexp!(pp) - if !isempty(fields1168) + if !isempty(fields1184) newline(pp) - for (i1638, elem1169) in enumerate(fields1168) - i1170 = i1638 - 1 - if (i1170 > 0) + for (i1670, elem1185) in enumerate(fields1184) + i1186 = i1670 - 1 + if (i1186 > 0) newline(pp) end - write(pp, format_string(pp, elem1169)) + write(pp, format_string(pp, elem1185)) end end dedent!(pp) @@ -3954,17 +3963,17 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1173 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1173) - write(pp, flat1173) + flat1189 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1189) + write(pp, flat1189) return nothing else - fields1172 = msg + fields1188 = msg write(pp, "(") write(pp, "inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1172)) + write(pp, format_string(pp, fields1188)) dedent!(pp) write(pp, ")") end @@ -3972,23 +3981,23 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1176 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1176) - write(pp, flat1176) + flat1192 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1192) + write(pp, flat1192) return nothing else - function _t1639(_dollar_dollar) - _t1640 = deconstruct_csv_config(pp, _dollar_dollar) - return _t1640 + function _t1671(_dollar_dollar) + _t1672 = deconstruct_csv_config(pp, _dollar_dollar) + return _t1672 end - _t1641 = _t1639(msg) - fields1174 = _t1641 - unwrapped_fields1175 = fields1174 + _t1673 = _t1671(msg) + fields1190 = _t1673 + unwrapped_fields1191 = fields1190 write(pp, "(") write(pp, "csv_config") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields1175) + pretty_config_dict(pp, unwrapped_fields1191) dedent!(pp) write(pp, ")") end @@ -3996,23 +4005,23 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.CSVColumn}) - flat1180 = try_flat(pp, msg, pretty_csv_columns) - if !isnothing(flat1180) - write(pp, flat1180) + flat1196 = try_flat(pp, msg, pretty_csv_columns) + if !isnothing(flat1196) + write(pp, flat1196) return nothing else - fields1177 = msg + fields1193 = msg write(pp, "(") write(pp, "columns") indent_sexp!(pp) - if !isempty(fields1177) + if !isempty(fields1193) newline(pp) - for (i1642, elem1178) in enumerate(fields1177) - i1179 = i1642 - 1 - if (i1179 > 0) + for (i1674, elem1194) in enumerate(fields1193) + i1195 = i1674 - 1 + if (i1195 > 0) newline(pp) end - pretty_csv_column(pp, elem1178) + pretty_csv_column(pp, elem1194) end end dedent!(pp) @@ -4022,55 +4031,153 @@ function pretty_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.CSVColumn}) end function pretty_csv_column(pp::PrettyPrinter, msg::Proto.CSVColumn) - flat1188 = try_flat(pp, msg, pretty_csv_column) - if !isnothing(flat1188) - write(pp, flat1188) + flat1202 = try_flat(pp, msg, pretty_csv_column) + if !isnothing(flat1202) + write(pp, flat1202) return nothing else - function _t1643(_dollar_dollar) - return (_dollar_dollar.column_name, _dollar_dollar.target_id, _dollar_dollar.types,) + function _t1675(_dollar_dollar) + _t1676 = deconstruct_csv_column_tail(pp, _dollar_dollar) + return (_dollar_dollar.column_path, _t1676,) end - _t1644 = _t1643(msg) - fields1181 = _t1644 - unwrapped_fields1182 = fields1181 + _t1677 = _t1675(msg) + fields1197 = _t1677 + unwrapped_fields1198 = fields1197 write(pp, "(") write(pp, "column") indent_sexp!(pp) newline(pp) - field1183 = unwrapped_fields1182[1] - write(pp, format_string(pp, field1183)) - newline(pp) - field1184 = unwrapped_fields1182[2] - pretty_relation_id(pp, field1184) - newline(pp) - write(pp, "[") - field1185 = unwrapped_fields1182[3] - for (i1645, elem1186) in enumerate(field1185) - i1187 = i1645 - 1 - if (i1187 > 0) - newline(pp) - end - pretty_type(pp, elem1186) + field1199 = unwrapped_fields1198[1] + pretty_csv_column_path(pp, field1199) + field1200 = unwrapped_fields1198[2] + if !isnothing(field1200) + newline(pp) + opt_val1201 = field1200 + pretty_csv_column_tail(pp, opt_val1201) end - write(pp, "]") dedent!(pp) write(pp, ")") end return nothing end +function pretty_csv_column_path(pp::PrettyPrinter, msg::Vector{String}) + flat1209 = try_flat(pp, msg, pretty_csv_column_path) + if !isnothing(flat1209) + write(pp, flat1209) + return nothing + else + function _t1678(_dollar_dollar) + if length(_dollar_dollar) == 1 + _t1679 = _dollar_dollar[1] + else + _t1679 = nothing + end + return _t1679 + end + _t1680 = _t1678(msg) + deconstruct_result1207 = _t1680 + if !isnothing(deconstruct_result1207) + unwrapped1208 = deconstruct_result1207 + write(pp, format_string(pp, unwrapped1208)) + else + function _t1681(_dollar_dollar) + if length(_dollar_dollar) != 1 + _t1682 = _dollar_dollar + else + _t1682 = nothing + end + return _t1682 + end + _t1683 = _t1681(msg) + deconstruct_result1203 = _t1683 + if !isnothing(deconstruct_result1203) + unwrapped1204 = deconstruct_result1203 + write(pp, "[") + indent!(pp) + for (i1684, elem1205) in enumerate(unwrapped1204) + i1206 = i1684 - 1 + if (i1206 > 0) + newline(pp) + end + write(pp, format_string(pp, elem1205)) + end + dedent!(pp) + write(pp, "]") + else + throw(ParseError("No matching rule for csv_column_path")) + end + end + end + return nothing +end + +function pretty_csv_column_tail(pp::PrettyPrinter, msg::Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}) + flat1220 = try_flat(pp, msg, pretty_csv_column_tail) + if !isnothing(flat1220) + write(pp, flat1220) + return nothing + else + function _t1685(_dollar_dollar) + if !isnothing(_dollar_dollar[1]) + _t1686 = (_dollar_dollar[1], _dollar_dollar[2],) + else + _t1686 = nothing + end + return _t1686 + end + _t1687 = _t1685(msg) + deconstruct_result1214 = _t1687 + if !isnothing(deconstruct_result1214) + unwrapped1215 = deconstruct_result1214 + field1216 = unwrapped1215[1] + pretty_relation_id(pp, field1216) + write(pp, " ") + write(pp, "[") + field1217 = unwrapped1215[2] + for (i1688, elem1218) in enumerate(field1217) + i1219 = i1688 - 1 + if (i1219 > 0) + newline(pp) + end + pretty_type(pp, elem1218) + end + write(pp, "]") + else + function _t1689(_dollar_dollar) + return _dollar_dollar[2] + end + _t1690 = _t1689(msg) + fields1210 = _t1690 + unwrapped_fields1211 = fields1210 + write(pp, "[") + indent!(pp) + for (i1691, elem1212) in enumerate(unwrapped_fields1211) + i1213 = i1691 - 1 + if (i1213 > 0) + newline(pp) + end + pretty_type(pp, elem1212) + end + dedent!(pp) + write(pp, "]") + end + end + return nothing +end + function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1190 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1190) - write(pp, flat1190) + flat1222 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1222) + write(pp, flat1222) return nothing else - fields1189 = msg + fields1221 = msg write(pp, "(") write(pp, "asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1189)) + write(pp, format_string(pp, fields1221)) dedent!(pp) write(pp, ")") end @@ -4078,22 +4185,22 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1193 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1193) - write(pp, flat1193) + flat1225 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1225) + write(pp, flat1225) return nothing else - function _t1646(_dollar_dollar) + function _t1692(_dollar_dollar) return _dollar_dollar.fragment_id end - _t1647 = _t1646(msg) - fields1191 = _t1647 - unwrapped_fields1192 = fields1191 + _t1693 = _t1692(msg) + fields1223 = _t1693 + unwrapped_fields1224 = fields1223 write(pp, "(") write(pp, "undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1192) + pretty_fragment_id(pp, unwrapped_fields1224) dedent!(pp) write(pp, ")") end @@ -4101,28 +4208,28 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1198 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1198) - write(pp, flat1198) + flat1230 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1230) + write(pp, flat1230) return nothing else - function _t1648(_dollar_dollar) + function _t1694(_dollar_dollar) return _dollar_dollar.relations end - _t1649 = _t1648(msg) - fields1194 = _t1649 - unwrapped_fields1195 = fields1194 + _t1695 = _t1694(msg) + fields1226 = _t1695 + unwrapped_fields1227 = fields1226 write(pp, "(") write(pp, "context") indent_sexp!(pp) - if !isempty(unwrapped_fields1195) + if !isempty(unwrapped_fields1227) newline(pp) - for (i1650, elem1196) in enumerate(unwrapped_fields1195) - i1197 = i1650 - 1 - if (i1197 > 0) + for (i1696, elem1228) in enumerate(unwrapped_fields1227) + i1229 = i1696 - 1 + if (i1229 > 0) newline(pp) end - pretty_relation_id(pp, elem1196) + pretty_relation_id(pp, elem1228) end end dedent!(pp) @@ -4132,26 +4239,26 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1203 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1203) - write(pp, flat1203) + flat1235 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1235) + write(pp, flat1235) return nothing else - function _t1651(_dollar_dollar) + function _t1697(_dollar_dollar) return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) end - _t1652 = _t1651(msg) - fields1199 = _t1652 - unwrapped_fields1200 = fields1199 + _t1698 = _t1697(msg) + fields1231 = _t1698 + unwrapped_fields1232 = fields1231 write(pp, "(") write(pp, "snapshot") indent_sexp!(pp) newline(pp) - field1201 = unwrapped_fields1200[1] - pretty_rel_edb_path(pp, field1201) + field1233 = unwrapped_fields1232[1] + pretty_rel_edb_path(pp, field1233) newline(pp) - field1202 = unwrapped_fields1200[2] - pretty_relation_id(pp, field1202) + field1234 = unwrapped_fields1232[2] + pretty_relation_id(pp, field1234) dedent!(pp) write(pp, ")") end @@ -4159,23 +4266,23 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1207 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1207) - write(pp, flat1207) + flat1239 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1239) + write(pp, flat1239) return nothing else - fields1204 = msg + fields1236 = msg write(pp, "(") write(pp, "reads") indent_sexp!(pp) - if !isempty(fields1204) + if !isempty(fields1236) newline(pp) - for (i1653, elem1205) in enumerate(fields1204) - i1206 = i1653 - 1 - if (i1206 > 0) + for (i1699, elem1237) in enumerate(fields1236) + i1238 = i1699 - 1 + if (i1238 > 0) newline(pp) end - pretty_read(pp, elem1205) + pretty_read(pp, elem1237) end end dedent!(pp) @@ -4185,80 +4292,80 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1218 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1218) - write(pp, flat1218) + flat1250 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1250) + write(pp, flat1250) return nothing else - function _t1654(_dollar_dollar) + function _t1700(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1655 = _get_oneof_field(_dollar_dollar, :demand) + _t1701 = _get_oneof_field(_dollar_dollar, :demand) else - _t1655 = nothing + _t1701 = nothing end - return _t1655 + return _t1701 end - _t1656 = _t1654(msg) - deconstruct_result1216 = _t1656 - if !isnothing(deconstruct_result1216) - unwrapped1217 = deconstruct_result1216 - pretty_demand(pp, unwrapped1217) + _t1702 = _t1700(msg) + deconstruct_result1248 = _t1702 + if !isnothing(deconstruct_result1248) + unwrapped1249 = deconstruct_result1248 + pretty_demand(pp, unwrapped1249) else - function _t1657(_dollar_dollar) + function _t1703(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1658 = _get_oneof_field(_dollar_dollar, :output) + _t1704 = _get_oneof_field(_dollar_dollar, :output) else - _t1658 = nothing + _t1704 = nothing end - return _t1658 + return _t1704 end - _t1659 = _t1657(msg) - deconstruct_result1214 = _t1659 - if !isnothing(deconstruct_result1214) - unwrapped1215 = deconstruct_result1214 - pretty_output(pp, unwrapped1215) + _t1705 = _t1703(msg) + deconstruct_result1246 = _t1705 + if !isnothing(deconstruct_result1246) + unwrapped1247 = deconstruct_result1246 + pretty_output(pp, unwrapped1247) else - function _t1660(_dollar_dollar) + function _t1706(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1661 = _get_oneof_field(_dollar_dollar, :what_if) + _t1707 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1661 = nothing + _t1707 = nothing end - return _t1661 + return _t1707 end - _t1662 = _t1660(msg) - deconstruct_result1212 = _t1662 - if !isnothing(deconstruct_result1212) - unwrapped1213 = deconstruct_result1212 - pretty_what_if(pp, unwrapped1213) + _t1708 = _t1706(msg) + deconstruct_result1244 = _t1708 + if !isnothing(deconstruct_result1244) + unwrapped1245 = deconstruct_result1244 + pretty_what_if(pp, unwrapped1245) else - function _t1663(_dollar_dollar) + function _t1709(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1664 = _get_oneof_field(_dollar_dollar, :abort) + _t1710 = _get_oneof_field(_dollar_dollar, :abort) else - _t1664 = nothing + _t1710 = nothing end - return _t1664 + return _t1710 end - _t1665 = _t1663(msg) - deconstruct_result1210 = _t1665 - if !isnothing(deconstruct_result1210) - unwrapped1211 = deconstruct_result1210 - pretty_abort(pp, unwrapped1211) + _t1711 = _t1709(msg) + deconstruct_result1242 = _t1711 + if !isnothing(deconstruct_result1242) + unwrapped1243 = deconstruct_result1242 + pretty_abort(pp, unwrapped1243) else - function _t1666(_dollar_dollar) + function _t1712(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1667 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1713 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1667 = nothing + _t1713 = nothing end - return _t1667 + return _t1713 end - _t1668 = _t1666(msg) - deconstruct_result1208 = _t1668 - if !isnothing(deconstruct_result1208) - unwrapped1209 = deconstruct_result1208 - pretty_export(pp, unwrapped1209) + _t1714 = _t1712(msg) + deconstruct_result1240 = _t1714 + if !isnothing(deconstruct_result1240) + unwrapped1241 = deconstruct_result1240 + pretty_export(pp, unwrapped1241) else throw(ParseError("No matching rule for read")) end @@ -4271,22 +4378,22 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1221 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1221) - write(pp, flat1221) + flat1253 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1253) + write(pp, flat1253) return nothing else - function _t1669(_dollar_dollar) + function _t1715(_dollar_dollar) return _dollar_dollar.relation_id end - _t1670 = _t1669(msg) - fields1219 = _t1670 - unwrapped_fields1220 = fields1219 + _t1716 = _t1715(msg) + fields1251 = _t1716 + unwrapped_fields1252 = fields1251 write(pp, "(") write(pp, "demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1220) + pretty_relation_id(pp, unwrapped_fields1252) dedent!(pp) write(pp, ")") end @@ -4294,26 +4401,26 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1226 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1226) - write(pp, flat1226) + flat1258 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1258) + write(pp, flat1258) return nothing else - function _t1671(_dollar_dollar) + function _t1717(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.relation_id,) end - _t1672 = _t1671(msg) - fields1222 = _t1672 - unwrapped_fields1223 = fields1222 + _t1718 = _t1717(msg) + fields1254 = _t1718 + unwrapped_fields1255 = fields1254 write(pp, "(") write(pp, "output") indent_sexp!(pp) newline(pp) - field1224 = unwrapped_fields1223[1] - pretty_name(pp, field1224) + field1256 = unwrapped_fields1255[1] + pretty_name(pp, field1256) newline(pp) - field1225 = unwrapped_fields1223[2] - pretty_relation_id(pp, field1225) + field1257 = unwrapped_fields1255[2] + pretty_relation_id(pp, field1257) dedent!(pp) write(pp, ")") end @@ -4321,26 +4428,26 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1231 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1231) - write(pp, flat1231) + flat1263 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1263) + write(pp, flat1263) return nothing else - function _t1673(_dollar_dollar) + function _t1719(_dollar_dollar) return (_dollar_dollar.branch, _dollar_dollar.epoch,) end - _t1674 = _t1673(msg) - fields1227 = _t1674 - unwrapped_fields1228 = fields1227 + _t1720 = _t1719(msg) + fields1259 = _t1720 + unwrapped_fields1260 = fields1259 write(pp, "(") write(pp, "what_if") indent_sexp!(pp) newline(pp) - field1229 = unwrapped_fields1228[1] - pretty_name(pp, field1229) + field1261 = unwrapped_fields1260[1] + pretty_name(pp, field1261) newline(pp) - field1230 = unwrapped_fields1228[2] - pretty_epoch(pp, field1230) + field1262 = unwrapped_fields1260[2] + pretty_epoch(pp, field1262) dedent!(pp) write(pp, ")") end @@ -4348,34 +4455,34 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1237 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1237) - write(pp, flat1237) + flat1269 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1269) + write(pp, flat1269) return nothing else - function _t1675(_dollar_dollar) + function _t1721(_dollar_dollar) if _dollar_dollar.name != "abort" - _t1676 = _dollar_dollar.name + _t1722 = _dollar_dollar.name else - _t1676 = nothing + _t1722 = nothing end - return (_t1676, _dollar_dollar.relation_id,) + return (_t1722, _dollar_dollar.relation_id,) end - _t1677 = _t1675(msg) - fields1232 = _t1677 - unwrapped_fields1233 = fields1232 + _t1723 = _t1721(msg) + fields1264 = _t1723 + unwrapped_fields1265 = fields1264 write(pp, "(") write(pp, "abort") indent_sexp!(pp) - field1234 = unwrapped_fields1233[1] - if !isnothing(field1234) + field1266 = unwrapped_fields1265[1] + if !isnothing(field1266) newline(pp) - opt_val1235 = field1234 - pretty_name(pp, opt_val1235) + opt_val1267 = field1266 + pretty_name(pp, opt_val1267) end newline(pp) - field1236 = unwrapped_fields1233[2] - pretty_relation_id(pp, field1236) + field1268 = unwrapped_fields1265[2] + pretty_relation_id(pp, field1268) dedent!(pp) write(pp, ")") end @@ -4383,22 +4490,22 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1240 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1240) - write(pp, flat1240) + flat1272 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1272) + write(pp, flat1272) return nothing else - function _t1678(_dollar_dollar) + function _t1724(_dollar_dollar) return _get_oneof_field(_dollar_dollar, :csv_config) end - _t1679 = _t1678(msg) - fields1238 = _t1679 - unwrapped_fields1239 = fields1238 + _t1725 = _t1724(msg) + fields1270 = _t1725 + unwrapped_fields1271 = fields1270 write(pp, "(") write(pp, "export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped_fields1239) + pretty_export_csv_config(pp, unwrapped_fields1271) dedent!(pp) write(pp, ")") end @@ -4406,30 +4513,30 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1246 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1246) - write(pp, flat1246) + flat1278 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1278) + write(pp, flat1278) return nothing else - function _t1680(_dollar_dollar) - _t1681 = deconstruct_export_csv_config(pp, _dollar_dollar) - return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1681,) + function _t1726(_dollar_dollar) + _t1727 = deconstruct_export_csv_config(pp, _dollar_dollar) + return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1727,) end - _t1682 = _t1680(msg) - fields1241 = _t1682 - unwrapped_fields1242 = fields1241 + _t1728 = _t1726(msg) + fields1273 = _t1728 + unwrapped_fields1274 = fields1273 write(pp, "(") write(pp, "export_csv_config") indent_sexp!(pp) newline(pp) - field1243 = unwrapped_fields1242[1] - pretty_export_csv_path(pp, field1243) + field1275 = unwrapped_fields1274[1] + pretty_export_csv_path(pp, field1275) newline(pp) - field1244 = unwrapped_fields1242[2] - pretty_export_csv_columns(pp, field1244) + field1276 = unwrapped_fields1274[2] + pretty_export_csv_columns(pp, field1276) newline(pp) - field1245 = unwrapped_fields1242[3] - pretty_config_dict(pp, field1245) + field1277 = unwrapped_fields1274[3] + pretty_config_dict(pp, field1277) dedent!(pp) write(pp, ")") end @@ -4437,17 +4544,17 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1248 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1248) - write(pp, flat1248) + flat1280 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1280) + write(pp, flat1280) return nothing else - fields1247 = msg + fields1279 = msg write(pp, "(") write(pp, "path") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1247)) + write(pp, format_string(pp, fields1279)) dedent!(pp) write(pp, ")") end @@ -4455,23 +4562,23 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1252 = try_flat(pp, msg, pretty_export_csv_columns) - if !isnothing(flat1252) - write(pp, flat1252) + flat1284 = try_flat(pp, msg, pretty_export_csv_columns) + if !isnothing(flat1284) + write(pp, flat1284) return nothing else - fields1249 = msg + fields1281 = msg write(pp, "(") write(pp, "columns") indent_sexp!(pp) - if !isempty(fields1249) + if !isempty(fields1281) newline(pp) - for (i1683, elem1250) in enumerate(fields1249) - i1251 = i1683 - 1 - if (i1251 > 0) + for (i1729, elem1282) in enumerate(fields1281) + i1283 = i1729 - 1 + if (i1283 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1250) + pretty_export_csv_column(pp, elem1282) end end dedent!(pp) @@ -4481,26 +4588,26 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCS end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1257 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1257) - write(pp, flat1257) + flat1289 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1289) + write(pp, flat1289) return nothing else - function _t1684(_dollar_dollar) + function _t1730(_dollar_dollar) return (_dollar_dollar.column_name, _dollar_dollar.column_data,) end - _t1685 = _t1684(msg) - fields1253 = _t1685 - unwrapped_fields1254 = fields1253 + _t1731 = _t1730(msg) + fields1285 = _t1731 + unwrapped_fields1286 = fields1285 write(pp, "(") write(pp, "column") indent_sexp!(pp) newline(pp) - field1255 = unwrapped_fields1254[1] - write(pp, format_string(pp, field1255)) + field1287 = unwrapped_fields1286[1] + write(pp, format_string(pp, field1287)) newline(pp) - field1256 = unwrapped_fields1254[2] - pretty_relation_id(pp, field1256) + field1288 = unwrapped_fields1286[2] + pretty_relation_id(pp, field1288) dedent!(pp) write(pp, ")") end @@ -4513,12 +4620,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1723, _rid) in enumerate(msg.ids) - _idx = i1723 - 1 + for (i1770, _rid) in enumerate(msg.ids) + _idx = i1770 - 1 newline(pp) write(pp, "(") - _t1724 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1724) + _t1771 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1771) write(pp, " ") write(pp, format_string(pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -4591,8 +4698,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe newline(pp) write(pp, ":keys ") write(pp, "(") - for (i1725, _elem) in enumerate(msg.keys) - _idx = i1725 - 1 + for (i1772, _elem) in enumerate(msg.keys) + _idx = i1772 - 1 if (_idx > 0) write(pp, " ") end @@ -4602,8 +4709,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe newline(pp) write(pp, ":values ") write(pp, "(") - for (i1726, _elem) in enumerate(msg.values) - _idx = i1726 - 1 + for (i1773, _elem) in enumerate(msg.values) + _idx = i1773 - 1 if (_idx > 0) write(pp, " ") end @@ -4745,6 +4852,7 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVLocator) = pretty_csvlocator(pp, _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVConfig) = pretty_csv_config(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.CSVColumn}) = pretty_csv_columns(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVColumn) = pretty_csv_column(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}) = pretty_csv_column_tail(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Undefine) = pretty_undefine(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Context) = pretty_context(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Snapshot) = pretty_snapshot(pp, x) diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index b4d262b9..518de5f7 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl @@ -2022,11 +2022,11 @@ end r3 = RelationId(id_low=2, id_high=0) t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType())) - c1 = CSVColumn(column_name="age", target_id=r1, types=[t1]) - c2 = CSVColumn(column_name="age", target_id=r2, types=[t1]) - c3 = CSVColumn(column_name="name", target_id=r1, types=[t1]) - c4 = CSVColumn(column_name="age", target_id=r3, types=[t1]) - c5 = CSVColumn(column_name="age", target_id=r1, types=[t1]) + c1 = CSVColumn(column_path=["age"], target_id=r1, types=[t1]) + c2 = CSVColumn(column_path=["age"], target_id=r2, types=[t1]) + c3 = CSVColumn(column_path=["name"], target_id=r1, types=[t1]) + c4 = CSVColumn(column_path=["age"], target_id=r3, types=[t1]) + c5 = CSVColumn(column_path=["age"], target_id=r1, types=[t1]) # Equality and inequality @test c1 == c2 @@ -2096,7 +2096,7 @@ end cfg2 = CSVConfig(header_row=1, skip=0, new_line="\n", delimiter=",", quotechar="\"", escapechar="\\", comment="", missing_strings=[], decimal_separator=".", encoding="", compression="") r1 = RelationId(id_low=1, id_high=0) t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType())) - col1 = CSVColumn(column_name="age", target_id=r1, types=[t1]) + col1 = CSVColumn(column_path=["age"], target_id=r1, types=[t1]) d1 = CSVData(locator=loc1, config=cfg1, columns=[col1], asof="2024-01-01") d2 = CSVData(locator=loc2, config=cfg2, columns=[col1], asof="2024-01-01") @@ -2138,7 +2138,7 @@ end betree1 = BeTreeRelation(name=r1, relation_info=info1) loc1 = CSVLocator(paths=["/file.csv"], inline_data=UInt8[]) cfg1 = CSVConfig(header_row=1, skip=0, new_line="\n", delimiter=",", quotechar="\"", escapechar="\\", comment="", missing_strings=[], decimal_separator=".", encoding="", compression="") - col1 = CSVColumn(column_name="col", target_id=r1, types=[t1]) + col1 = CSVColumn(column_path=["col"], target_id=r1, types=[t1]) csv1 = CSVData(locator=loc1, config=cfg1, columns=[col1], asof="") d1 = Data(data_type=OneOf(:rel_edb, edb1)) diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 2c023fb0..bf5336bf 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -298,177 +298,177 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: Optional[logic_pb2.Value], default: int) -> int: if value is not None: assert value is not None - _t1311 = value.HasField("int_value") + _t1348 = value.HasField("int_value") else: - _t1311 = False - if _t1311: + _t1348 = False + if _t1348: assert value is not None return int(value.int_value) else: - _t1312 = None + _t1349 = None return int(default) def _extract_value_int64(self, value: Optional[logic_pb2.Value], default: int) -> int: if value is not None: assert value is not None - _t1313 = value.HasField("int_value") + _t1350 = value.HasField("int_value") else: - _t1313 = False - if _t1313: + _t1350 = False + if _t1350: assert value is not None return value.int_value else: - _t1314 = None + _t1351 = None return default def _extract_value_string(self, value: Optional[logic_pb2.Value], default: str) -> str: if value is not None: assert value is not None - _t1315 = value.HasField("string_value") + _t1352 = value.HasField("string_value") else: - _t1315 = False - if _t1315: + _t1352 = False + if _t1352: assert value is not None return value.string_value else: - _t1316 = None + _t1353 = None return default def _extract_value_boolean(self, value: Optional[logic_pb2.Value], default: bool) -> bool: if value is not None: assert value is not None - _t1317 = value.HasField("boolean_value") + _t1354 = value.HasField("boolean_value") else: - _t1317 = False - if _t1317: + _t1354 = False + if _t1354: assert value is not None return value.boolean_value else: - _t1318 = None + _t1355 = None return default def _extract_value_string_list(self, value: Optional[logic_pb2.Value], default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t1319 = value.HasField("string_value") + _t1356 = value.HasField("string_value") else: - _t1319 = False - if _t1319: + _t1356 = False + if _t1356: assert value is not None return [value.string_value] else: - _t1320 = None + _t1357 = None return default def _try_extract_value_int64(self, value: Optional[logic_pb2.Value]) -> Optional[int]: if value is not None: assert value is not None - _t1321 = value.HasField("int_value") + _t1358 = value.HasField("int_value") else: - _t1321 = False - if _t1321: + _t1358 = False + if _t1358: assert value is not None return value.int_value else: - _t1322 = None + _t1359 = None return None def _try_extract_value_float64(self, value: Optional[logic_pb2.Value]) -> Optional[float]: if value is not None: assert value is not None - _t1323 = value.HasField("float_value") + _t1360 = value.HasField("float_value") else: - _t1323 = False - if _t1323: + _t1360 = False + if _t1360: assert value is not None return value.float_value else: - _t1324 = None + _t1361 = None return None def _try_extract_value_bytes(self, value: Optional[logic_pb2.Value]) -> Optional[bytes]: if value is not None: assert value is not None - _t1325 = value.HasField("string_value") + _t1362 = value.HasField("string_value") else: - _t1325 = False - if _t1325: + _t1362 = False + if _t1362: assert value is not None return value.string_value.encode() else: - _t1326 = None + _t1363 = None return None def _try_extract_value_uint128(self, value: Optional[logic_pb2.Value]) -> Optional[logic_pb2.UInt128Value]: if value is not None: assert value is not None - _t1327 = value.HasField("uint128_value") + _t1364 = value.HasField("uint128_value") else: - _t1327 = False - if _t1327: + _t1364 = False + if _t1364: assert value is not None return value.uint128_value else: - _t1328 = None + _t1365 = None return None def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t1329 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t1329 - _t1330 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t1330 - _t1331 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t1331 - _t1332 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t1332 - _t1333 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t1333 - _t1334 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t1334 - _t1335 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t1335 - _t1336 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t1336 - _t1337 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t1337 - _t1338 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t1338 - _t1339 = self._extract_value_string(config.get("csv_compression"), "auto") - compression = _t1339 - _t1340 = 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) - return _t1340 + _t1366 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t1366 + _t1367 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t1367 + _t1368 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t1368 + _t1369 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t1369 + _t1370 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t1370 + _t1371 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t1371 + _t1372 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t1372 + _t1373 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t1373 + _t1374 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t1374 + _t1375 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t1375 + _t1376 = self._extract_value_string(config.get("csv_compression"), "auto") + compression = _t1376 + _t1377 = 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) + return _t1377 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) - _t1341 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t1341 - _t1342 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t1342 - _t1343 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t1343 - _t1344 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t1344 - _t1345 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t1345 - _t1346 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t1346 - _t1347 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t1347 - _t1348 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t1348 - _t1349 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t1349 - _t1350 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t1350 - _t1351 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t1351 + _t1378 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t1378 + _t1379 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t1379 + _t1380 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t1380 + _t1381 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t1381 + _t1382 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t1382 + _t1383 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t1383 + _t1384 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t1384 + _t1385 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t1385 + _t1386 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t1386 + _t1387 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t1387 + _t1388 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t1388 def default_configure(self) -> transactions_pb2.Configure: - _t1352 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t1352 - _t1353 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t1353 + _t1389 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t1389 + _t1390 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t1390 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -485,31 +485,42 @@ 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 - _t1354 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t1354 - _t1355 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t1355 - _t1356 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t1356 + _t1391 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t1391 + _t1392 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t1392 + _t1393 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t1393 def 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) - _t1357 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t1357 - _t1358 = self._extract_value_string(config.get("compression"), "") - compression = _t1358 - _t1359 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t1359 - _t1360 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t1360 - _t1361 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t1361 - _t1362 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t1362 - _t1363 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t1363 - _t1364 = 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 _t1364 + _t1394 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t1394 + _t1395 = self._extract_value_string(config.get("compression"), "") + compression = _t1395 + _t1396 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t1396 + _t1397 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t1397 + _t1398 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t1398 + _t1399 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t1399 + _t1400 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t1400 + _t1401 = 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 _t1401 + + def construct_csv_column(self, path: Sequence[str], tail: Optional[tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]]) -> logic_pb2.CSVColumn: + if tail is not None: + assert tail is not None + t = tail + _t1403 = logic_pb2.CSVColumn(column_path=path, target_id=t[0], types=t[1]) + return _t1403 + else: + _t1402 = None + _t1404 = logic_pb2.CSVColumn(column_path=path, target_id=None, types=[]) + return _t1404 # --- Parse methods --- @@ -517,2336 +528,2407 @@ def parse_transaction(self) -> transactions_pb2.Transaction: self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t713 = self.parse_configure() - _t712 = _t713 + _t737 = self.parse_configure() + _t736 = _t737 else: - _t712 = None - configure356 = _t712 + _t736 = None + configure368 = _t736 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t715 = self.parse_sync() - _t714 = _t715 - else: - _t714 = None - sync357 = _t714 - xs358 = [] - cond359 = self.match_lookahead_literal("(", 0) - while cond359: - _t716 = self.parse_epoch() - item360 = _t716 - xs358.append(item360) - cond359 = self.match_lookahead_literal("(", 0) - epochs361 = xs358 - self.consume_literal(")") - _t717 = self.default_configure() - _t718 = transactions_pb2.Transaction(epochs=epochs361, configure=(configure356 if configure356 is not None else _t717), sync=sync357) - return _t718 + _t739 = self.parse_sync() + _t738 = _t739 + else: + _t738 = None + sync369 = _t738 + xs370 = [] + cond371 = self.match_lookahead_literal("(", 0) + while cond371: + _t740 = self.parse_epoch() + item372 = _t740 + xs370.append(item372) + cond371 = self.match_lookahead_literal("(", 0) + epochs373 = xs370 + self.consume_literal(")") + _t741 = self.default_configure() + _t742 = transactions_pb2.Transaction(epochs=epochs373, configure=(configure368 if configure368 is not None else _t741), sync=sync369) + return _t742 def parse_configure(self) -> transactions_pb2.Configure: self.consume_literal("(") self.consume_literal("configure") - _t719 = self.parse_config_dict() - config_dict362 = _t719 + _t743 = self.parse_config_dict() + config_dict374 = _t743 self.consume_literal(")") - _t720 = self.construct_configure(config_dict362) - return _t720 + _t744 = self.construct_configure(config_dict374) + return _t744 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs363 = [] - cond364 = self.match_lookahead_literal(":", 0) - while cond364: - _t721 = self.parse_config_key_value() - item365 = _t721 - xs363.append(item365) - cond364 = self.match_lookahead_literal(":", 0) - config_key_values366 = xs363 + xs375 = [] + cond376 = self.match_lookahead_literal(":", 0) + while cond376: + _t745 = self.parse_config_key_value() + item377 = _t745 + xs375.append(item377) + cond376 = self.match_lookahead_literal(":", 0) + config_key_values378 = xs375 self.consume_literal("}") - return config_key_values366 + return config_key_values378 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol367 = self.consume_terminal("SYMBOL") - _t722 = self.parse_value() - value368 = _t722 - return (symbol367, value368,) + symbol379 = self.consume_terminal("SYMBOL") + _t746 = self.parse_value() + value380 = _t746 + return (symbol379, value380,) def parse_value(self) -> logic_pb2.Value: if self.match_lookahead_literal("true", 0): - _t723 = 9 + _t747 = 9 else: if self.match_lookahead_literal("missing", 0): - _t724 = 8 + _t748 = 8 else: if self.match_lookahead_literal("false", 0): - _t725 = 9 + _t749 = 9 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t727 = 1 + _t751 = 1 else: if self.match_lookahead_literal("date", 1): - _t728 = 0 + _t752 = 0 else: - _t728 = -1 - _t727 = _t728 - _t726 = _t727 + _t752 = -1 + _t751 = _t752 + _t750 = _t751 else: if self.match_lookahead_terminal("UINT128", 0): - _t729 = 5 + _t753 = 5 else: if self.match_lookahead_terminal("STRING", 0): - _t730 = 2 + _t754 = 2 else: if self.match_lookahead_terminal("INT128", 0): - _t731 = 6 + _t755 = 6 else: if self.match_lookahead_terminal("INT", 0): - _t732 = 3 + _t756 = 3 else: if self.match_lookahead_terminal("FLOAT", 0): - _t733 = 4 + _t757 = 4 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t734 = 7 + _t758 = 7 else: - _t734 = -1 - _t733 = _t734 - _t732 = _t733 - _t731 = _t732 - _t730 = _t731 - _t729 = _t730 - _t726 = _t729 - _t725 = _t726 - _t724 = _t725 - _t723 = _t724 - prediction369 = _t723 - if prediction369 == 9: - _t736 = self.parse_boolean_value() - boolean_value378 = _t736 - _t737 = logic_pb2.Value(boolean_value=boolean_value378) - _t735 = _t737 - else: - if prediction369 == 8: + _t758 = -1 + _t757 = _t758 + _t756 = _t757 + _t755 = _t756 + _t754 = _t755 + _t753 = _t754 + _t750 = _t753 + _t749 = _t750 + _t748 = _t749 + _t747 = _t748 + prediction381 = _t747 + if prediction381 == 9: + _t760 = self.parse_boolean_value() + boolean_value390 = _t760 + _t761 = logic_pb2.Value(boolean_value=boolean_value390) + _t759 = _t761 + else: + if prediction381 == 8: self.consume_literal("missing") - _t739 = logic_pb2.MissingValue() - _t740 = logic_pb2.Value(missing_value=_t739) - _t738 = _t740 + _t763 = logic_pb2.MissingValue() + _t764 = logic_pb2.Value(missing_value=_t763) + _t762 = _t764 else: - if prediction369 == 7: - decimal377 = self.consume_terminal("DECIMAL") - _t742 = logic_pb2.Value(decimal_value=decimal377) - _t741 = _t742 + if prediction381 == 7: + decimal389 = self.consume_terminal("DECIMAL") + _t766 = logic_pb2.Value(decimal_value=decimal389) + _t765 = _t766 else: - if prediction369 == 6: - int128376 = self.consume_terminal("INT128") - _t744 = logic_pb2.Value(int128_value=int128376) - _t743 = _t744 + if prediction381 == 6: + int128388 = self.consume_terminal("INT128") + _t768 = logic_pb2.Value(int128_value=int128388) + _t767 = _t768 else: - if prediction369 == 5: - uint128375 = self.consume_terminal("UINT128") - _t746 = logic_pb2.Value(uint128_value=uint128375) - _t745 = _t746 + if prediction381 == 5: + uint128387 = self.consume_terminal("UINT128") + _t770 = logic_pb2.Value(uint128_value=uint128387) + _t769 = _t770 else: - if prediction369 == 4: - float374 = self.consume_terminal("FLOAT") - _t748 = logic_pb2.Value(float_value=float374) - _t747 = _t748 + if prediction381 == 4: + float386 = self.consume_terminal("FLOAT") + _t772 = logic_pb2.Value(float_value=float386) + _t771 = _t772 else: - if prediction369 == 3: - int373 = self.consume_terminal("INT") - _t750 = logic_pb2.Value(int_value=int373) - _t749 = _t750 + if prediction381 == 3: + int385 = self.consume_terminal("INT") + _t774 = logic_pb2.Value(int_value=int385) + _t773 = _t774 else: - if prediction369 == 2: - string372 = self.consume_terminal("STRING") - _t752 = logic_pb2.Value(string_value=string372) - _t751 = _t752 + if prediction381 == 2: + string384 = self.consume_terminal("STRING") + _t776 = logic_pb2.Value(string_value=string384) + _t775 = _t776 else: - if prediction369 == 1: - _t754 = self.parse_datetime() - datetime371 = _t754 - _t755 = logic_pb2.Value(datetime_value=datetime371) - _t753 = _t755 + if prediction381 == 1: + _t778 = self.parse_datetime() + datetime383 = _t778 + _t779 = logic_pb2.Value(datetime_value=datetime383) + _t777 = _t779 else: - if prediction369 == 0: - _t757 = self.parse_date() - date370 = _t757 - _t758 = logic_pb2.Value(date_value=date370) - _t756 = _t758 + if prediction381 == 0: + _t781 = self.parse_date() + date382 = _t781 + _t782 = logic_pb2.Value(date_value=date382) + _t780 = _t782 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t753 = _t756 - _t751 = _t753 - _t749 = _t751 - _t747 = _t749 - _t745 = _t747 - _t743 = _t745 - _t741 = _t743 - _t738 = _t741 - _t735 = _t738 - return _t735 + _t777 = _t780 + _t775 = _t777 + _t773 = _t775 + _t771 = _t773 + _t769 = _t771 + _t767 = _t769 + _t765 = _t767 + _t762 = _t765 + _t759 = _t762 + return _t759 def parse_date(self) -> logic_pb2.DateValue: self.consume_literal("(") self.consume_literal("date") - int379 = self.consume_terminal("INT") - int_3380 = self.consume_terminal("INT") - int_4381 = self.consume_terminal("INT") + int391 = self.consume_terminal("INT") + int_3392 = self.consume_terminal("INT") + int_4393 = self.consume_terminal("INT") self.consume_literal(")") - _t759 = logic_pb2.DateValue(year=int(int379), month=int(int_3380), day=int(int_4381)) - return _t759 + _t783 = logic_pb2.DateValue(year=int(int391), month=int(int_3392), day=int(int_4393)) + return _t783 def parse_datetime(self) -> logic_pb2.DateTimeValue: self.consume_literal("(") self.consume_literal("datetime") - int382 = self.consume_terminal("INT") - int_3383 = self.consume_terminal("INT") - int_4384 = self.consume_terminal("INT") - int_5385 = self.consume_terminal("INT") - int_6386 = self.consume_terminal("INT") - int_7387 = self.consume_terminal("INT") + int394 = self.consume_terminal("INT") + int_3395 = self.consume_terminal("INT") + int_4396 = self.consume_terminal("INT") + int_5397 = self.consume_terminal("INT") + int_6398 = self.consume_terminal("INT") + int_7399 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t760 = self.consume_terminal("INT") + _t784 = self.consume_terminal("INT") else: - _t760 = None - int_8388 = _t760 + _t784 = None + int_8400 = _t784 self.consume_literal(")") - _t761 = logic_pb2.DateTimeValue(year=int(int382), month=int(int_3383), day=int(int_4384), hour=int(int_5385), minute=int(int_6386), second=int(int_7387), microsecond=int((int_8388 if int_8388 is not None else 0))) - return _t761 + _t785 = logic_pb2.DateTimeValue(year=int(int394), month=int(int_3395), day=int(int_4396), hour=int(int_5397), minute=int(int_6398), second=int(int_7399), microsecond=int((int_8400 if int_8400 is not None else 0))) + return _t785 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t762 = 0 + _t786 = 0 else: if self.match_lookahead_literal("false", 0): - _t763 = 1 + _t787 = 1 else: - _t763 = -1 - _t762 = _t763 - prediction389 = _t762 - if prediction389 == 1: + _t787 = -1 + _t786 = _t787 + prediction401 = _t786 + if prediction401 == 1: self.consume_literal("false") - _t764 = False + _t788 = False else: - if prediction389 == 0: + if prediction401 == 0: self.consume_literal("true") - _t765 = True + _t789 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t764 = _t765 - return _t764 + _t788 = _t789 + return _t788 def parse_sync(self) -> transactions_pb2.Sync: self.consume_literal("(") self.consume_literal("sync") - xs390 = [] - cond391 = self.match_lookahead_literal(":", 0) - while cond391: - _t766 = self.parse_fragment_id() - item392 = _t766 - xs390.append(item392) - cond391 = self.match_lookahead_literal(":", 0) - fragment_ids393 = xs390 - self.consume_literal(")") - _t767 = transactions_pb2.Sync(fragments=fragment_ids393) - return _t767 + xs402 = [] + cond403 = self.match_lookahead_literal(":", 0) + while cond403: + _t790 = self.parse_fragment_id() + item404 = _t790 + xs402.append(item404) + cond403 = self.match_lookahead_literal(":", 0) + fragment_ids405 = xs402 + self.consume_literal(")") + _t791 = transactions_pb2.Sync(fragments=fragment_ids405) + return _t791 def parse_fragment_id(self) -> fragments_pb2.FragmentId: self.consume_literal(":") - symbol394 = self.consume_terminal("SYMBOL") - return fragments_pb2.FragmentId(id=symbol394.encode()) + symbol406 = self.consume_terminal("SYMBOL") + return fragments_pb2.FragmentId(id=symbol406.encode()) def parse_epoch(self) -> transactions_pb2.Epoch: self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t769 = self.parse_epoch_writes() - _t768 = _t769 + _t793 = self.parse_epoch_writes() + _t792 = _t793 else: - _t768 = None - epoch_writes395 = _t768 + _t792 = None + epoch_writes407 = _t792 if self.match_lookahead_literal("(", 0): - _t771 = self.parse_epoch_reads() - _t770 = _t771 + _t795 = self.parse_epoch_reads() + _t794 = _t795 else: - _t770 = None - epoch_reads396 = _t770 + _t794 = None + epoch_reads408 = _t794 self.consume_literal(")") - _t772 = transactions_pb2.Epoch(writes=(epoch_writes395 if epoch_writes395 is not None else []), reads=(epoch_reads396 if epoch_reads396 is not None else [])) - return _t772 + _t796 = transactions_pb2.Epoch(writes=(epoch_writes407 if epoch_writes407 is not None else []), reads=(epoch_reads408 if epoch_reads408 is not None else [])) + return _t796 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs397 = [] - cond398 = self.match_lookahead_literal("(", 0) - while cond398: - _t773 = self.parse_write() - item399 = _t773 - xs397.append(item399) - cond398 = self.match_lookahead_literal("(", 0) - writes400 = xs397 + xs409 = [] + cond410 = self.match_lookahead_literal("(", 0) + while cond410: + _t797 = self.parse_write() + item411 = _t797 + xs409.append(item411) + cond410 = self.match_lookahead_literal("(", 0) + writes412 = xs409 self.consume_literal(")") - return writes400 + return writes412 def parse_write(self) -> transactions_pb2.Write: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t775 = 1 + _t799 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t776 = 3 + _t800 = 3 else: if self.match_lookahead_literal("define", 1): - _t777 = 0 + _t801 = 0 else: if self.match_lookahead_literal("context", 1): - _t778 = 2 + _t802 = 2 else: - _t778 = -1 - _t777 = _t778 - _t776 = _t777 - _t775 = _t776 - _t774 = _t775 - else: - _t774 = -1 - prediction401 = _t774 - if prediction401 == 3: - _t780 = self.parse_snapshot() - snapshot405 = _t780 - _t781 = transactions_pb2.Write(snapshot=snapshot405) - _t779 = _t781 - else: - if prediction401 == 2: - _t783 = self.parse_context() - context404 = _t783 - _t784 = transactions_pb2.Write(context=context404) - _t782 = _t784 + _t802 = -1 + _t801 = _t802 + _t800 = _t801 + _t799 = _t800 + _t798 = _t799 + else: + _t798 = -1 + prediction413 = _t798 + if prediction413 == 3: + _t804 = self.parse_snapshot() + snapshot417 = _t804 + _t805 = transactions_pb2.Write(snapshot=snapshot417) + _t803 = _t805 + else: + if prediction413 == 2: + _t807 = self.parse_context() + context416 = _t807 + _t808 = transactions_pb2.Write(context=context416) + _t806 = _t808 else: - if prediction401 == 1: - _t786 = self.parse_undefine() - undefine403 = _t786 - _t787 = transactions_pb2.Write(undefine=undefine403) - _t785 = _t787 + if prediction413 == 1: + _t810 = self.parse_undefine() + undefine415 = _t810 + _t811 = transactions_pb2.Write(undefine=undefine415) + _t809 = _t811 else: - if prediction401 == 0: - _t789 = self.parse_define() - define402 = _t789 - _t790 = transactions_pb2.Write(define=define402) - _t788 = _t790 + if prediction413 == 0: + _t813 = self.parse_define() + define414 = _t813 + _t814 = transactions_pb2.Write(define=define414) + _t812 = _t814 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t785 = _t788 - _t782 = _t785 - _t779 = _t782 - return _t779 + _t809 = _t812 + _t806 = _t809 + _t803 = _t806 + return _t803 def parse_define(self) -> transactions_pb2.Define: self.consume_literal("(") self.consume_literal("define") - _t791 = self.parse_fragment() - fragment406 = _t791 + _t815 = self.parse_fragment() + fragment418 = _t815 self.consume_literal(")") - _t792 = transactions_pb2.Define(fragment=fragment406) - return _t792 + _t816 = transactions_pb2.Define(fragment=fragment418) + return _t816 def parse_fragment(self) -> fragments_pb2.Fragment: self.consume_literal("(") self.consume_literal("fragment") - _t793 = self.parse_new_fragment_id() - new_fragment_id407 = _t793 - xs408 = [] - cond409 = self.match_lookahead_literal("(", 0) - while cond409: - _t794 = self.parse_declaration() - item410 = _t794 - xs408.append(item410) - cond409 = self.match_lookahead_literal("(", 0) - declarations411 = xs408 - self.consume_literal(")") - return self.construct_fragment(new_fragment_id407, declarations411) + _t817 = self.parse_new_fragment_id() + new_fragment_id419 = _t817 + xs420 = [] + cond421 = self.match_lookahead_literal("(", 0) + while cond421: + _t818 = self.parse_declaration() + item422 = _t818 + xs420.append(item422) + cond421 = self.match_lookahead_literal("(", 0) + declarations423 = xs420 + self.consume_literal(")") + return self.construct_fragment(new_fragment_id419, declarations423) def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - _t795 = self.parse_fragment_id() - fragment_id412 = _t795 - self.start_fragment(fragment_id412) - return fragment_id412 + _t819 = self.parse_fragment_id() + fragment_id424 = _t819 + self.start_fragment(fragment_id424) + return fragment_id424 def parse_declaration(self) -> logic_pb2.Declaration: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("rel_edb", 1): - _t797 = 3 + _t821 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t798 = 2 + _t822 = 2 else: if self.match_lookahead_literal("def", 1): - _t799 = 0 + _t823 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t800 = 3 + _t824 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t801 = 3 + _t825 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t802 = 1 + _t826 = 1 else: - _t802 = -1 - _t801 = _t802 - _t800 = _t801 - _t799 = _t800 - _t798 = _t799 - _t797 = _t798 - _t796 = _t797 - else: - _t796 = -1 - prediction413 = _t796 - if prediction413 == 3: - _t804 = self.parse_data() - data417 = _t804 - _t805 = logic_pb2.Declaration(data=data417) - _t803 = _t805 + _t826 = -1 + _t825 = _t826 + _t824 = _t825 + _t823 = _t824 + _t822 = _t823 + _t821 = _t822 + _t820 = _t821 else: - if prediction413 == 2: - _t807 = self.parse_constraint() - constraint416 = _t807 - _t808 = logic_pb2.Declaration(constraint=constraint416) - _t806 = _t808 + _t820 = -1 + prediction425 = _t820 + if prediction425 == 3: + _t828 = self.parse_data() + data429 = _t828 + _t829 = logic_pb2.Declaration(data=data429) + _t827 = _t829 + else: + if prediction425 == 2: + _t831 = self.parse_constraint() + constraint428 = _t831 + _t832 = logic_pb2.Declaration(constraint=constraint428) + _t830 = _t832 else: - if prediction413 == 1: - _t810 = self.parse_algorithm() - algorithm415 = _t810 - _t811 = logic_pb2.Declaration(algorithm=algorithm415) - _t809 = _t811 + if prediction425 == 1: + _t834 = self.parse_algorithm() + algorithm427 = _t834 + _t835 = logic_pb2.Declaration(algorithm=algorithm427) + _t833 = _t835 else: - if prediction413 == 0: - _t813 = self.parse_def() - def414 = _t813 - _t814 = logic_pb2.Declaration() - getattr(_t814, 'def').CopyFrom(def414) - _t812 = _t814 + if prediction425 == 0: + _t837 = self.parse_def() + def426 = _t837 + _t838 = logic_pb2.Declaration() + getattr(_t838, 'def').CopyFrom(def426) + _t836 = _t838 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t809 = _t812 - _t806 = _t809 - _t803 = _t806 - return _t803 + _t833 = _t836 + _t830 = _t833 + _t827 = _t830 + return _t827 def parse_def(self) -> logic_pb2.Def: self.consume_literal("(") self.consume_literal("def") - _t815 = self.parse_relation_id() - relation_id418 = _t815 - _t816 = self.parse_abstraction() - abstraction419 = _t816 + _t839 = self.parse_relation_id() + relation_id430 = _t839 + _t840 = self.parse_abstraction() + abstraction431 = _t840 if self.match_lookahead_literal("(", 0): - _t818 = self.parse_attrs() - _t817 = _t818 + _t842 = self.parse_attrs() + _t841 = _t842 else: - _t817 = None - attrs420 = _t817 + _t841 = None + attrs432 = _t841 self.consume_literal(")") - _t819 = logic_pb2.Def(name=relation_id418, body=abstraction419, attrs=(attrs420 if attrs420 is not None else [])) - return _t819 + _t843 = logic_pb2.Def(name=relation_id430, body=abstraction431, attrs=(attrs432 if attrs432 is not None else [])) + return _t843 def parse_relation_id(self) -> logic_pb2.RelationId: if self.match_lookahead_literal(":", 0): - _t820 = 0 + _t844 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t821 = 1 + _t845 = 1 else: - _t821 = -1 - _t820 = _t821 - prediction421 = _t820 - if prediction421 == 1: - uint128423 = self.consume_terminal("UINT128") - _t822 = logic_pb2.RelationId(id_low=uint128423.low, id_high=uint128423.high) + _t845 = -1 + _t844 = _t845 + prediction433 = _t844 + if prediction433 == 1: + uint128435 = self.consume_terminal("UINT128") + _t846 = logic_pb2.RelationId(id_low=uint128435.low, id_high=uint128435.high) else: - if prediction421 == 0: + if prediction433 == 0: self.consume_literal(":") - symbol422 = self.consume_terminal("SYMBOL") - _t823 = self.relation_id_from_string(symbol422) + symbol434 = self.consume_terminal("SYMBOL") + _t847 = self.relation_id_from_string(symbol434) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t822 = _t823 - return _t822 + _t846 = _t847 + return _t846 def parse_abstraction(self) -> logic_pb2.Abstraction: self.consume_literal("(") - _t824 = self.parse_bindings() - bindings424 = _t824 - _t825 = self.parse_formula() - formula425 = _t825 + _t848 = self.parse_bindings() + bindings436 = _t848 + _t849 = self.parse_formula() + formula437 = _t849 self.consume_literal(")") - _t826 = logic_pb2.Abstraction(vars=(list(bindings424[0]) + list(bindings424[1] if bindings424[1] is not None else [])), value=formula425) - return _t826 + _t850 = logic_pb2.Abstraction(vars=(list(bindings436[0]) + list(bindings436[1] if bindings436[1] is not None else [])), value=formula437) + return _t850 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs426 = [] - cond427 = self.match_lookahead_terminal("SYMBOL", 0) - while cond427: - _t827 = self.parse_binding() - item428 = _t827 - xs426.append(item428) - cond427 = self.match_lookahead_terminal("SYMBOL", 0) - bindings429 = xs426 + xs438 = [] + cond439 = self.match_lookahead_terminal("SYMBOL", 0) + while cond439: + _t851 = self.parse_binding() + item440 = _t851 + xs438.append(item440) + cond439 = self.match_lookahead_terminal("SYMBOL", 0) + bindings441 = xs438 if self.match_lookahead_literal("|", 0): - _t829 = self.parse_value_bindings() - _t828 = _t829 + _t853 = self.parse_value_bindings() + _t852 = _t853 else: - _t828 = None - value_bindings430 = _t828 + _t852 = None + value_bindings442 = _t852 self.consume_literal("]") - return (bindings429, (value_bindings430 if value_bindings430 is not None else []),) + return (bindings441, (value_bindings442 if value_bindings442 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - symbol431 = self.consume_terminal("SYMBOL") + symbol443 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t830 = self.parse_type() - type432 = _t830 - _t831 = logic_pb2.Var(name=symbol431) - _t832 = logic_pb2.Binding(var=_t831, type=type432) - return _t832 + _t854 = self.parse_type() + type444 = _t854 + _t855 = logic_pb2.Var(name=symbol443) + _t856 = logic_pb2.Binding(var=_t855, type=type444) + return _t856 def parse_type(self) -> logic_pb2.Type: if self.match_lookahead_literal("UNKNOWN", 0): - _t833 = 0 + _t857 = 0 else: if self.match_lookahead_literal("UINT128", 0): - _t834 = 4 + _t858 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t835 = 1 + _t859 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t836 = 8 + _t860 = 8 else: if self.match_lookahead_literal("INT128", 0): - _t837 = 5 + _t861 = 5 else: if self.match_lookahead_literal("INT", 0): - _t838 = 2 + _t862 = 2 else: if self.match_lookahead_literal("FLOAT", 0): - _t839 = 3 + _t863 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t840 = 7 + _t864 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t841 = 6 + _t865 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t842 = 10 + _t866 = 10 else: if self.match_lookahead_literal("(", 0): - _t843 = 9 + _t867 = 9 else: - _t843 = -1 - _t842 = _t843 - _t841 = _t842 - _t840 = _t841 - _t839 = _t840 - _t838 = _t839 - _t837 = _t838 - _t836 = _t837 - _t835 = _t836 - _t834 = _t835 - _t833 = _t834 - prediction433 = _t833 - if prediction433 == 10: - _t845 = self.parse_boolean_type() - boolean_type444 = _t845 - _t846 = logic_pb2.Type(boolean_type=boolean_type444) - _t844 = _t846 - else: - if prediction433 == 9: - _t848 = self.parse_decimal_type() - decimal_type443 = _t848 - _t849 = logic_pb2.Type(decimal_type=decimal_type443) - _t847 = _t849 + _t867 = -1 + _t866 = _t867 + _t865 = _t866 + _t864 = _t865 + _t863 = _t864 + _t862 = _t863 + _t861 = _t862 + _t860 = _t861 + _t859 = _t860 + _t858 = _t859 + _t857 = _t858 + prediction445 = _t857 + if prediction445 == 10: + _t869 = self.parse_boolean_type() + boolean_type456 = _t869 + _t870 = logic_pb2.Type(boolean_type=boolean_type456) + _t868 = _t870 + else: + if prediction445 == 9: + _t872 = self.parse_decimal_type() + decimal_type455 = _t872 + _t873 = logic_pb2.Type(decimal_type=decimal_type455) + _t871 = _t873 else: - if prediction433 == 8: - _t851 = self.parse_missing_type() - missing_type442 = _t851 - _t852 = logic_pb2.Type(missing_type=missing_type442) - _t850 = _t852 + if prediction445 == 8: + _t875 = self.parse_missing_type() + missing_type454 = _t875 + _t876 = logic_pb2.Type(missing_type=missing_type454) + _t874 = _t876 else: - if prediction433 == 7: - _t854 = self.parse_datetime_type() - datetime_type441 = _t854 - _t855 = logic_pb2.Type(datetime_type=datetime_type441) - _t853 = _t855 + if prediction445 == 7: + _t878 = self.parse_datetime_type() + datetime_type453 = _t878 + _t879 = logic_pb2.Type(datetime_type=datetime_type453) + _t877 = _t879 else: - if prediction433 == 6: - _t857 = self.parse_date_type() - date_type440 = _t857 - _t858 = logic_pb2.Type(date_type=date_type440) - _t856 = _t858 + if prediction445 == 6: + _t881 = self.parse_date_type() + date_type452 = _t881 + _t882 = logic_pb2.Type(date_type=date_type452) + _t880 = _t882 else: - if prediction433 == 5: - _t860 = self.parse_int128_type() - int128_type439 = _t860 - _t861 = logic_pb2.Type(int128_type=int128_type439) - _t859 = _t861 + if prediction445 == 5: + _t884 = self.parse_int128_type() + int128_type451 = _t884 + _t885 = logic_pb2.Type(int128_type=int128_type451) + _t883 = _t885 else: - if prediction433 == 4: - _t863 = self.parse_uint128_type() - uint128_type438 = _t863 - _t864 = logic_pb2.Type(uint128_type=uint128_type438) - _t862 = _t864 + if prediction445 == 4: + _t887 = self.parse_uint128_type() + uint128_type450 = _t887 + _t888 = logic_pb2.Type(uint128_type=uint128_type450) + _t886 = _t888 else: - if prediction433 == 3: - _t866 = self.parse_float_type() - float_type437 = _t866 - _t867 = logic_pb2.Type(float_type=float_type437) - _t865 = _t867 + if prediction445 == 3: + _t890 = self.parse_float_type() + float_type449 = _t890 + _t891 = logic_pb2.Type(float_type=float_type449) + _t889 = _t891 else: - if prediction433 == 2: - _t869 = self.parse_int_type() - int_type436 = _t869 - _t870 = logic_pb2.Type(int_type=int_type436) - _t868 = _t870 + if prediction445 == 2: + _t893 = self.parse_int_type() + int_type448 = _t893 + _t894 = logic_pb2.Type(int_type=int_type448) + _t892 = _t894 else: - if prediction433 == 1: - _t872 = self.parse_string_type() - string_type435 = _t872 - _t873 = logic_pb2.Type(string_type=string_type435) - _t871 = _t873 + if prediction445 == 1: + _t896 = self.parse_string_type() + string_type447 = _t896 + _t897 = logic_pb2.Type(string_type=string_type447) + _t895 = _t897 else: - if prediction433 == 0: - _t875 = self.parse_unspecified_type() - unspecified_type434 = _t875 - _t876 = logic_pb2.Type(unspecified_type=unspecified_type434) - _t874 = _t876 + if prediction445 == 0: + _t899 = self.parse_unspecified_type() + unspecified_type446 = _t899 + _t900 = logic_pb2.Type(unspecified_type=unspecified_type446) + _t898 = _t900 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t871 = _t874 - _t868 = _t871 - _t865 = _t868 - _t862 = _t865 - _t859 = _t862 - _t856 = _t859 - _t853 = _t856 - _t850 = _t853 - _t847 = _t850 - _t844 = _t847 - return _t844 + _t895 = _t898 + _t892 = _t895 + _t889 = _t892 + _t886 = _t889 + _t883 = _t886 + _t880 = _t883 + _t877 = _t880 + _t874 = _t877 + _t871 = _t874 + _t868 = _t871 + return _t868 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: self.consume_literal("UNKNOWN") - _t877 = logic_pb2.UnspecifiedType() - return _t877 + _t901 = logic_pb2.UnspecifiedType() + return _t901 def parse_string_type(self) -> logic_pb2.StringType: self.consume_literal("STRING") - _t878 = logic_pb2.StringType() - return _t878 + _t902 = logic_pb2.StringType() + return _t902 def parse_int_type(self) -> logic_pb2.IntType: self.consume_literal("INT") - _t879 = logic_pb2.IntType() - return _t879 + _t903 = logic_pb2.IntType() + return _t903 def parse_float_type(self) -> logic_pb2.FloatType: self.consume_literal("FLOAT") - _t880 = logic_pb2.FloatType() - return _t880 + _t904 = logic_pb2.FloatType() + return _t904 def parse_uint128_type(self) -> logic_pb2.UInt128Type: self.consume_literal("UINT128") - _t881 = logic_pb2.UInt128Type() - return _t881 + _t905 = logic_pb2.UInt128Type() + return _t905 def parse_int128_type(self) -> logic_pb2.Int128Type: self.consume_literal("INT128") - _t882 = logic_pb2.Int128Type() - return _t882 + _t906 = logic_pb2.Int128Type() + return _t906 def parse_date_type(self) -> logic_pb2.DateType: self.consume_literal("DATE") - _t883 = logic_pb2.DateType() - return _t883 + _t907 = logic_pb2.DateType() + return _t907 def parse_datetime_type(self) -> logic_pb2.DateTimeType: self.consume_literal("DATETIME") - _t884 = logic_pb2.DateTimeType() - return _t884 + _t908 = logic_pb2.DateTimeType() + return _t908 def parse_missing_type(self) -> logic_pb2.MissingType: self.consume_literal("MISSING") - _t885 = logic_pb2.MissingType() - return _t885 + _t909 = logic_pb2.MissingType() + return _t909 def parse_decimal_type(self) -> logic_pb2.DecimalType: self.consume_literal("(") self.consume_literal("DECIMAL") - int445 = self.consume_terminal("INT") - int_3446 = self.consume_terminal("INT") + int457 = self.consume_terminal("INT") + int_3458 = self.consume_terminal("INT") self.consume_literal(")") - _t886 = logic_pb2.DecimalType(precision=int(int445), scale=int(int_3446)) - return _t886 + _t910 = logic_pb2.DecimalType(precision=int(int457), scale=int(int_3458)) + return _t910 def parse_boolean_type(self) -> logic_pb2.BooleanType: self.consume_literal("BOOLEAN") - _t887 = logic_pb2.BooleanType() - return _t887 + _t911 = logic_pb2.BooleanType() + return _t911 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs447 = [] - cond448 = self.match_lookahead_terminal("SYMBOL", 0) - while cond448: - _t888 = self.parse_binding() - item449 = _t888 - xs447.append(item449) - cond448 = self.match_lookahead_terminal("SYMBOL", 0) - bindings450 = xs447 - return bindings450 + xs459 = [] + cond460 = self.match_lookahead_terminal("SYMBOL", 0) + while cond460: + _t912 = self.parse_binding() + item461 = _t912 + xs459.append(item461) + cond460 = self.match_lookahead_terminal("SYMBOL", 0) + bindings462 = xs459 + return bindings462 def parse_formula(self) -> logic_pb2.Formula: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t890 = 0 + _t914 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t891 = 11 + _t915 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t892 = 3 + _t916 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t893 = 10 + _t917 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t894 = 9 + _t918 = 9 else: if self.match_lookahead_literal("or", 1): - _t895 = 5 + _t919 = 5 else: if self.match_lookahead_literal("not", 1): - _t896 = 6 + _t920 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t897 = 7 + _t921 = 7 else: if self.match_lookahead_literal("false", 1): - _t898 = 1 + _t922 = 1 else: if self.match_lookahead_literal("exists", 1): - _t899 = 2 + _t923 = 2 else: if self.match_lookahead_literal("cast", 1): - _t900 = 12 + _t924 = 12 else: if self.match_lookahead_literal("atom", 1): - _t901 = 8 + _t925 = 8 else: if self.match_lookahead_literal("and", 1): - _t902 = 4 + _t926 = 4 else: if self.match_lookahead_literal(">=", 1): - _t903 = 10 + _t927 = 10 else: if self.match_lookahead_literal(">", 1): - _t904 = 10 + _t928 = 10 else: if self.match_lookahead_literal("=", 1): - _t905 = 10 + _t929 = 10 else: if self.match_lookahead_literal("<=", 1): - _t906 = 10 + _t930 = 10 else: if self.match_lookahead_literal("<", 1): - _t907 = 10 + _t931 = 10 else: if self.match_lookahead_literal("/", 1): - _t908 = 10 + _t932 = 10 else: if self.match_lookahead_literal("-", 1): - _t909 = 10 + _t933 = 10 else: if self.match_lookahead_literal("+", 1): - _t910 = 10 + _t934 = 10 else: if self.match_lookahead_literal("*", 1): - _t911 = 10 + _t935 = 10 else: - _t911 = -1 - _t910 = _t911 - _t909 = _t910 - _t908 = _t909 - _t907 = _t908 - _t906 = _t907 - _t905 = _t906 - _t904 = _t905 - _t903 = _t904 - _t902 = _t903 - _t901 = _t902 - _t900 = _t901 - _t899 = _t900 - _t898 = _t899 - _t897 = _t898 - _t896 = _t897 - _t895 = _t896 - _t894 = _t895 - _t893 = _t894 - _t892 = _t893 - _t891 = _t892 - _t890 = _t891 - _t889 = _t890 - else: - _t889 = -1 - prediction451 = _t889 - if prediction451 == 12: - _t913 = self.parse_cast() - cast464 = _t913 - _t914 = logic_pb2.Formula(cast=cast464) - _t912 = _t914 - else: - if prediction451 == 11: - _t916 = self.parse_rel_atom() - rel_atom463 = _t916 - _t917 = logic_pb2.Formula(rel_atom=rel_atom463) - _t915 = _t917 + _t935 = -1 + _t934 = _t935 + _t933 = _t934 + _t932 = _t933 + _t931 = _t932 + _t930 = _t931 + _t929 = _t930 + _t928 = _t929 + _t927 = _t928 + _t926 = _t927 + _t925 = _t926 + _t924 = _t925 + _t923 = _t924 + _t922 = _t923 + _t921 = _t922 + _t920 = _t921 + _t919 = _t920 + _t918 = _t919 + _t917 = _t918 + _t916 = _t917 + _t915 = _t916 + _t914 = _t915 + _t913 = _t914 + else: + _t913 = -1 + prediction463 = _t913 + if prediction463 == 12: + _t937 = self.parse_cast() + cast476 = _t937 + _t938 = logic_pb2.Formula(cast=cast476) + _t936 = _t938 + else: + if prediction463 == 11: + _t940 = self.parse_rel_atom() + rel_atom475 = _t940 + _t941 = logic_pb2.Formula(rel_atom=rel_atom475) + _t939 = _t941 else: - if prediction451 == 10: - _t919 = self.parse_primitive() - primitive462 = _t919 - _t920 = logic_pb2.Formula(primitive=primitive462) - _t918 = _t920 + if prediction463 == 10: + _t943 = self.parse_primitive() + primitive474 = _t943 + _t944 = logic_pb2.Formula(primitive=primitive474) + _t942 = _t944 else: - if prediction451 == 9: - _t922 = self.parse_pragma() - pragma461 = _t922 - _t923 = logic_pb2.Formula(pragma=pragma461) - _t921 = _t923 + if prediction463 == 9: + _t946 = self.parse_pragma() + pragma473 = _t946 + _t947 = logic_pb2.Formula(pragma=pragma473) + _t945 = _t947 else: - if prediction451 == 8: - _t925 = self.parse_atom() - atom460 = _t925 - _t926 = logic_pb2.Formula(atom=atom460) - _t924 = _t926 + if prediction463 == 8: + _t949 = self.parse_atom() + atom472 = _t949 + _t950 = logic_pb2.Formula(atom=atom472) + _t948 = _t950 else: - if prediction451 == 7: - _t928 = self.parse_ffi() - ffi459 = _t928 - _t929 = logic_pb2.Formula(ffi=ffi459) - _t927 = _t929 + if prediction463 == 7: + _t952 = self.parse_ffi() + ffi471 = _t952 + _t953 = logic_pb2.Formula(ffi=ffi471) + _t951 = _t953 else: - if prediction451 == 6: - _t931 = self.parse_not() - not458 = _t931 - _t932 = logic_pb2.Formula() - getattr(_t932, 'not').CopyFrom(not458) - _t930 = _t932 + if prediction463 == 6: + _t955 = self.parse_not() + not470 = _t955 + _t956 = logic_pb2.Formula() + getattr(_t956, 'not').CopyFrom(not470) + _t954 = _t956 else: - if prediction451 == 5: - _t934 = self.parse_disjunction() - disjunction457 = _t934 - _t935 = logic_pb2.Formula(disjunction=disjunction457) - _t933 = _t935 + if prediction463 == 5: + _t958 = self.parse_disjunction() + disjunction469 = _t958 + _t959 = logic_pb2.Formula(disjunction=disjunction469) + _t957 = _t959 else: - if prediction451 == 4: - _t937 = self.parse_conjunction() - conjunction456 = _t937 - _t938 = logic_pb2.Formula(conjunction=conjunction456) - _t936 = _t938 + if prediction463 == 4: + _t961 = self.parse_conjunction() + conjunction468 = _t961 + _t962 = logic_pb2.Formula(conjunction=conjunction468) + _t960 = _t962 else: - if prediction451 == 3: - _t940 = self.parse_reduce() - reduce455 = _t940 - _t941 = logic_pb2.Formula(reduce=reduce455) - _t939 = _t941 + if prediction463 == 3: + _t964 = self.parse_reduce() + reduce467 = _t964 + _t965 = logic_pb2.Formula(reduce=reduce467) + _t963 = _t965 else: - if prediction451 == 2: - _t943 = self.parse_exists() - exists454 = _t943 - _t944 = logic_pb2.Formula(exists=exists454) - _t942 = _t944 + if prediction463 == 2: + _t967 = self.parse_exists() + exists466 = _t967 + _t968 = logic_pb2.Formula(exists=exists466) + _t966 = _t968 else: - if prediction451 == 1: - _t946 = self.parse_false() - false453 = _t946 - _t947 = logic_pb2.Formula(disjunction=false453) - _t945 = _t947 + if prediction463 == 1: + _t970 = self.parse_false() + false465 = _t970 + _t971 = logic_pb2.Formula(disjunction=false465) + _t969 = _t971 else: - if prediction451 == 0: - _t949 = self.parse_true() - true452 = _t949 - _t950 = logic_pb2.Formula(conjunction=true452) - _t948 = _t950 + if prediction463 == 0: + _t973 = self.parse_true() + true464 = _t973 + _t974 = logic_pb2.Formula(conjunction=true464) + _t972 = _t974 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t945 = _t948 - _t942 = _t945 - _t939 = _t942 - _t936 = _t939 - _t933 = _t936 - _t930 = _t933 - _t927 = _t930 - _t924 = _t927 - _t921 = _t924 - _t918 = _t921 - _t915 = _t918 - _t912 = _t915 - return _t912 + _t969 = _t972 + _t966 = _t969 + _t963 = _t966 + _t960 = _t963 + _t957 = _t960 + _t954 = _t957 + _t951 = _t954 + _t948 = _t951 + _t945 = _t948 + _t942 = _t945 + _t939 = _t942 + _t936 = _t939 + return _t936 def parse_true(self) -> logic_pb2.Conjunction: self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t951 = logic_pb2.Conjunction(args=[]) - return _t951 + _t975 = logic_pb2.Conjunction(args=[]) + return _t975 def parse_false(self) -> logic_pb2.Disjunction: self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t952 = logic_pb2.Disjunction(args=[]) - return _t952 + _t976 = logic_pb2.Disjunction(args=[]) + return _t976 def parse_exists(self) -> logic_pb2.Exists: self.consume_literal("(") self.consume_literal("exists") - _t953 = self.parse_bindings() - bindings465 = _t953 - _t954 = self.parse_formula() - formula466 = _t954 + _t977 = self.parse_bindings() + bindings477 = _t977 + _t978 = self.parse_formula() + formula478 = _t978 self.consume_literal(")") - _t955 = logic_pb2.Abstraction(vars=(list(bindings465[0]) + list(bindings465[1] if bindings465[1] is not None else [])), value=formula466) - _t956 = logic_pb2.Exists(body=_t955) - return _t956 + _t979 = logic_pb2.Abstraction(vars=(list(bindings477[0]) + list(bindings477[1] if bindings477[1] is not None else [])), value=formula478) + _t980 = logic_pb2.Exists(body=_t979) + return _t980 def parse_reduce(self) -> logic_pb2.Reduce: self.consume_literal("(") self.consume_literal("reduce") - _t957 = self.parse_abstraction() - abstraction467 = _t957 - _t958 = self.parse_abstraction() - abstraction_3468 = _t958 - _t959 = self.parse_terms() - terms469 = _t959 - self.consume_literal(")") - _t960 = logic_pb2.Reduce(op=abstraction467, body=abstraction_3468, terms=terms469) - return _t960 + _t981 = self.parse_abstraction() + abstraction479 = _t981 + _t982 = self.parse_abstraction() + abstraction_3480 = _t982 + _t983 = self.parse_terms() + terms481 = _t983 + self.consume_literal(")") + _t984 = logic_pb2.Reduce(op=abstraction479, body=abstraction_3480, terms=terms481) + return _t984 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs470 = [] - cond471 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond471: - _t961 = self.parse_term() - item472 = _t961 - xs470.append(item472) - cond471 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms473 = xs470 + xs482 = [] + cond483 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond483: + _t985 = self.parse_term() + item484 = _t985 + xs482.append(item484) + cond483 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms485 = xs482 self.consume_literal(")") - return terms473 + return terms485 def parse_term(self) -> logic_pb2.Term: if self.match_lookahead_literal("true", 0): - _t962 = 1 + _t986 = 1 else: if self.match_lookahead_literal("missing", 0): - _t963 = 1 + _t987 = 1 else: if self.match_lookahead_literal("false", 0): - _t964 = 1 + _t988 = 1 else: if self.match_lookahead_literal("(", 0): - _t965 = 1 + _t989 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t966 = 1 + _t990 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t967 = 0 + _t991 = 0 else: if self.match_lookahead_terminal("STRING", 0): - _t968 = 1 + _t992 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t969 = 1 + _t993 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t970 = 1 + _t994 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t971 = 1 + _t995 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t972 = 1 + _t996 = 1 else: - _t972 = -1 - _t971 = _t972 - _t970 = _t971 - _t969 = _t970 - _t968 = _t969 - _t967 = _t968 - _t966 = _t967 - _t965 = _t966 - _t964 = _t965 - _t963 = _t964 - _t962 = _t963 - prediction474 = _t962 - if prediction474 == 1: - _t974 = self.parse_constant() - constant476 = _t974 - _t975 = logic_pb2.Term(constant=constant476) - _t973 = _t975 - else: - if prediction474 == 0: - _t977 = self.parse_var() - var475 = _t977 - _t978 = logic_pb2.Term(var=var475) - _t976 = _t978 + _t996 = -1 + _t995 = _t996 + _t994 = _t995 + _t993 = _t994 + _t992 = _t993 + _t991 = _t992 + _t990 = _t991 + _t989 = _t990 + _t988 = _t989 + _t987 = _t988 + _t986 = _t987 + prediction486 = _t986 + if prediction486 == 1: + _t998 = self.parse_constant() + constant488 = _t998 + _t999 = logic_pb2.Term(constant=constant488) + _t997 = _t999 + else: + if prediction486 == 0: + _t1001 = self.parse_var() + var487 = _t1001 + _t1002 = logic_pb2.Term(var=var487) + _t1000 = _t1002 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t973 = _t976 - return _t973 + _t997 = _t1000 + return _t997 def parse_var(self) -> logic_pb2.Var: - symbol477 = self.consume_terminal("SYMBOL") - _t979 = logic_pb2.Var(name=symbol477) - return _t979 + symbol489 = self.consume_terminal("SYMBOL") + _t1003 = logic_pb2.Var(name=symbol489) + return _t1003 def parse_constant(self) -> logic_pb2.Value: - _t980 = self.parse_value() - value478 = _t980 - return value478 + _t1004 = self.parse_value() + value490 = _t1004 + return value490 def parse_conjunction(self) -> logic_pb2.Conjunction: self.consume_literal("(") self.consume_literal("and") - xs479 = [] - cond480 = self.match_lookahead_literal("(", 0) - while cond480: - _t981 = self.parse_formula() - item481 = _t981 - xs479.append(item481) - cond480 = self.match_lookahead_literal("(", 0) - formulas482 = xs479 - self.consume_literal(")") - _t982 = logic_pb2.Conjunction(args=formulas482) - return _t982 + xs491 = [] + cond492 = self.match_lookahead_literal("(", 0) + while cond492: + _t1005 = self.parse_formula() + item493 = _t1005 + xs491.append(item493) + cond492 = self.match_lookahead_literal("(", 0) + formulas494 = xs491 + self.consume_literal(")") + _t1006 = logic_pb2.Conjunction(args=formulas494) + return _t1006 def parse_disjunction(self) -> logic_pb2.Disjunction: self.consume_literal("(") self.consume_literal("or") - xs483 = [] - cond484 = self.match_lookahead_literal("(", 0) - while cond484: - _t983 = self.parse_formula() - item485 = _t983 - xs483.append(item485) - cond484 = self.match_lookahead_literal("(", 0) - formulas486 = xs483 - self.consume_literal(")") - _t984 = logic_pb2.Disjunction(args=formulas486) - return _t984 + xs495 = [] + cond496 = self.match_lookahead_literal("(", 0) + while cond496: + _t1007 = self.parse_formula() + item497 = _t1007 + xs495.append(item497) + cond496 = self.match_lookahead_literal("(", 0) + formulas498 = xs495 + self.consume_literal(")") + _t1008 = logic_pb2.Disjunction(args=formulas498) + return _t1008 def parse_not(self) -> logic_pb2.Not: self.consume_literal("(") self.consume_literal("not") - _t985 = self.parse_formula() - formula487 = _t985 + _t1009 = self.parse_formula() + formula499 = _t1009 self.consume_literal(")") - _t986 = logic_pb2.Not(arg=formula487) - return _t986 + _t1010 = logic_pb2.Not(arg=formula499) + return _t1010 def parse_ffi(self) -> logic_pb2.FFI: self.consume_literal("(") self.consume_literal("ffi") - _t987 = self.parse_name() - name488 = _t987 - _t988 = self.parse_ffi_args() - ffi_args489 = _t988 - _t989 = self.parse_terms() - terms490 = _t989 + _t1011 = self.parse_name() + name500 = _t1011 + _t1012 = self.parse_ffi_args() + ffi_args501 = _t1012 + _t1013 = self.parse_terms() + terms502 = _t1013 self.consume_literal(")") - _t990 = logic_pb2.FFI(name=name488, args=ffi_args489, terms=terms490) - return _t990 + _t1014 = logic_pb2.FFI(name=name500, args=ffi_args501, terms=terms502) + return _t1014 def parse_name(self) -> str: self.consume_literal(":") - symbol491 = self.consume_terminal("SYMBOL") - return symbol491 + symbol503 = self.consume_terminal("SYMBOL") + return symbol503 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs492 = [] - cond493 = self.match_lookahead_literal("(", 0) - while cond493: - _t991 = self.parse_abstraction() - item494 = _t991 - xs492.append(item494) - cond493 = self.match_lookahead_literal("(", 0) - abstractions495 = xs492 + xs504 = [] + cond505 = self.match_lookahead_literal("(", 0) + while cond505: + _t1015 = self.parse_abstraction() + item506 = _t1015 + xs504.append(item506) + cond505 = self.match_lookahead_literal("(", 0) + abstractions507 = xs504 self.consume_literal(")") - return abstractions495 + return abstractions507 def parse_atom(self) -> logic_pb2.Atom: self.consume_literal("(") self.consume_literal("atom") - _t992 = self.parse_relation_id() - relation_id496 = _t992 - xs497 = [] - cond498 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond498: - _t993 = self.parse_term() - item499 = _t993 - xs497.append(item499) - cond498 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms500 = xs497 - self.consume_literal(")") - _t994 = logic_pb2.Atom(name=relation_id496, terms=terms500) - return _t994 + _t1016 = self.parse_relation_id() + relation_id508 = _t1016 + xs509 = [] + cond510 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond510: + _t1017 = self.parse_term() + item511 = _t1017 + xs509.append(item511) + cond510 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms512 = xs509 + self.consume_literal(")") + _t1018 = logic_pb2.Atom(name=relation_id508, terms=terms512) + return _t1018 def parse_pragma(self) -> logic_pb2.Pragma: self.consume_literal("(") self.consume_literal("pragma") - _t995 = self.parse_name() - name501 = _t995 - xs502 = [] - cond503 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond503: - _t996 = self.parse_term() - item504 = _t996 - xs502.append(item504) - cond503 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms505 = xs502 - self.consume_literal(")") - _t997 = logic_pb2.Pragma(name=name501, terms=terms505) - return _t997 + _t1019 = self.parse_name() + name513 = _t1019 + xs514 = [] + cond515 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond515: + _t1020 = self.parse_term() + item516 = _t1020 + xs514.append(item516) + cond515 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms517 = xs514 + self.consume_literal(")") + _t1021 = logic_pb2.Pragma(name=name513, terms=terms517) + return _t1021 def parse_primitive(self) -> logic_pb2.Primitive: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t999 = 9 + _t1023 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1000 = 4 + _t1024 = 4 else: if self.match_lookahead_literal(">", 1): - _t1001 = 3 + _t1025 = 3 else: if self.match_lookahead_literal("=", 1): - _t1002 = 0 + _t1026 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1003 = 2 + _t1027 = 2 else: if self.match_lookahead_literal("<", 1): - _t1004 = 1 + _t1028 = 1 else: if self.match_lookahead_literal("/", 1): - _t1005 = 8 + _t1029 = 8 else: if self.match_lookahead_literal("-", 1): - _t1006 = 6 + _t1030 = 6 else: if self.match_lookahead_literal("+", 1): - _t1007 = 5 + _t1031 = 5 else: if self.match_lookahead_literal("*", 1): - _t1008 = 7 + _t1032 = 7 else: - _t1008 = -1 - _t1007 = _t1008 - _t1006 = _t1007 - _t1005 = _t1006 - _t1004 = _t1005 - _t1003 = _t1004 - _t1002 = _t1003 - _t1001 = _t1002 - _t1000 = _t1001 - _t999 = _t1000 - _t998 = _t999 - else: - _t998 = -1 - prediction506 = _t998 - if prediction506 == 9: + _t1032 = -1 + _t1031 = _t1032 + _t1030 = _t1031 + _t1029 = _t1030 + _t1028 = _t1029 + _t1027 = _t1028 + _t1026 = _t1027 + _t1025 = _t1026 + _t1024 = _t1025 + _t1023 = _t1024 + _t1022 = _t1023 + else: + _t1022 = -1 + prediction518 = _t1022 + if prediction518 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1010 = self.parse_name() - name516 = _t1010 - xs517 = [] - cond518 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond518: - _t1011 = self.parse_rel_term() - item519 = _t1011 - xs517.append(item519) - cond518 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - rel_terms520 = xs517 + _t1034 = self.parse_name() + name528 = _t1034 + xs529 = [] + cond530 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond530: + _t1035 = self.parse_rel_term() + item531 = _t1035 + xs529.append(item531) + cond530 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + rel_terms532 = xs529 self.consume_literal(")") - _t1012 = logic_pb2.Primitive(name=name516, terms=rel_terms520) - _t1009 = _t1012 + _t1036 = logic_pb2.Primitive(name=name528, terms=rel_terms532) + _t1033 = _t1036 else: - if prediction506 == 8: - _t1014 = self.parse_divide() - divide515 = _t1014 - _t1013 = divide515 + if prediction518 == 8: + _t1038 = self.parse_divide() + divide527 = _t1038 + _t1037 = divide527 else: - if prediction506 == 7: - _t1016 = self.parse_multiply() - multiply514 = _t1016 - _t1015 = multiply514 + if prediction518 == 7: + _t1040 = self.parse_multiply() + multiply526 = _t1040 + _t1039 = multiply526 else: - if prediction506 == 6: - _t1018 = self.parse_minus() - minus513 = _t1018 - _t1017 = minus513 + if prediction518 == 6: + _t1042 = self.parse_minus() + minus525 = _t1042 + _t1041 = minus525 else: - if prediction506 == 5: - _t1020 = self.parse_add() - add512 = _t1020 - _t1019 = add512 + if prediction518 == 5: + _t1044 = self.parse_add() + add524 = _t1044 + _t1043 = add524 else: - if prediction506 == 4: - _t1022 = self.parse_gt_eq() - gt_eq511 = _t1022 - _t1021 = gt_eq511 + if prediction518 == 4: + _t1046 = self.parse_gt_eq() + gt_eq523 = _t1046 + _t1045 = gt_eq523 else: - if prediction506 == 3: - _t1024 = self.parse_gt() - gt510 = _t1024 - _t1023 = gt510 + if prediction518 == 3: + _t1048 = self.parse_gt() + gt522 = _t1048 + _t1047 = gt522 else: - if prediction506 == 2: - _t1026 = self.parse_lt_eq() - lt_eq509 = _t1026 - _t1025 = lt_eq509 + if prediction518 == 2: + _t1050 = self.parse_lt_eq() + lt_eq521 = _t1050 + _t1049 = lt_eq521 else: - if prediction506 == 1: - _t1028 = self.parse_lt() - lt508 = _t1028 - _t1027 = lt508 + if prediction518 == 1: + _t1052 = self.parse_lt() + lt520 = _t1052 + _t1051 = lt520 else: - if prediction506 == 0: - _t1030 = self.parse_eq() - eq507 = _t1030 - _t1029 = eq507 + if prediction518 == 0: + _t1054 = self.parse_eq() + eq519 = _t1054 + _t1053 = eq519 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1027 = _t1029 - _t1025 = _t1027 - _t1023 = _t1025 - _t1021 = _t1023 - _t1019 = _t1021 - _t1017 = _t1019 - _t1015 = _t1017 - _t1013 = _t1015 - _t1009 = _t1013 - return _t1009 + _t1051 = _t1053 + _t1049 = _t1051 + _t1047 = _t1049 + _t1045 = _t1047 + _t1043 = _t1045 + _t1041 = _t1043 + _t1039 = _t1041 + _t1037 = _t1039 + _t1033 = _t1037 + return _t1033 def parse_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("=") - _t1031 = self.parse_term() - term521 = _t1031 - _t1032 = self.parse_term() - term_3522 = _t1032 + _t1055 = self.parse_term() + term533 = _t1055 + _t1056 = self.parse_term() + term_3534 = _t1056 self.consume_literal(")") - _t1033 = logic_pb2.RelTerm(term=term521) - _t1034 = logic_pb2.RelTerm(term=term_3522) - _t1035 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1033, _t1034]) - return _t1035 + _t1057 = logic_pb2.RelTerm(term=term533) + _t1058 = logic_pb2.RelTerm(term=term_3534) + _t1059 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1057, _t1058]) + return _t1059 def parse_lt(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("<") - _t1036 = self.parse_term() - term523 = _t1036 - _t1037 = self.parse_term() - term_3524 = _t1037 + _t1060 = self.parse_term() + term535 = _t1060 + _t1061 = self.parse_term() + term_3536 = _t1061 self.consume_literal(")") - _t1038 = logic_pb2.RelTerm(term=term523) - _t1039 = logic_pb2.RelTerm(term=term_3524) - _t1040 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1038, _t1039]) - return _t1040 + _t1062 = logic_pb2.RelTerm(term=term535) + _t1063 = logic_pb2.RelTerm(term=term_3536) + _t1064 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1062, _t1063]) + return _t1064 def parse_lt_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("<=") - _t1041 = self.parse_term() - term525 = _t1041 - _t1042 = self.parse_term() - term_3526 = _t1042 + _t1065 = self.parse_term() + term537 = _t1065 + _t1066 = self.parse_term() + term_3538 = _t1066 self.consume_literal(")") - _t1043 = logic_pb2.RelTerm(term=term525) - _t1044 = logic_pb2.RelTerm(term=term_3526) - _t1045 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1043, _t1044]) - return _t1045 + _t1067 = logic_pb2.RelTerm(term=term537) + _t1068 = logic_pb2.RelTerm(term=term_3538) + _t1069 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1067, _t1068]) + return _t1069 def parse_gt(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal(">") - _t1046 = self.parse_term() - term527 = _t1046 - _t1047 = self.parse_term() - term_3528 = _t1047 + _t1070 = self.parse_term() + term539 = _t1070 + _t1071 = self.parse_term() + term_3540 = _t1071 self.consume_literal(")") - _t1048 = logic_pb2.RelTerm(term=term527) - _t1049 = logic_pb2.RelTerm(term=term_3528) - _t1050 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1048, _t1049]) - return _t1050 + _t1072 = logic_pb2.RelTerm(term=term539) + _t1073 = logic_pb2.RelTerm(term=term_3540) + _t1074 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1072, _t1073]) + return _t1074 def parse_gt_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal(">=") - _t1051 = self.parse_term() - term529 = _t1051 - _t1052 = self.parse_term() - term_3530 = _t1052 + _t1075 = self.parse_term() + term541 = _t1075 + _t1076 = self.parse_term() + term_3542 = _t1076 self.consume_literal(")") - _t1053 = logic_pb2.RelTerm(term=term529) - _t1054 = logic_pb2.RelTerm(term=term_3530) - _t1055 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1053, _t1054]) - return _t1055 + _t1077 = logic_pb2.RelTerm(term=term541) + _t1078 = logic_pb2.RelTerm(term=term_3542) + _t1079 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1077, _t1078]) + return _t1079 def parse_add(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("+") - _t1056 = self.parse_term() - term531 = _t1056 - _t1057 = self.parse_term() - term_3532 = _t1057 - _t1058 = self.parse_term() - term_4533 = _t1058 - self.consume_literal(")") - _t1059 = logic_pb2.RelTerm(term=term531) - _t1060 = logic_pb2.RelTerm(term=term_3532) - _t1061 = logic_pb2.RelTerm(term=term_4533) - _t1062 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1059, _t1060, _t1061]) - return _t1062 + _t1080 = self.parse_term() + term543 = _t1080 + _t1081 = self.parse_term() + term_3544 = _t1081 + _t1082 = self.parse_term() + term_4545 = _t1082 + self.consume_literal(")") + _t1083 = logic_pb2.RelTerm(term=term543) + _t1084 = logic_pb2.RelTerm(term=term_3544) + _t1085 = logic_pb2.RelTerm(term=term_4545) + _t1086 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1083, _t1084, _t1085]) + return _t1086 def parse_minus(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("-") - _t1063 = self.parse_term() - term534 = _t1063 - _t1064 = self.parse_term() - term_3535 = _t1064 - _t1065 = self.parse_term() - term_4536 = _t1065 - self.consume_literal(")") - _t1066 = logic_pb2.RelTerm(term=term534) - _t1067 = logic_pb2.RelTerm(term=term_3535) - _t1068 = logic_pb2.RelTerm(term=term_4536) - _t1069 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1066, _t1067, _t1068]) - return _t1069 + _t1087 = self.parse_term() + term546 = _t1087 + _t1088 = self.parse_term() + term_3547 = _t1088 + _t1089 = self.parse_term() + term_4548 = _t1089 + self.consume_literal(")") + _t1090 = logic_pb2.RelTerm(term=term546) + _t1091 = logic_pb2.RelTerm(term=term_3547) + _t1092 = logic_pb2.RelTerm(term=term_4548) + _t1093 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1090, _t1091, _t1092]) + return _t1093 def parse_multiply(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("*") - _t1070 = self.parse_term() - term537 = _t1070 - _t1071 = self.parse_term() - term_3538 = _t1071 - _t1072 = self.parse_term() - term_4539 = _t1072 - self.consume_literal(")") - _t1073 = logic_pb2.RelTerm(term=term537) - _t1074 = logic_pb2.RelTerm(term=term_3538) - _t1075 = logic_pb2.RelTerm(term=term_4539) - _t1076 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1073, _t1074, _t1075]) - return _t1076 + _t1094 = self.parse_term() + term549 = _t1094 + _t1095 = self.parse_term() + term_3550 = _t1095 + _t1096 = self.parse_term() + term_4551 = _t1096 + self.consume_literal(")") + _t1097 = logic_pb2.RelTerm(term=term549) + _t1098 = logic_pb2.RelTerm(term=term_3550) + _t1099 = logic_pb2.RelTerm(term=term_4551) + _t1100 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1097, _t1098, _t1099]) + return _t1100 def parse_divide(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("/") - _t1077 = self.parse_term() - term540 = _t1077 - _t1078 = self.parse_term() - term_3541 = _t1078 - _t1079 = self.parse_term() - term_4542 = _t1079 - self.consume_literal(")") - _t1080 = logic_pb2.RelTerm(term=term540) - _t1081 = logic_pb2.RelTerm(term=term_3541) - _t1082 = logic_pb2.RelTerm(term=term_4542) - _t1083 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1080, _t1081, _t1082]) - return _t1083 + _t1101 = self.parse_term() + term552 = _t1101 + _t1102 = self.parse_term() + term_3553 = _t1102 + _t1103 = self.parse_term() + term_4554 = _t1103 + self.consume_literal(")") + _t1104 = logic_pb2.RelTerm(term=term552) + _t1105 = logic_pb2.RelTerm(term=term_3553) + _t1106 = logic_pb2.RelTerm(term=term_4554) + _t1107 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1104, _t1105, _t1106]) + return _t1107 def parse_rel_term(self) -> logic_pb2.RelTerm: if self.match_lookahead_literal("true", 0): - _t1084 = 1 + _t1108 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1085 = 1 + _t1109 = 1 else: if self.match_lookahead_literal("false", 0): - _t1086 = 1 + _t1110 = 1 else: if self.match_lookahead_literal("(", 0): - _t1087 = 1 + _t1111 = 1 else: if self.match_lookahead_literal("#", 0): - _t1088 = 0 + _t1112 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1089 = 1 + _t1113 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1090 = 1 + _t1114 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1091 = 1 + _t1115 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1092 = 1 + _t1116 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1093 = 1 + _t1117 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1094 = 1 + _t1118 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1095 = 1 + _t1119 = 1 else: - _t1095 = -1 - _t1094 = _t1095 - _t1093 = _t1094 - _t1092 = _t1093 - _t1091 = _t1092 - _t1090 = _t1091 - _t1089 = _t1090 - _t1088 = _t1089 - _t1087 = _t1088 - _t1086 = _t1087 - _t1085 = _t1086 - _t1084 = _t1085 - prediction543 = _t1084 - if prediction543 == 1: - _t1097 = self.parse_term() - term545 = _t1097 - _t1098 = logic_pb2.RelTerm(term=term545) - _t1096 = _t1098 - else: - if prediction543 == 0: - _t1100 = self.parse_specialized_value() - specialized_value544 = _t1100 - _t1101 = logic_pb2.RelTerm(specialized_value=specialized_value544) - _t1099 = _t1101 + _t1119 = -1 + _t1118 = _t1119 + _t1117 = _t1118 + _t1116 = _t1117 + _t1115 = _t1116 + _t1114 = _t1115 + _t1113 = _t1114 + _t1112 = _t1113 + _t1111 = _t1112 + _t1110 = _t1111 + _t1109 = _t1110 + _t1108 = _t1109 + prediction555 = _t1108 + if prediction555 == 1: + _t1121 = self.parse_term() + term557 = _t1121 + _t1122 = logic_pb2.RelTerm(term=term557) + _t1120 = _t1122 + else: + if prediction555 == 0: + _t1124 = self.parse_specialized_value() + specialized_value556 = _t1124 + _t1125 = logic_pb2.RelTerm(specialized_value=specialized_value556) + _t1123 = _t1125 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1096 = _t1099 - return _t1096 + _t1120 = _t1123 + return _t1120 def parse_specialized_value(self) -> logic_pb2.Value: self.consume_literal("#") - _t1102 = self.parse_value() - value546 = _t1102 - return value546 + _t1126 = self.parse_value() + value558 = _t1126 + return value558 def parse_rel_atom(self) -> logic_pb2.RelAtom: self.consume_literal("(") self.consume_literal("relatom") - _t1103 = self.parse_name() - name547 = _t1103 - xs548 = [] - cond549 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond549: - _t1104 = self.parse_rel_term() - item550 = _t1104 - xs548.append(item550) - cond549 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - rel_terms551 = xs548 - self.consume_literal(")") - _t1105 = logic_pb2.RelAtom(name=name547, terms=rel_terms551) - return _t1105 + _t1127 = self.parse_name() + name559 = _t1127 + xs560 = [] + cond561 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond561: + _t1128 = self.parse_rel_term() + item562 = _t1128 + xs560.append(item562) + cond561 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + rel_terms563 = xs560 + self.consume_literal(")") + _t1129 = logic_pb2.RelAtom(name=name559, terms=rel_terms563) + return _t1129 def parse_cast(self) -> logic_pb2.Cast: self.consume_literal("(") self.consume_literal("cast") - _t1106 = self.parse_term() - term552 = _t1106 - _t1107 = self.parse_term() - term_3553 = _t1107 + _t1130 = self.parse_term() + term564 = _t1130 + _t1131 = self.parse_term() + term_3565 = _t1131 self.consume_literal(")") - _t1108 = logic_pb2.Cast(input=term552, result=term_3553) - return _t1108 + _t1132 = logic_pb2.Cast(input=term564, result=term_3565) + return _t1132 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs554 = [] - cond555 = self.match_lookahead_literal("(", 0) - while cond555: - _t1109 = self.parse_attribute() - item556 = _t1109 - xs554.append(item556) - cond555 = self.match_lookahead_literal("(", 0) - attributes557 = xs554 + xs566 = [] + cond567 = self.match_lookahead_literal("(", 0) + while cond567: + _t1133 = self.parse_attribute() + item568 = _t1133 + xs566.append(item568) + cond567 = self.match_lookahead_literal("(", 0) + attributes569 = xs566 self.consume_literal(")") - return attributes557 + return attributes569 def parse_attribute(self) -> logic_pb2.Attribute: self.consume_literal("(") self.consume_literal("attribute") - _t1110 = self.parse_name() - name558 = _t1110 - xs559 = [] - cond560 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond560: - _t1111 = self.parse_value() - item561 = _t1111 - xs559.append(item561) - cond560 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) - values562 = xs559 - self.consume_literal(")") - _t1112 = logic_pb2.Attribute(name=name558, args=values562) - return _t1112 + _t1134 = self.parse_name() + name570 = _t1134 + xs571 = [] + cond572 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond572: + _t1135 = self.parse_value() + item573 = _t1135 + xs571.append(item573) + cond572 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) + values574 = xs571 + self.consume_literal(")") + _t1136 = logic_pb2.Attribute(name=name570, args=values574) + return _t1136 def parse_algorithm(self) -> logic_pb2.Algorithm: self.consume_literal("(") self.consume_literal("algorithm") - xs563 = [] - cond564 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond564: - _t1113 = self.parse_relation_id() - item565 = _t1113 - xs563.append(item565) - cond564 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids566 = xs563 - _t1114 = self.parse_script() - script567 = _t1114 - self.consume_literal(")") - _t1115 = logic_pb2.Algorithm(body=script567) - getattr(_t1115, 'global').extend(relation_ids566) - return _t1115 + xs575 = [] + cond576 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond576: + _t1137 = self.parse_relation_id() + item577 = _t1137 + xs575.append(item577) + cond576 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids578 = xs575 + _t1138 = self.parse_script() + script579 = _t1138 + self.consume_literal(")") + _t1139 = logic_pb2.Algorithm(body=script579) + getattr(_t1139, 'global').extend(relation_ids578) + return _t1139 def parse_script(self) -> logic_pb2.Script: self.consume_literal("(") self.consume_literal("script") - xs568 = [] - cond569 = self.match_lookahead_literal("(", 0) - while cond569: - _t1116 = self.parse_construct() - item570 = _t1116 - xs568.append(item570) - cond569 = self.match_lookahead_literal("(", 0) - constructs571 = xs568 - self.consume_literal(")") - _t1117 = logic_pb2.Script(constructs=constructs571) - return _t1117 + xs580 = [] + cond581 = self.match_lookahead_literal("(", 0) + while cond581: + _t1140 = self.parse_construct() + item582 = _t1140 + xs580.append(item582) + cond581 = self.match_lookahead_literal("(", 0) + constructs583 = xs580 + self.consume_literal(")") + _t1141 = logic_pb2.Script(constructs=constructs583) + return _t1141 def parse_construct(self) -> logic_pb2.Construct: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1119 = 1 + _t1143 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1120 = 1 + _t1144 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1121 = 1 + _t1145 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1122 = 0 + _t1146 = 0 else: if self.match_lookahead_literal("break", 1): - _t1123 = 1 + _t1147 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1124 = 1 + _t1148 = 1 else: - _t1124 = -1 - _t1123 = _t1124 - _t1122 = _t1123 - _t1121 = _t1122 - _t1120 = _t1121 - _t1119 = _t1120 - _t1118 = _t1119 - else: - _t1118 = -1 - prediction572 = _t1118 - if prediction572 == 1: - _t1126 = self.parse_instruction() - instruction574 = _t1126 - _t1127 = logic_pb2.Construct(instruction=instruction574) - _t1125 = _t1127 - else: - if prediction572 == 0: - _t1129 = self.parse_loop() - loop573 = _t1129 - _t1130 = logic_pb2.Construct(loop=loop573) - _t1128 = _t1130 + _t1148 = -1 + _t1147 = _t1148 + _t1146 = _t1147 + _t1145 = _t1146 + _t1144 = _t1145 + _t1143 = _t1144 + _t1142 = _t1143 + else: + _t1142 = -1 + prediction584 = _t1142 + if prediction584 == 1: + _t1150 = self.parse_instruction() + instruction586 = _t1150 + _t1151 = logic_pb2.Construct(instruction=instruction586) + _t1149 = _t1151 + else: + if prediction584 == 0: + _t1153 = self.parse_loop() + loop585 = _t1153 + _t1154 = logic_pb2.Construct(loop=loop585) + _t1152 = _t1154 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1125 = _t1128 - return _t1125 + _t1149 = _t1152 + return _t1149 def parse_loop(self) -> logic_pb2.Loop: self.consume_literal("(") self.consume_literal("loop") - _t1131 = self.parse_init() - init575 = _t1131 - _t1132 = self.parse_script() - script576 = _t1132 + _t1155 = self.parse_init() + init587 = _t1155 + _t1156 = self.parse_script() + script588 = _t1156 self.consume_literal(")") - _t1133 = logic_pb2.Loop(init=init575, body=script576) - return _t1133 + _t1157 = logic_pb2.Loop(init=init587, body=script588) + return _t1157 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs577 = [] - cond578 = self.match_lookahead_literal("(", 0) - while cond578: - _t1134 = self.parse_instruction() - item579 = _t1134 - xs577.append(item579) - cond578 = self.match_lookahead_literal("(", 0) - instructions580 = xs577 + xs589 = [] + cond590 = self.match_lookahead_literal("(", 0) + while cond590: + _t1158 = self.parse_instruction() + item591 = _t1158 + xs589.append(item591) + cond590 = self.match_lookahead_literal("(", 0) + instructions592 = xs589 self.consume_literal(")") - return instructions580 + return instructions592 def parse_instruction(self) -> logic_pb2.Instruction: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1136 = 1 + _t1160 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1137 = 4 + _t1161 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1138 = 3 + _t1162 = 3 else: if self.match_lookahead_literal("break", 1): - _t1139 = 2 + _t1163 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1140 = 0 + _t1164 = 0 else: - _t1140 = -1 - _t1139 = _t1140 - _t1138 = _t1139 - _t1137 = _t1138 - _t1136 = _t1137 - _t1135 = _t1136 - else: - _t1135 = -1 - prediction581 = _t1135 - if prediction581 == 4: - _t1142 = self.parse_monus_def() - monus_def586 = _t1142 - _t1143 = logic_pb2.Instruction(monus_def=monus_def586) - _t1141 = _t1143 - else: - if prediction581 == 3: - _t1145 = self.parse_monoid_def() - monoid_def585 = _t1145 - _t1146 = logic_pb2.Instruction(monoid_def=monoid_def585) - _t1144 = _t1146 + _t1164 = -1 + _t1163 = _t1164 + _t1162 = _t1163 + _t1161 = _t1162 + _t1160 = _t1161 + _t1159 = _t1160 + else: + _t1159 = -1 + prediction593 = _t1159 + if prediction593 == 4: + _t1166 = self.parse_monus_def() + monus_def598 = _t1166 + _t1167 = logic_pb2.Instruction(monus_def=monus_def598) + _t1165 = _t1167 + else: + if prediction593 == 3: + _t1169 = self.parse_monoid_def() + monoid_def597 = _t1169 + _t1170 = logic_pb2.Instruction(monoid_def=monoid_def597) + _t1168 = _t1170 else: - if prediction581 == 2: - _t1148 = self.parse_break() - break584 = _t1148 - _t1149 = logic_pb2.Instruction() - getattr(_t1149, 'break').CopyFrom(break584) - _t1147 = _t1149 + if prediction593 == 2: + _t1172 = self.parse_break() + break596 = _t1172 + _t1173 = logic_pb2.Instruction() + getattr(_t1173, 'break').CopyFrom(break596) + _t1171 = _t1173 else: - if prediction581 == 1: - _t1151 = self.parse_upsert() - upsert583 = _t1151 - _t1152 = logic_pb2.Instruction(upsert=upsert583) - _t1150 = _t1152 + if prediction593 == 1: + _t1175 = self.parse_upsert() + upsert595 = _t1175 + _t1176 = logic_pb2.Instruction(upsert=upsert595) + _t1174 = _t1176 else: - if prediction581 == 0: - _t1154 = self.parse_assign() - assign582 = _t1154 - _t1155 = logic_pb2.Instruction(assign=assign582) - _t1153 = _t1155 + if prediction593 == 0: + _t1178 = self.parse_assign() + assign594 = _t1178 + _t1179 = logic_pb2.Instruction(assign=assign594) + _t1177 = _t1179 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1150 = _t1153 - _t1147 = _t1150 - _t1144 = _t1147 - _t1141 = _t1144 - return _t1141 + _t1174 = _t1177 + _t1171 = _t1174 + _t1168 = _t1171 + _t1165 = _t1168 + return _t1165 def parse_assign(self) -> logic_pb2.Assign: self.consume_literal("(") self.consume_literal("assign") - _t1156 = self.parse_relation_id() - relation_id587 = _t1156 - _t1157 = self.parse_abstraction() - abstraction588 = _t1157 + _t1180 = self.parse_relation_id() + relation_id599 = _t1180 + _t1181 = self.parse_abstraction() + abstraction600 = _t1181 if self.match_lookahead_literal("(", 0): - _t1159 = self.parse_attrs() - _t1158 = _t1159 + _t1183 = self.parse_attrs() + _t1182 = _t1183 else: - _t1158 = None - attrs589 = _t1158 + _t1182 = None + attrs601 = _t1182 self.consume_literal(")") - _t1160 = logic_pb2.Assign(name=relation_id587, body=abstraction588, attrs=(attrs589 if attrs589 is not None else [])) - return _t1160 + _t1184 = logic_pb2.Assign(name=relation_id599, body=abstraction600, attrs=(attrs601 if attrs601 is not None else [])) + return _t1184 def parse_upsert(self) -> logic_pb2.Upsert: self.consume_literal("(") self.consume_literal("upsert") - _t1161 = self.parse_relation_id() - relation_id590 = _t1161 - _t1162 = self.parse_abstraction_with_arity() - abstraction_with_arity591 = _t1162 + _t1185 = self.parse_relation_id() + relation_id602 = _t1185 + _t1186 = self.parse_abstraction_with_arity() + abstraction_with_arity603 = _t1186 if self.match_lookahead_literal("(", 0): - _t1164 = self.parse_attrs() - _t1163 = _t1164 + _t1188 = self.parse_attrs() + _t1187 = _t1188 else: - _t1163 = None - attrs592 = _t1163 + _t1187 = None + attrs604 = _t1187 self.consume_literal(")") - _t1165 = logic_pb2.Upsert(name=relation_id590, body=abstraction_with_arity591[0], attrs=(attrs592 if attrs592 is not None else []), value_arity=abstraction_with_arity591[1]) - return _t1165 + _t1189 = logic_pb2.Upsert(name=relation_id602, body=abstraction_with_arity603[0], attrs=(attrs604 if attrs604 is not None else []), value_arity=abstraction_with_arity603[1]) + return _t1189 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1166 = self.parse_bindings() - bindings593 = _t1166 - _t1167 = self.parse_formula() - formula594 = _t1167 + _t1190 = self.parse_bindings() + bindings605 = _t1190 + _t1191 = self.parse_formula() + formula606 = _t1191 self.consume_literal(")") - _t1168 = logic_pb2.Abstraction(vars=(list(bindings593[0]) + list(bindings593[1] if bindings593[1] is not None else [])), value=formula594) - return (_t1168, len(bindings593[1]),) + _t1192 = logic_pb2.Abstraction(vars=(list(bindings605[0]) + list(bindings605[1] if bindings605[1] is not None else [])), value=formula606) + return (_t1192, len(bindings605[1]),) def parse_break(self) -> logic_pb2.Break: self.consume_literal("(") self.consume_literal("break") - _t1169 = self.parse_relation_id() - relation_id595 = _t1169 - _t1170 = self.parse_abstraction() - abstraction596 = _t1170 + _t1193 = self.parse_relation_id() + relation_id607 = _t1193 + _t1194 = self.parse_abstraction() + abstraction608 = _t1194 if self.match_lookahead_literal("(", 0): - _t1172 = self.parse_attrs() - _t1171 = _t1172 + _t1196 = self.parse_attrs() + _t1195 = _t1196 else: - _t1171 = None - attrs597 = _t1171 + _t1195 = None + attrs609 = _t1195 self.consume_literal(")") - _t1173 = logic_pb2.Break(name=relation_id595, body=abstraction596, attrs=(attrs597 if attrs597 is not None else [])) - return _t1173 + _t1197 = logic_pb2.Break(name=relation_id607, body=abstraction608, attrs=(attrs609 if attrs609 is not None else [])) + return _t1197 def parse_monoid_def(self) -> logic_pb2.MonoidDef: self.consume_literal("(") self.consume_literal("monoid") - _t1174 = self.parse_monoid() - monoid598 = _t1174 - _t1175 = self.parse_relation_id() - relation_id599 = _t1175 - _t1176 = self.parse_abstraction_with_arity() - abstraction_with_arity600 = _t1176 + _t1198 = self.parse_monoid() + monoid610 = _t1198 + _t1199 = self.parse_relation_id() + relation_id611 = _t1199 + _t1200 = self.parse_abstraction_with_arity() + abstraction_with_arity612 = _t1200 if self.match_lookahead_literal("(", 0): - _t1178 = self.parse_attrs() - _t1177 = _t1178 + _t1202 = self.parse_attrs() + _t1201 = _t1202 else: - _t1177 = None - attrs601 = _t1177 + _t1201 = None + attrs613 = _t1201 self.consume_literal(")") - _t1179 = logic_pb2.MonoidDef(monoid=monoid598, name=relation_id599, body=abstraction_with_arity600[0], attrs=(attrs601 if attrs601 is not None else []), value_arity=abstraction_with_arity600[1]) - return _t1179 + _t1203 = logic_pb2.MonoidDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[0], attrs=(attrs613 if attrs613 is not None else []), value_arity=abstraction_with_arity612[1]) + return _t1203 def parse_monoid(self) -> logic_pb2.Monoid: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1181 = 3 + _t1205 = 3 else: if self.match_lookahead_literal("or", 1): - _t1182 = 0 + _t1206 = 0 else: if self.match_lookahead_literal("min", 1): - _t1183 = 1 + _t1207 = 1 else: if self.match_lookahead_literal("max", 1): - _t1184 = 2 + _t1208 = 2 else: - _t1184 = -1 - _t1183 = _t1184 - _t1182 = _t1183 - _t1181 = _t1182 - _t1180 = _t1181 - else: - _t1180 = -1 - prediction602 = _t1180 - if prediction602 == 3: - _t1186 = self.parse_sum_monoid() - sum_monoid606 = _t1186 - _t1187 = logic_pb2.Monoid(sum_monoid=sum_monoid606) - _t1185 = _t1187 - else: - if prediction602 == 2: - _t1189 = self.parse_max_monoid() - max_monoid605 = _t1189 - _t1190 = logic_pb2.Monoid(max_monoid=max_monoid605) - _t1188 = _t1190 + _t1208 = -1 + _t1207 = _t1208 + _t1206 = _t1207 + _t1205 = _t1206 + _t1204 = _t1205 + else: + _t1204 = -1 + prediction614 = _t1204 + if prediction614 == 3: + _t1210 = self.parse_sum_monoid() + sum_monoid618 = _t1210 + _t1211 = logic_pb2.Monoid(sum_monoid=sum_monoid618) + _t1209 = _t1211 + else: + if prediction614 == 2: + _t1213 = self.parse_max_monoid() + max_monoid617 = _t1213 + _t1214 = logic_pb2.Monoid(max_monoid=max_monoid617) + _t1212 = _t1214 else: - if prediction602 == 1: - _t1192 = self.parse_min_monoid() - min_monoid604 = _t1192 - _t1193 = logic_pb2.Monoid(min_monoid=min_monoid604) - _t1191 = _t1193 + if prediction614 == 1: + _t1216 = self.parse_min_monoid() + min_monoid616 = _t1216 + _t1217 = logic_pb2.Monoid(min_monoid=min_monoid616) + _t1215 = _t1217 else: - if prediction602 == 0: - _t1195 = self.parse_or_monoid() - or_monoid603 = _t1195 - _t1196 = logic_pb2.Monoid(or_monoid=or_monoid603) - _t1194 = _t1196 + if prediction614 == 0: + _t1219 = self.parse_or_monoid() + or_monoid615 = _t1219 + _t1220 = logic_pb2.Monoid(or_monoid=or_monoid615) + _t1218 = _t1220 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1191 = _t1194 - _t1188 = _t1191 - _t1185 = _t1188 - return _t1185 + _t1215 = _t1218 + _t1212 = _t1215 + _t1209 = _t1212 + return _t1209 def parse_or_monoid(self) -> logic_pb2.OrMonoid: self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1197 = logic_pb2.OrMonoid() - return _t1197 + _t1221 = logic_pb2.OrMonoid() + return _t1221 def parse_min_monoid(self) -> logic_pb2.MinMonoid: self.consume_literal("(") self.consume_literal("min") - _t1198 = self.parse_type() - type607 = _t1198 + _t1222 = self.parse_type() + type619 = _t1222 self.consume_literal(")") - _t1199 = logic_pb2.MinMonoid(type=type607) - return _t1199 + _t1223 = logic_pb2.MinMonoid(type=type619) + return _t1223 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: self.consume_literal("(") self.consume_literal("max") - _t1200 = self.parse_type() - type608 = _t1200 + _t1224 = self.parse_type() + type620 = _t1224 self.consume_literal(")") - _t1201 = logic_pb2.MaxMonoid(type=type608) - return _t1201 + _t1225 = logic_pb2.MaxMonoid(type=type620) + return _t1225 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: self.consume_literal("(") self.consume_literal("sum") - _t1202 = self.parse_type() - type609 = _t1202 + _t1226 = self.parse_type() + type621 = _t1226 self.consume_literal(")") - _t1203 = logic_pb2.SumMonoid(type=type609) - return _t1203 + _t1227 = logic_pb2.SumMonoid(type=type621) + return _t1227 def parse_monus_def(self) -> logic_pb2.MonusDef: self.consume_literal("(") self.consume_literal("monus") - _t1204 = self.parse_monoid() - monoid610 = _t1204 - _t1205 = self.parse_relation_id() - relation_id611 = _t1205 - _t1206 = self.parse_abstraction_with_arity() - abstraction_with_arity612 = _t1206 + _t1228 = self.parse_monoid() + monoid622 = _t1228 + _t1229 = self.parse_relation_id() + relation_id623 = _t1229 + _t1230 = self.parse_abstraction_with_arity() + abstraction_with_arity624 = _t1230 if self.match_lookahead_literal("(", 0): - _t1208 = self.parse_attrs() - _t1207 = _t1208 + _t1232 = self.parse_attrs() + _t1231 = _t1232 else: - _t1207 = None - attrs613 = _t1207 + _t1231 = None + attrs625 = _t1231 self.consume_literal(")") - _t1209 = logic_pb2.MonusDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[0], attrs=(attrs613 if attrs613 is not None else []), value_arity=abstraction_with_arity612[1]) - return _t1209 + _t1233 = logic_pb2.MonusDef(monoid=monoid622, name=relation_id623, body=abstraction_with_arity624[0], attrs=(attrs625 if attrs625 is not None else []), value_arity=abstraction_with_arity624[1]) + return _t1233 def parse_constraint(self) -> logic_pb2.Constraint: self.consume_literal("(") self.consume_literal("functional_dependency") - _t1210 = self.parse_relation_id() - relation_id614 = _t1210 - _t1211 = self.parse_abstraction() - abstraction615 = _t1211 - _t1212 = self.parse_functional_dependency_keys() - functional_dependency_keys616 = _t1212 - _t1213 = self.parse_functional_dependency_values() - functional_dependency_values617 = _t1213 - self.consume_literal(")") - _t1214 = logic_pb2.FunctionalDependency(guard=abstraction615, keys=functional_dependency_keys616, values=functional_dependency_values617) - _t1215 = logic_pb2.Constraint(name=relation_id614, functional_dependency=_t1214) - return _t1215 + _t1234 = self.parse_relation_id() + relation_id626 = _t1234 + _t1235 = self.parse_abstraction() + abstraction627 = _t1235 + _t1236 = self.parse_functional_dependency_keys() + functional_dependency_keys628 = _t1236 + _t1237 = self.parse_functional_dependency_values() + functional_dependency_values629 = _t1237 + self.consume_literal(")") + _t1238 = logic_pb2.FunctionalDependency(guard=abstraction627, keys=functional_dependency_keys628, values=functional_dependency_values629) + _t1239 = logic_pb2.Constraint(name=relation_id626, functional_dependency=_t1238) + return _t1239 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs618 = [] - cond619 = self.match_lookahead_terminal("SYMBOL", 0) - while cond619: - _t1216 = self.parse_var() - item620 = _t1216 - xs618.append(item620) - cond619 = self.match_lookahead_terminal("SYMBOL", 0) - vars621 = xs618 + xs630 = [] + cond631 = self.match_lookahead_terminal("SYMBOL", 0) + while cond631: + _t1240 = self.parse_var() + item632 = _t1240 + xs630.append(item632) + cond631 = self.match_lookahead_terminal("SYMBOL", 0) + vars633 = xs630 self.consume_literal(")") - return vars621 + return vars633 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs622 = [] - cond623 = self.match_lookahead_terminal("SYMBOL", 0) - while cond623: - _t1217 = self.parse_var() - item624 = _t1217 - xs622.append(item624) - cond623 = self.match_lookahead_terminal("SYMBOL", 0) - vars625 = xs622 + xs634 = [] + cond635 = self.match_lookahead_terminal("SYMBOL", 0) + while cond635: + _t1241 = self.parse_var() + item636 = _t1241 + xs634.append(item636) + cond635 = self.match_lookahead_terminal("SYMBOL", 0) + vars637 = xs634 self.consume_literal(")") - return vars625 + return vars637 def parse_data(self) -> logic_pb2.Data: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("rel_edb", 1): - _t1219 = 0 + _t1243 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1220 = 2 + _t1244 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1221 = 1 + _t1245 = 1 else: - _t1221 = -1 - _t1220 = _t1221 - _t1219 = _t1220 - _t1218 = _t1219 - else: - _t1218 = -1 - prediction626 = _t1218 - if prediction626 == 2: - _t1223 = self.parse_csv_data() - csv_data629 = _t1223 - _t1224 = logic_pb2.Data(csv_data=csv_data629) - _t1222 = _t1224 - else: - if prediction626 == 1: - _t1226 = self.parse_betree_relation() - betree_relation628 = _t1226 - _t1227 = logic_pb2.Data(betree_relation=betree_relation628) - _t1225 = _t1227 + _t1245 = -1 + _t1244 = _t1245 + _t1243 = _t1244 + _t1242 = _t1243 + else: + _t1242 = -1 + prediction638 = _t1242 + if prediction638 == 2: + _t1247 = self.parse_csv_data() + csv_data641 = _t1247 + _t1248 = logic_pb2.Data(csv_data=csv_data641) + _t1246 = _t1248 + else: + if prediction638 == 1: + _t1250 = self.parse_betree_relation() + betree_relation640 = _t1250 + _t1251 = logic_pb2.Data(betree_relation=betree_relation640) + _t1249 = _t1251 else: - if prediction626 == 0: - _t1229 = self.parse_rel_edb() - rel_edb627 = _t1229 - _t1230 = logic_pb2.Data(rel_edb=rel_edb627) - _t1228 = _t1230 + if prediction638 == 0: + _t1253 = self.parse_rel_edb() + rel_edb639 = _t1253 + _t1254 = logic_pb2.Data(rel_edb=rel_edb639) + _t1252 = _t1254 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1225 = _t1228 - _t1222 = _t1225 - return _t1222 + _t1249 = _t1252 + _t1246 = _t1249 + return _t1246 def parse_rel_edb(self) -> logic_pb2.RelEDB: self.consume_literal("(") self.consume_literal("rel_edb") - _t1231 = self.parse_relation_id() - relation_id630 = _t1231 - _t1232 = self.parse_rel_edb_path() - rel_edb_path631 = _t1232 - _t1233 = self.parse_rel_edb_types() - rel_edb_types632 = _t1233 + _t1255 = self.parse_relation_id() + relation_id642 = _t1255 + _t1256 = self.parse_rel_edb_path() + rel_edb_path643 = _t1256 + _t1257 = self.parse_rel_edb_types() + rel_edb_types644 = _t1257 self.consume_literal(")") - _t1234 = logic_pb2.RelEDB(target_id=relation_id630, path=rel_edb_path631, types=rel_edb_types632) - return _t1234 + _t1258 = logic_pb2.RelEDB(target_id=relation_id642, path=rel_edb_path643, types=rel_edb_types644) + return _t1258 def parse_rel_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs633 = [] - cond634 = self.match_lookahead_terminal("STRING", 0) - while cond634: - item635 = self.consume_terminal("STRING") - xs633.append(item635) - cond634 = self.match_lookahead_terminal("STRING", 0) - strings636 = xs633 + xs645 = [] + cond646 = self.match_lookahead_terminal("STRING", 0) + while cond646: + item647 = self.consume_terminal("STRING") + xs645.append(item647) + cond646 = self.match_lookahead_terminal("STRING", 0) + strings648 = xs645 self.consume_literal("]") - return strings636 + return strings648 def parse_rel_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs637 = [] - cond638 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond638: - _t1235 = self.parse_type() - item639 = _t1235 - xs637.append(item639) - cond638 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types640 = xs637 + xs649 = [] + cond650 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond650: + _t1259 = self.parse_type() + item651 = _t1259 + xs649.append(item651) + cond650 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types652 = xs649 self.consume_literal("]") - return types640 + return types652 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: self.consume_literal("(") self.consume_literal("betree_relation") - _t1236 = self.parse_relation_id() - relation_id641 = _t1236 - _t1237 = self.parse_betree_info() - betree_info642 = _t1237 + _t1260 = self.parse_relation_id() + relation_id653 = _t1260 + _t1261 = self.parse_betree_info() + betree_info654 = _t1261 self.consume_literal(")") - _t1238 = logic_pb2.BeTreeRelation(name=relation_id641, relation_info=betree_info642) - return _t1238 + _t1262 = logic_pb2.BeTreeRelation(name=relation_id653, relation_info=betree_info654) + return _t1262 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: self.consume_literal("(") self.consume_literal("betree_info") - _t1239 = self.parse_betree_info_key_types() - betree_info_key_types643 = _t1239 - _t1240 = self.parse_betree_info_value_types() - betree_info_value_types644 = _t1240 - _t1241 = self.parse_config_dict() - config_dict645 = _t1241 + _t1263 = self.parse_betree_info_key_types() + betree_info_key_types655 = _t1263 + _t1264 = self.parse_betree_info_value_types() + betree_info_value_types656 = _t1264 + _t1265 = self.parse_config_dict() + config_dict657 = _t1265 self.consume_literal(")") - _t1242 = self.construct_betree_info(betree_info_key_types643, betree_info_value_types644, config_dict645) - return _t1242 + _t1266 = self.construct_betree_info(betree_info_key_types655, betree_info_value_types656, config_dict657) + return _t1266 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs646 = [] - cond647 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond647: - _t1243 = self.parse_type() - item648 = _t1243 - xs646.append(item648) - cond647 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types649 = xs646 + xs658 = [] + cond659 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond659: + _t1267 = self.parse_type() + item660 = _t1267 + xs658.append(item660) + cond659 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types661 = xs658 self.consume_literal(")") - return types649 + return types661 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs650 = [] - cond651 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond651: - _t1244 = self.parse_type() - item652 = _t1244 - xs650.append(item652) - cond651 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types653 = xs650 + xs662 = [] + cond663 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond663: + _t1268 = self.parse_type() + item664 = _t1268 + xs662.append(item664) + cond663 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types665 = xs662 self.consume_literal(")") - return types653 + return types665 def parse_csv_data(self) -> logic_pb2.CSVData: self.consume_literal("(") self.consume_literal("csv_data") - _t1245 = self.parse_csvlocator() - csvlocator654 = _t1245 - _t1246 = self.parse_csv_config() - csv_config655 = _t1246 - _t1247 = self.parse_csv_columns() - csv_columns656 = _t1247 - _t1248 = self.parse_csv_asof() - csv_asof657 = _t1248 - self.consume_literal(")") - _t1249 = logic_pb2.CSVData(locator=csvlocator654, config=csv_config655, columns=csv_columns656, asof=csv_asof657) - return _t1249 + _t1269 = self.parse_csvlocator() + csvlocator666 = _t1269 + _t1270 = self.parse_csv_config() + csv_config667 = _t1270 + _t1271 = self.parse_csv_columns() + csv_columns668 = _t1271 + _t1272 = self.parse_csv_asof() + csv_asof669 = _t1272 + self.consume_literal(")") + _t1273 = logic_pb2.CSVData(locator=csvlocator666, config=csv_config667, columns=csv_columns668, asof=csv_asof669) + return _t1273 def parse_csvlocator(self) -> logic_pb2.CSVLocator: self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1251 = self.parse_csv_locator_paths() - _t1250 = _t1251 + _t1275 = self.parse_csv_locator_paths() + _t1274 = _t1275 else: - _t1250 = None - csv_locator_paths658 = _t1250 + _t1274 = None + csv_locator_paths670 = _t1274 if self.match_lookahead_literal("(", 0): - _t1253 = self.parse_csv_locator_inline_data() - _t1252 = _t1253 + _t1277 = self.parse_csv_locator_inline_data() + _t1276 = _t1277 else: - _t1252 = None - csv_locator_inline_data659 = _t1252 + _t1276 = None + csv_locator_inline_data671 = _t1276 self.consume_literal(")") - _t1254 = logic_pb2.CSVLocator(paths=(csv_locator_paths658 if csv_locator_paths658 is not None else []), inline_data=(csv_locator_inline_data659 if csv_locator_inline_data659 is not None else "").encode()) - return _t1254 + _t1278 = logic_pb2.CSVLocator(paths=(csv_locator_paths670 if csv_locator_paths670 is not None else []), inline_data=(csv_locator_inline_data671 if csv_locator_inline_data671 is not None else "").encode()) + return _t1278 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs660 = [] - cond661 = self.match_lookahead_terminal("STRING", 0) - while cond661: - item662 = self.consume_terminal("STRING") - xs660.append(item662) - cond661 = self.match_lookahead_terminal("STRING", 0) - strings663 = xs660 + xs672 = [] + cond673 = self.match_lookahead_terminal("STRING", 0) + while cond673: + item674 = self.consume_terminal("STRING") + xs672.append(item674) + cond673 = self.match_lookahead_terminal("STRING", 0) + strings675 = xs672 self.consume_literal(")") - return strings663 + return strings675 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - string664 = self.consume_terminal("STRING") + string676 = self.consume_terminal("STRING") self.consume_literal(")") - return string664 + return string676 def parse_csv_config(self) -> logic_pb2.CSVConfig: self.consume_literal("(") self.consume_literal("csv_config") - _t1255 = self.parse_config_dict() - config_dict665 = _t1255 + _t1279 = self.parse_config_dict() + config_dict677 = _t1279 self.consume_literal(")") - _t1256 = self.construct_csv_config(config_dict665) - return _t1256 + _t1280 = self.construct_csv_config(config_dict677) + return _t1280 def parse_csv_columns(self) -> Sequence[logic_pb2.CSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs666 = [] - cond667 = self.match_lookahead_literal("(", 0) - while cond667: - _t1257 = self.parse_csv_column() - item668 = _t1257 - xs666.append(item668) - cond667 = self.match_lookahead_literal("(", 0) - csv_columns669 = xs666 + xs678 = [] + cond679 = self.match_lookahead_literal("(", 0) + while cond679: + _t1281 = self.parse_csv_column() + item680 = _t1281 + xs678.append(item680) + cond679 = self.match_lookahead_literal("(", 0) + csv_columns681 = xs678 self.consume_literal(")") - return csv_columns669 + return csv_columns681 def parse_csv_column(self) -> logic_pb2.CSVColumn: self.consume_literal("(") self.consume_literal("column") - string670 = self.consume_terminal("STRING") - _t1258 = self.parse_relation_id() - relation_id671 = _t1258 - self.consume_literal("[") - xs672 = [] - cond673 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond673: - _t1259 = self.parse_type() - item674 = _t1259 - xs672.append(item674) - cond673 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types675 = xs672 - self.consume_literal("]") + _t1282 = self.parse_csv_column_path() + csv_column_path682 = _t1282 + if ((self.match_lookahead_literal(":", 0) or self.match_lookahead_literal("[", 0)) or self.match_lookahead_terminal("UINT128", 0)): + _t1284 = self.parse_csv_column_tail() + _t1283 = _t1284 + else: + _t1283 = None + csv_column_tail683 = _t1283 self.consume_literal(")") - _t1260 = logic_pb2.CSVColumn(column_name=string670, target_id=relation_id671, types=types675) - return _t1260 + _t1285 = self.construct_csv_column(csv_column_path682, csv_column_tail683) + return _t1285 + + def parse_csv_column_path(self) -> Sequence[str]: + if self.match_lookahead_literal("[", 0): + _t1286 = 1 + else: + if self.match_lookahead_terminal("STRING", 0): + _t1287 = 0 + else: + _t1287 = -1 + _t1286 = _t1287 + prediction684 = _t1286 + if prediction684 == 1: + self.consume_literal("[") + xs686 = [] + cond687 = self.match_lookahead_terminal("STRING", 0) + while cond687: + item688 = self.consume_terminal("STRING") + xs686.append(item688) + cond687 = self.match_lookahead_terminal("STRING", 0) + strings689 = xs686 + self.consume_literal("]") + _t1288 = strings689 + else: + if prediction684 == 0: + string685 = self.consume_terminal("STRING") + _t1289 = [string685] + else: + raise ParseError("Unexpected token in csv_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t1288 = _t1289 + return _t1288 + + def parse_csv_column_tail(self) -> tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]: + if self.match_lookahead_literal("[", 0): + _t1290 = 1 + else: + if self.match_lookahead_literal(":", 0): + _t1291 = 0 + else: + if self.match_lookahead_terminal("UINT128", 0): + _t1292 = 0 + else: + _t1292 = -1 + _t1291 = _t1292 + _t1290 = _t1291 + prediction690 = _t1290 + if prediction690 == 1: + self.consume_literal("[") + xs696 = [] + cond697 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond697: + _t1294 = self.parse_type() + item698 = _t1294 + xs696.append(item698) + cond697 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types699 = xs696 + self.consume_literal("]") + _t1293 = (None, types699,) + else: + if prediction690 == 0: + _t1296 = self.parse_relation_id() + relation_id691 = _t1296 + self.consume_literal("[") + xs692 = [] + cond693 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond693: + _t1297 = self.parse_type() + item694 = _t1297 + xs692.append(item694) + cond693 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types695 = xs692 + self.consume_literal("]") + _t1295 = (relation_id691, types695,) + else: + raise ParseError("Unexpected token in csv_column_tail" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t1293 = _t1295 + return _t1293 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string676 = self.consume_terminal("STRING") + string700 = self.consume_terminal("STRING") self.consume_literal(")") - return string676 + return string700 def parse_undefine(self) -> transactions_pb2.Undefine: self.consume_literal("(") self.consume_literal("undefine") - _t1261 = self.parse_fragment_id() - fragment_id677 = _t1261 + _t1298 = self.parse_fragment_id() + fragment_id701 = _t1298 self.consume_literal(")") - _t1262 = transactions_pb2.Undefine(fragment_id=fragment_id677) - return _t1262 + _t1299 = transactions_pb2.Undefine(fragment_id=fragment_id701) + return _t1299 def parse_context(self) -> transactions_pb2.Context: self.consume_literal("(") self.consume_literal("context") - xs678 = [] - cond679 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond679: - _t1263 = self.parse_relation_id() - item680 = _t1263 - xs678.append(item680) - cond679 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids681 = xs678 - self.consume_literal(")") - _t1264 = transactions_pb2.Context(relations=relation_ids681) - return _t1264 + xs702 = [] + cond703 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond703: + _t1300 = self.parse_relation_id() + item704 = _t1300 + xs702.append(item704) + cond703 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids705 = xs702 + self.consume_literal(")") + _t1301 = transactions_pb2.Context(relations=relation_ids705) + return _t1301 def parse_snapshot(self) -> transactions_pb2.Snapshot: self.consume_literal("(") self.consume_literal("snapshot") - _t1265 = self.parse_rel_edb_path() - rel_edb_path682 = _t1265 - _t1266 = self.parse_relation_id() - relation_id683 = _t1266 + _t1302 = self.parse_rel_edb_path() + rel_edb_path706 = _t1302 + _t1303 = self.parse_relation_id() + relation_id707 = _t1303 self.consume_literal(")") - _t1267 = transactions_pb2.Snapshot(destination_path=rel_edb_path682, source_relation=relation_id683) - return _t1267 + _t1304 = transactions_pb2.Snapshot(destination_path=rel_edb_path706, source_relation=relation_id707) + return _t1304 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs684 = [] - cond685 = self.match_lookahead_literal("(", 0) - while cond685: - _t1268 = self.parse_read() - item686 = _t1268 - xs684.append(item686) - cond685 = self.match_lookahead_literal("(", 0) - reads687 = xs684 + xs708 = [] + cond709 = self.match_lookahead_literal("(", 0) + while cond709: + _t1305 = self.parse_read() + item710 = _t1305 + xs708.append(item710) + cond709 = self.match_lookahead_literal("(", 0) + reads711 = xs708 self.consume_literal(")") - return reads687 + return reads711 def parse_read(self) -> transactions_pb2.Read: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t1270 = 2 + _t1307 = 2 else: if self.match_lookahead_literal("output", 1): - _t1271 = 1 + _t1308 = 1 else: if self.match_lookahead_literal("export", 1): - _t1272 = 4 + _t1309 = 4 else: if self.match_lookahead_literal("demand", 1): - _t1273 = 0 + _t1310 = 0 else: if self.match_lookahead_literal("abort", 1): - _t1274 = 3 + _t1311 = 3 else: - _t1274 = -1 - _t1273 = _t1274 - _t1272 = _t1273 - _t1271 = _t1272 - _t1270 = _t1271 - _t1269 = _t1270 - else: - _t1269 = -1 - prediction688 = _t1269 - if prediction688 == 4: - _t1276 = self.parse_export() - export693 = _t1276 - _t1277 = transactions_pb2.Read(export=export693) - _t1275 = _t1277 - else: - if prediction688 == 3: - _t1279 = self.parse_abort() - abort692 = _t1279 - _t1280 = transactions_pb2.Read(abort=abort692) - _t1278 = _t1280 + _t1311 = -1 + _t1310 = _t1311 + _t1309 = _t1310 + _t1308 = _t1309 + _t1307 = _t1308 + _t1306 = _t1307 + else: + _t1306 = -1 + prediction712 = _t1306 + if prediction712 == 4: + _t1313 = self.parse_export() + export717 = _t1313 + _t1314 = transactions_pb2.Read(export=export717) + _t1312 = _t1314 + else: + if prediction712 == 3: + _t1316 = self.parse_abort() + abort716 = _t1316 + _t1317 = transactions_pb2.Read(abort=abort716) + _t1315 = _t1317 else: - if prediction688 == 2: - _t1282 = self.parse_what_if() - what_if691 = _t1282 - _t1283 = transactions_pb2.Read(what_if=what_if691) - _t1281 = _t1283 + if prediction712 == 2: + _t1319 = self.parse_what_if() + what_if715 = _t1319 + _t1320 = transactions_pb2.Read(what_if=what_if715) + _t1318 = _t1320 else: - if prediction688 == 1: - _t1285 = self.parse_output() - output690 = _t1285 - _t1286 = transactions_pb2.Read(output=output690) - _t1284 = _t1286 + if prediction712 == 1: + _t1322 = self.parse_output() + output714 = _t1322 + _t1323 = transactions_pb2.Read(output=output714) + _t1321 = _t1323 else: - if prediction688 == 0: - _t1288 = self.parse_demand() - demand689 = _t1288 - _t1289 = transactions_pb2.Read(demand=demand689) - _t1287 = _t1289 + if prediction712 == 0: + _t1325 = self.parse_demand() + demand713 = _t1325 + _t1326 = transactions_pb2.Read(demand=demand713) + _t1324 = _t1326 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1284 = _t1287 - _t1281 = _t1284 - _t1278 = _t1281 - _t1275 = _t1278 - return _t1275 + _t1321 = _t1324 + _t1318 = _t1321 + _t1315 = _t1318 + _t1312 = _t1315 + return _t1312 def parse_demand(self) -> transactions_pb2.Demand: self.consume_literal("(") self.consume_literal("demand") - _t1290 = self.parse_relation_id() - relation_id694 = _t1290 + _t1327 = self.parse_relation_id() + relation_id718 = _t1327 self.consume_literal(")") - _t1291 = transactions_pb2.Demand(relation_id=relation_id694) - return _t1291 + _t1328 = transactions_pb2.Demand(relation_id=relation_id718) + return _t1328 def parse_output(self) -> transactions_pb2.Output: self.consume_literal("(") self.consume_literal("output") - _t1292 = self.parse_name() - name695 = _t1292 - _t1293 = self.parse_relation_id() - relation_id696 = _t1293 + _t1329 = self.parse_name() + name719 = _t1329 + _t1330 = self.parse_relation_id() + relation_id720 = _t1330 self.consume_literal(")") - _t1294 = transactions_pb2.Output(name=name695, relation_id=relation_id696) - return _t1294 + _t1331 = transactions_pb2.Output(name=name719, relation_id=relation_id720) + return _t1331 def parse_what_if(self) -> transactions_pb2.WhatIf: self.consume_literal("(") self.consume_literal("what_if") - _t1295 = self.parse_name() - name697 = _t1295 - _t1296 = self.parse_epoch() - epoch698 = _t1296 + _t1332 = self.parse_name() + name721 = _t1332 + _t1333 = self.parse_epoch() + epoch722 = _t1333 self.consume_literal(")") - _t1297 = transactions_pb2.WhatIf(branch=name697, epoch=epoch698) - return _t1297 + _t1334 = transactions_pb2.WhatIf(branch=name721, epoch=epoch722) + return _t1334 def parse_abort(self) -> transactions_pb2.Abort: self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t1299 = self.parse_name() - _t1298 = _t1299 + _t1336 = self.parse_name() + _t1335 = _t1336 else: - _t1298 = None - name699 = _t1298 - _t1300 = self.parse_relation_id() - relation_id700 = _t1300 + _t1335 = None + name723 = _t1335 + _t1337 = self.parse_relation_id() + relation_id724 = _t1337 self.consume_literal(")") - _t1301 = transactions_pb2.Abort(name=(name699 if name699 is not None else "abort"), relation_id=relation_id700) - return _t1301 + _t1338 = transactions_pb2.Abort(name=(name723 if name723 is not None else "abort"), relation_id=relation_id724) + return _t1338 def parse_export(self) -> transactions_pb2.Export: self.consume_literal("(") self.consume_literal("export") - _t1302 = self.parse_export_csv_config() - export_csv_config701 = _t1302 + _t1339 = self.parse_export_csv_config() + export_csv_config725 = _t1339 self.consume_literal(")") - _t1303 = transactions_pb2.Export(csv_config=export_csv_config701) - return _t1303 + _t1340 = transactions_pb2.Export(csv_config=export_csv_config725) + return _t1340 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: self.consume_literal("(") self.consume_literal("export_csv_config") - _t1304 = self.parse_export_csv_path() - export_csv_path702 = _t1304 - _t1305 = self.parse_export_csv_columns() - export_csv_columns703 = _t1305 - _t1306 = self.parse_config_dict() - config_dict704 = _t1306 + _t1341 = self.parse_export_csv_path() + export_csv_path726 = _t1341 + _t1342 = self.parse_export_csv_columns() + export_csv_columns727 = _t1342 + _t1343 = self.parse_config_dict() + config_dict728 = _t1343 self.consume_literal(")") - _t1307 = self.export_csv_config(export_csv_path702, export_csv_columns703, config_dict704) - return _t1307 + _t1344 = self.export_csv_config(export_csv_path726, export_csv_columns727, config_dict728) + return _t1344 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string705 = self.consume_terminal("STRING") + string729 = self.consume_terminal("STRING") self.consume_literal(")") - return string705 + return string729 def parse_export_csv_columns(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs706 = [] - cond707 = self.match_lookahead_literal("(", 0) - while cond707: - _t1308 = self.parse_export_csv_column() - item708 = _t1308 - xs706.append(item708) - cond707 = self.match_lookahead_literal("(", 0) - export_csv_columns709 = xs706 + xs730 = [] + cond731 = self.match_lookahead_literal("(", 0) + while cond731: + _t1345 = self.parse_export_csv_column() + item732 = _t1345 + xs730.append(item732) + cond731 = self.match_lookahead_literal("(", 0) + export_csv_columns733 = xs730 self.consume_literal(")") - return export_csv_columns709 + return export_csv_columns733 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: self.consume_literal("(") self.consume_literal("column") - string710 = self.consume_terminal("STRING") - _t1309 = self.parse_relation_id() - relation_id711 = _t1309 + string734 = self.consume_terminal("STRING") + _t1346 = self.parse_relation_id() + relation_id735 = _t1346 self.consume_literal(")") - _t1310 = transactions_pb2.ExportCSVColumn(column_name=string710, column_data=relation_id711) - return _t1310 + _t1347 = transactions_pb2.ExportCSVColumn(column_name=string734, column_data=relation_id735) + return _t1347 def parse(input_str: str) -> Any: diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index e58dfdd5..0a04c46e 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -193,133 +193,140 @@ def write_debug_info(self) -> None: # --- Helper functions --- def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1654 = logic_pb2.Value(int_value=int(v)) - return _t1654 + _t1698 = logic_pb2.Value(int_value=int(v)) + return _t1698 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1655 = logic_pb2.Value(int_value=v) - return _t1655 + _t1699 = logic_pb2.Value(int_value=v) + return _t1699 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1656 = logic_pb2.Value(float_value=v) - return _t1656 + _t1700 = logic_pb2.Value(float_value=v) + return _t1700 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1657 = logic_pb2.Value(string_value=v) - return _t1657 + _t1701 = logic_pb2.Value(string_value=v) + return _t1701 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1658 = logic_pb2.Value(boolean_value=v) - return _t1658 + _t1702 = logic_pb2.Value(boolean_value=v) + return _t1702 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1659 = logic_pb2.Value(uint128_value=v) - return _t1659 + _t1703 = logic_pb2.Value(uint128_value=v) + return _t1703 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: - _t1660 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1660,)) + _t1704 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1704,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1661 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1661,)) + _t1705 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1705,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1662 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1662,)) - _t1663 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1663,)) + _t1706 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1706,)) + _t1707 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1707,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1664 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1664,)) - _t1665 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1665,)) + _t1708 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1708,)) + _t1709 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1709,)) if msg.new_line != "": - _t1666 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1666,)) - _t1667 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1667,)) - _t1668 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1668,)) - _t1669 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1669,)) + _t1710 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1710,)) + _t1711 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1711,)) + _t1712 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1712,)) + _t1713 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1713,)) if msg.comment != "": - _t1670 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1670,)) + _t1714 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1714,)) for missing_string in msg.missing_strings: - _t1671 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1671,)) - _t1672 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1672,)) - _t1673 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1673,)) - _t1674 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1674,)) + _t1715 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1715,)) + _t1716 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1716,)) + _t1717 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1717,)) + _t1718 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1718,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1675 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1675,)) - _t1676 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1676,)) - _t1677 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1677,)) - _t1678 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1678,)) + _t1719 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1719,)) + _t1720 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1720,)) + _t1721 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1721,)) + _t1722 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1722,)) 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 - _t1679 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1679,)) + _t1723 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1723,)) 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 - _t1680 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1680,)) - _t1681 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1681,)) - _t1682 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1682,)) + _t1724 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1724,)) + _t1725 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1725,)) + _t1726 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1726,)) 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 - _t1683 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1683,)) + _t1727 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1727,)) if msg.compression is not None: assert msg.compression is not None - _t1684 = self._make_value_string(msg.compression) - result.append(("compression", _t1684,)) + _t1728 = self._make_value_string(msg.compression) + result.append(("compression", _t1728,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1685 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1685,)) + _t1729 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1729,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1686 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1686,)) + _t1730 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1730,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1687 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1687,)) + _t1731 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1731,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1688 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1688,)) + _t1732 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1732,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1689 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1689,)) + _t1733 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1733,)) return sorted(result) + def deconstruct_csv_column_tail(self, col: logic_pb2.CSVColumn) -> Optional[tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]]: + if (col.HasField("target_id") or not len(col.types) == 0): + return (col.target_id, col.types,) + else: + _t1734 = None + return None + def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: name = self.relation_id_to_string(msg) assert name is not None @@ -330,7 +337,7 @@ def deconstruct_relation_id_uint128(self, msg: logic_pb2.RelationId) -> Optional if name is None: return self.relation_id_to_uint128(msg) else: - _t1690 = None + _t1735 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -345,3453 +352,3535 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat638 = self._try_flat(msg, self.pretty_transaction) - if flat638 is not None: - assert flat638 is not None - self.write(flat638) + flat654 = self._try_flat(msg, self.pretty_transaction) + if flat654 is not None: + assert flat654 is not None + self.write(flat654) return None else: - def _t1258(_dollar_dollar): + def _t1290(_dollar_dollar): if _dollar_dollar.HasField("configure"): - _t1259 = _dollar_dollar.configure + _t1291 = _dollar_dollar.configure else: - _t1259 = None + _t1291 = None if _dollar_dollar.HasField("sync"): - _t1260 = _dollar_dollar.sync + _t1292 = _dollar_dollar.sync else: - _t1260 = None - return (_t1259, _t1260, _dollar_dollar.epochs,) - _t1261 = _t1258(msg) - fields629 = _t1261 - assert fields629 is not None - unwrapped_fields630 = fields629 + _t1292 = None + return (_t1291, _t1292, _dollar_dollar.epochs,) + _t1293 = _t1290(msg) + fields645 = _t1293 + assert fields645 is not None + unwrapped_fields646 = fields645 self.write("(") self.write("transaction") self.indent_sexp() - field631 = unwrapped_fields630[0] - if field631 is not None: + field647 = unwrapped_fields646[0] + if field647 is not None: self.newline() - assert field631 is not None - opt_val632 = field631 - self.pretty_configure(opt_val632) - field633 = unwrapped_fields630[1] - if field633 is not None: + assert field647 is not None + opt_val648 = field647 + self.pretty_configure(opt_val648) + field649 = unwrapped_fields646[1] + if field649 is not None: self.newline() - assert field633 is not None - opt_val634 = field633 - self.pretty_sync(opt_val634) - field635 = unwrapped_fields630[2] - if not len(field635) == 0: + assert field649 is not None + opt_val650 = field649 + self.pretty_sync(opt_val650) + field651 = unwrapped_fields646[2] + if not len(field651) == 0: self.newline() - for i637, elem636 in enumerate(field635): - if (i637 > 0): + for i653, elem652 in enumerate(field651): + if (i653 > 0): self.newline() - self.pretty_epoch(elem636) + self.pretty_epoch(elem652) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat641 = self._try_flat(msg, self.pretty_configure) - if flat641 is not None: - assert flat641 is not None - self.write(flat641) + flat657 = self._try_flat(msg, self.pretty_configure) + if flat657 is not None: + assert flat657 is not None + self.write(flat657) return None else: - def _t1262(_dollar_dollar): - _t1263 = self.deconstruct_configure(_dollar_dollar) - return _t1263 - _t1264 = _t1262(msg) - fields639 = _t1264 - assert fields639 is not None - unwrapped_fields640 = fields639 + def _t1294(_dollar_dollar): + _t1295 = self.deconstruct_configure(_dollar_dollar) + return _t1295 + _t1296 = _t1294(msg) + fields655 = _t1296 + assert fields655 is not None + unwrapped_fields656 = fields655 self.write("(") self.write("configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields640) + self.pretty_config_dict(unwrapped_fields656) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat645 = self._try_flat(msg, self.pretty_config_dict) - if flat645 is not None: - assert flat645 is not None - self.write(flat645) + flat661 = self._try_flat(msg, self.pretty_config_dict) + if flat661 is not None: + assert flat661 is not None + self.write(flat661) return None else: - fields642 = msg + fields658 = msg self.write("{") self.indent() - if not len(fields642) == 0: + if not len(fields658) == 0: self.newline() - for i644, elem643 in enumerate(fields642): - if (i644 > 0): + for i660, elem659 in enumerate(fields658): + if (i660 > 0): self.newline() - self.pretty_config_key_value(elem643) + self.pretty_config_key_value(elem659) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat650 = self._try_flat(msg, self.pretty_config_key_value) - if flat650 is not None: - assert flat650 is not None - self.write(flat650) + flat666 = self._try_flat(msg, self.pretty_config_key_value) + if flat666 is not None: + assert flat666 is not None + self.write(flat666) return None else: - def _t1265(_dollar_dollar): + def _t1297(_dollar_dollar): return (_dollar_dollar[0], _dollar_dollar[1],) - _t1266 = _t1265(msg) - fields646 = _t1266 - assert fields646 is not None - unwrapped_fields647 = fields646 + _t1298 = _t1297(msg) + fields662 = _t1298 + assert fields662 is not None + unwrapped_fields663 = fields662 self.write(":") - field648 = unwrapped_fields647[0] - self.write(field648) + field664 = unwrapped_fields663[0] + self.write(field664) self.write(" ") - field649 = unwrapped_fields647[1] - self.pretty_value(field649) + field665 = unwrapped_fields663[1] + self.pretty_value(field665) def pretty_value(self, msg: logic_pb2.Value): - flat670 = self._try_flat(msg, self.pretty_value) - if flat670 is not None: - assert flat670 is not None - self.write(flat670) + flat686 = self._try_flat(msg, self.pretty_value) + if flat686 is not None: + assert flat686 is not None + self.write(flat686) return None else: - def _t1267(_dollar_dollar): + def _t1299(_dollar_dollar): if _dollar_dollar.HasField("date_value"): - _t1268 = _dollar_dollar.date_value + _t1300 = _dollar_dollar.date_value else: - _t1268 = None - return _t1268 - _t1269 = _t1267(msg) - deconstruct_result668 = _t1269 - if deconstruct_result668 is not None: - assert deconstruct_result668 is not None - unwrapped669 = deconstruct_result668 - self.pretty_date(unwrapped669) + _t1300 = None + return _t1300 + _t1301 = _t1299(msg) + deconstruct_result684 = _t1301 + if deconstruct_result684 is not None: + assert deconstruct_result684 is not None + unwrapped685 = deconstruct_result684 + self.pretty_date(unwrapped685) else: - def _t1270(_dollar_dollar): + def _t1302(_dollar_dollar): if _dollar_dollar.HasField("datetime_value"): - _t1271 = _dollar_dollar.datetime_value + _t1303 = _dollar_dollar.datetime_value else: - _t1271 = None - return _t1271 - _t1272 = _t1270(msg) - deconstruct_result666 = _t1272 - if deconstruct_result666 is not None: - assert deconstruct_result666 is not None - unwrapped667 = deconstruct_result666 - self.pretty_datetime(unwrapped667) + _t1303 = None + return _t1303 + _t1304 = _t1302(msg) + deconstruct_result682 = _t1304 + if deconstruct_result682 is not None: + assert deconstruct_result682 is not None + unwrapped683 = deconstruct_result682 + self.pretty_datetime(unwrapped683) else: - def _t1273(_dollar_dollar): + def _t1305(_dollar_dollar): if _dollar_dollar.HasField("string_value"): - _t1274 = _dollar_dollar.string_value + _t1306 = _dollar_dollar.string_value else: - _t1274 = None - return _t1274 - _t1275 = _t1273(msg) - deconstruct_result664 = _t1275 - if deconstruct_result664 is not None: - assert deconstruct_result664 is not None - unwrapped665 = deconstruct_result664 - self.write(self.format_string_value(unwrapped665)) + _t1306 = None + return _t1306 + _t1307 = _t1305(msg) + deconstruct_result680 = _t1307 + if deconstruct_result680 is not None: + assert deconstruct_result680 is not None + unwrapped681 = deconstruct_result680 + self.write(self.format_string_value(unwrapped681)) else: - def _t1276(_dollar_dollar): + def _t1308(_dollar_dollar): if _dollar_dollar.HasField("int_value"): - _t1277 = _dollar_dollar.int_value + _t1309 = _dollar_dollar.int_value else: - _t1277 = None - return _t1277 - _t1278 = _t1276(msg) - deconstruct_result662 = _t1278 - if deconstruct_result662 is not None: - assert deconstruct_result662 is not None - unwrapped663 = deconstruct_result662 - self.write(str(unwrapped663)) + _t1309 = None + return _t1309 + _t1310 = _t1308(msg) + deconstruct_result678 = _t1310 + if deconstruct_result678 is not None: + assert deconstruct_result678 is not None + unwrapped679 = deconstruct_result678 + self.write(str(unwrapped679)) else: - def _t1279(_dollar_dollar): + def _t1311(_dollar_dollar): if _dollar_dollar.HasField("float_value"): - _t1280 = _dollar_dollar.float_value + _t1312 = _dollar_dollar.float_value else: - _t1280 = None - return _t1280 - _t1281 = _t1279(msg) - deconstruct_result660 = _t1281 - if deconstruct_result660 is not None: - assert deconstruct_result660 is not None - unwrapped661 = deconstruct_result660 - self.write(str(unwrapped661)) + _t1312 = None + return _t1312 + _t1313 = _t1311(msg) + deconstruct_result676 = _t1313 + if deconstruct_result676 is not None: + assert deconstruct_result676 is not None + unwrapped677 = deconstruct_result676 + self.write(str(unwrapped677)) else: - def _t1282(_dollar_dollar): + def _t1314(_dollar_dollar): if _dollar_dollar.HasField("uint128_value"): - _t1283 = _dollar_dollar.uint128_value + _t1315 = _dollar_dollar.uint128_value else: - _t1283 = None - return _t1283 - _t1284 = _t1282(msg) - deconstruct_result658 = _t1284 - if deconstruct_result658 is not None: - assert deconstruct_result658 is not None - unwrapped659 = deconstruct_result658 - self.write(self.format_uint128(unwrapped659)) + _t1315 = None + return _t1315 + _t1316 = _t1314(msg) + deconstruct_result674 = _t1316 + if deconstruct_result674 is not None: + assert deconstruct_result674 is not None + unwrapped675 = deconstruct_result674 + self.write(self.format_uint128(unwrapped675)) else: - def _t1285(_dollar_dollar): + def _t1317(_dollar_dollar): if _dollar_dollar.HasField("int128_value"): - _t1286 = _dollar_dollar.int128_value + _t1318 = _dollar_dollar.int128_value else: - _t1286 = None - return _t1286 - _t1287 = _t1285(msg) - deconstruct_result656 = _t1287 - if deconstruct_result656 is not None: - assert deconstruct_result656 is not None - unwrapped657 = deconstruct_result656 - self.write(self.format_int128(unwrapped657)) + _t1318 = None + return _t1318 + _t1319 = _t1317(msg) + deconstruct_result672 = _t1319 + if deconstruct_result672 is not None: + assert deconstruct_result672 is not None + unwrapped673 = deconstruct_result672 + self.write(self.format_int128(unwrapped673)) else: - def _t1288(_dollar_dollar): + def _t1320(_dollar_dollar): if _dollar_dollar.HasField("decimal_value"): - _t1289 = _dollar_dollar.decimal_value + _t1321 = _dollar_dollar.decimal_value else: - _t1289 = None - return _t1289 - _t1290 = _t1288(msg) - deconstruct_result654 = _t1290 - if deconstruct_result654 is not None: - assert deconstruct_result654 is not None - unwrapped655 = deconstruct_result654 - self.write(self.format_decimal(unwrapped655)) + _t1321 = None + return _t1321 + _t1322 = _t1320(msg) + deconstruct_result670 = _t1322 + if deconstruct_result670 is not None: + assert deconstruct_result670 is not None + unwrapped671 = deconstruct_result670 + self.write(self.format_decimal(unwrapped671)) else: - def _t1291(_dollar_dollar): + def _t1323(_dollar_dollar): if _dollar_dollar.HasField("boolean_value"): - _t1292 = _dollar_dollar.boolean_value + _t1324 = _dollar_dollar.boolean_value else: - _t1292 = None - return _t1292 - _t1293 = _t1291(msg) - deconstruct_result652 = _t1293 - if deconstruct_result652 is not None: - assert deconstruct_result652 is not None - unwrapped653 = deconstruct_result652 - self.pretty_boolean_value(unwrapped653) + _t1324 = None + return _t1324 + _t1325 = _t1323(msg) + deconstruct_result668 = _t1325 + if deconstruct_result668 is not None: + assert deconstruct_result668 is not None + unwrapped669 = deconstruct_result668 + self.pretty_boolean_value(unwrapped669) else: - fields651 = msg + fields667 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat676 = self._try_flat(msg, self.pretty_date) - if flat676 is not None: - assert flat676 is not None - self.write(flat676) + flat692 = self._try_flat(msg, self.pretty_date) + if flat692 is not None: + assert flat692 is not None + self.write(flat692) return None else: - def _t1294(_dollar_dollar): + def _t1326(_dollar_dollar): return (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - _t1295 = _t1294(msg) - fields671 = _t1295 - assert fields671 is not None - unwrapped_fields672 = fields671 + _t1327 = _t1326(msg) + fields687 = _t1327 + assert fields687 is not None + unwrapped_fields688 = fields687 self.write("(") self.write("date") self.indent_sexp() self.newline() - field673 = unwrapped_fields672[0] - self.write(str(field673)) + field689 = unwrapped_fields688[0] + self.write(str(field689)) self.newline() - field674 = unwrapped_fields672[1] - self.write(str(field674)) + field690 = unwrapped_fields688[1] + self.write(str(field690)) self.newline() - field675 = unwrapped_fields672[2] - self.write(str(field675)) + field691 = unwrapped_fields688[2] + self.write(str(field691)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat687 = self._try_flat(msg, self.pretty_datetime) - if flat687 is not None: - assert flat687 is not None - self.write(flat687) + flat703 = self._try_flat(msg, self.pretty_datetime) + if flat703 is not None: + assert flat703 is not None + self.write(flat703) return None else: - def _t1296(_dollar_dollar): + def _t1328(_dollar_dollar): return (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),) - _t1297 = _t1296(msg) - fields677 = _t1297 - assert fields677 is not None - unwrapped_fields678 = fields677 + _t1329 = _t1328(msg) + fields693 = _t1329 + assert fields693 is not None + unwrapped_fields694 = fields693 self.write("(") self.write("datetime") self.indent_sexp() self.newline() - field679 = unwrapped_fields678[0] - self.write(str(field679)) + field695 = unwrapped_fields694[0] + self.write(str(field695)) self.newline() - field680 = unwrapped_fields678[1] - self.write(str(field680)) + field696 = unwrapped_fields694[1] + self.write(str(field696)) self.newline() - field681 = unwrapped_fields678[2] - self.write(str(field681)) + field697 = unwrapped_fields694[2] + self.write(str(field697)) self.newline() - field682 = unwrapped_fields678[3] - self.write(str(field682)) + field698 = unwrapped_fields694[3] + self.write(str(field698)) self.newline() - field683 = unwrapped_fields678[4] - self.write(str(field683)) + field699 = unwrapped_fields694[4] + self.write(str(field699)) self.newline() - field684 = unwrapped_fields678[5] - self.write(str(field684)) - field685 = unwrapped_fields678[6] - if field685 is not None: + field700 = unwrapped_fields694[5] + self.write(str(field700)) + field701 = unwrapped_fields694[6] + if field701 is not None: self.newline() - assert field685 is not None - opt_val686 = field685 - self.write(str(opt_val686)) + assert field701 is not None + opt_val702 = field701 + self.write(str(opt_val702)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): - def _t1298(_dollar_dollar): + def _t1330(_dollar_dollar): if _dollar_dollar: - _t1299 = () + _t1331 = () else: - _t1299 = None - return _t1299 - _t1300 = _t1298(msg) - deconstruct_result690 = _t1300 - if deconstruct_result690 is not None: - assert deconstruct_result690 is not None - unwrapped691 = deconstruct_result690 + _t1331 = None + return _t1331 + _t1332 = _t1330(msg) + deconstruct_result706 = _t1332 + if deconstruct_result706 is not None: + assert deconstruct_result706 is not None + unwrapped707 = deconstruct_result706 self.write("true") else: - def _t1301(_dollar_dollar): + def _t1333(_dollar_dollar): if not _dollar_dollar: - _t1302 = () + _t1334 = () else: - _t1302 = None - return _t1302 - _t1303 = _t1301(msg) - deconstruct_result688 = _t1303 - if deconstruct_result688 is not None: - assert deconstruct_result688 is not None - unwrapped689 = deconstruct_result688 + _t1334 = None + return _t1334 + _t1335 = _t1333(msg) + deconstruct_result704 = _t1335 + if deconstruct_result704 is not None: + assert deconstruct_result704 is not None + unwrapped705 = deconstruct_result704 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat696 = self._try_flat(msg, self.pretty_sync) - if flat696 is not None: - assert flat696 is not None - self.write(flat696) + flat712 = self._try_flat(msg, self.pretty_sync) + if flat712 is not None: + assert flat712 is not None + self.write(flat712) return None else: - def _t1304(_dollar_dollar): + def _t1336(_dollar_dollar): return _dollar_dollar.fragments - _t1305 = _t1304(msg) - fields692 = _t1305 - assert fields692 is not None - unwrapped_fields693 = fields692 + _t1337 = _t1336(msg) + fields708 = _t1337 + assert fields708 is not None + unwrapped_fields709 = fields708 self.write("(") self.write("sync") self.indent_sexp() - if not len(unwrapped_fields693) == 0: + if not len(unwrapped_fields709) == 0: self.newline() - for i695, elem694 in enumerate(unwrapped_fields693): - if (i695 > 0): + for i711, elem710 in enumerate(unwrapped_fields709): + if (i711 > 0): self.newline() - self.pretty_fragment_id(elem694) + self.pretty_fragment_id(elem710) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat699 = self._try_flat(msg, self.pretty_fragment_id) - if flat699 is not None: - assert flat699 is not None - self.write(flat699) + flat715 = self._try_flat(msg, self.pretty_fragment_id) + if flat715 is not None: + assert flat715 is not None + self.write(flat715) return None else: - def _t1306(_dollar_dollar): + def _t1338(_dollar_dollar): return self.fragment_id_to_string(_dollar_dollar) - _t1307 = _t1306(msg) - fields697 = _t1307 - assert fields697 is not None - unwrapped_fields698 = fields697 + _t1339 = _t1338(msg) + fields713 = _t1339 + assert fields713 is not None + unwrapped_fields714 = fields713 self.write(":") - self.write(unwrapped_fields698) + self.write(unwrapped_fields714) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat706 = self._try_flat(msg, self.pretty_epoch) - if flat706 is not None: - assert flat706 is not None - self.write(flat706) + flat722 = self._try_flat(msg, self.pretty_epoch) + if flat722 is not None: + assert flat722 is not None + self.write(flat722) return None else: - def _t1308(_dollar_dollar): + def _t1340(_dollar_dollar): if not len(_dollar_dollar.writes) == 0: - _t1309 = _dollar_dollar.writes + _t1341 = _dollar_dollar.writes else: - _t1309 = None + _t1341 = None if not len(_dollar_dollar.reads) == 0: - _t1310 = _dollar_dollar.reads + _t1342 = _dollar_dollar.reads else: - _t1310 = None - return (_t1309, _t1310,) - _t1311 = _t1308(msg) - fields700 = _t1311 - assert fields700 is not None - unwrapped_fields701 = fields700 + _t1342 = None + return (_t1341, _t1342,) + _t1343 = _t1340(msg) + fields716 = _t1343 + assert fields716 is not None + unwrapped_fields717 = fields716 self.write("(") self.write("epoch") self.indent_sexp() - field702 = unwrapped_fields701[0] - if field702 is not None: + field718 = unwrapped_fields717[0] + if field718 is not None: self.newline() - assert field702 is not None - opt_val703 = field702 - self.pretty_epoch_writes(opt_val703) - field704 = unwrapped_fields701[1] - if field704 is not None: + assert field718 is not None + opt_val719 = field718 + self.pretty_epoch_writes(opt_val719) + field720 = unwrapped_fields717[1] + if field720 is not None: self.newline() - assert field704 is not None - opt_val705 = field704 - self.pretty_epoch_reads(opt_val705) + assert field720 is not None + opt_val721 = field720 + self.pretty_epoch_reads(opt_val721) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat710 = self._try_flat(msg, self.pretty_epoch_writes) - if flat710 is not None: - assert flat710 is not None - self.write(flat710) + flat726 = self._try_flat(msg, self.pretty_epoch_writes) + if flat726 is not None: + assert flat726 is not None + self.write(flat726) return None else: - fields707 = msg + fields723 = msg self.write("(") self.write("writes") self.indent_sexp() - if not len(fields707) == 0: + if not len(fields723) == 0: self.newline() - for i709, elem708 in enumerate(fields707): - if (i709 > 0): + for i725, elem724 in enumerate(fields723): + if (i725 > 0): self.newline() - self.pretty_write(elem708) + self.pretty_write(elem724) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat719 = self._try_flat(msg, self.pretty_write) - if flat719 is not None: - assert flat719 is not None - self.write(flat719) + flat735 = self._try_flat(msg, self.pretty_write) + if flat735 is not None: + assert flat735 is not None + self.write(flat735) return None else: - def _t1312(_dollar_dollar): + def _t1344(_dollar_dollar): if _dollar_dollar.HasField("define"): - _t1313 = _dollar_dollar.define + _t1345 = _dollar_dollar.define else: - _t1313 = None - return _t1313 - _t1314 = _t1312(msg) - deconstruct_result717 = _t1314 - if deconstruct_result717 is not None: - assert deconstruct_result717 is not None - unwrapped718 = deconstruct_result717 - self.pretty_define(unwrapped718) + _t1345 = None + return _t1345 + _t1346 = _t1344(msg) + deconstruct_result733 = _t1346 + if deconstruct_result733 is not None: + assert deconstruct_result733 is not None + unwrapped734 = deconstruct_result733 + self.pretty_define(unwrapped734) else: - def _t1315(_dollar_dollar): + def _t1347(_dollar_dollar): if _dollar_dollar.HasField("undefine"): - _t1316 = _dollar_dollar.undefine + _t1348 = _dollar_dollar.undefine else: - _t1316 = None - return _t1316 - _t1317 = _t1315(msg) - deconstruct_result715 = _t1317 - if deconstruct_result715 is not None: - assert deconstruct_result715 is not None - unwrapped716 = deconstruct_result715 - self.pretty_undefine(unwrapped716) + _t1348 = None + return _t1348 + _t1349 = _t1347(msg) + deconstruct_result731 = _t1349 + if deconstruct_result731 is not None: + assert deconstruct_result731 is not None + unwrapped732 = deconstruct_result731 + self.pretty_undefine(unwrapped732) else: - def _t1318(_dollar_dollar): + def _t1350(_dollar_dollar): if _dollar_dollar.HasField("context"): - _t1319 = _dollar_dollar.context + _t1351 = _dollar_dollar.context else: - _t1319 = None - return _t1319 - _t1320 = _t1318(msg) - deconstruct_result713 = _t1320 - if deconstruct_result713 is not None: - assert deconstruct_result713 is not None - unwrapped714 = deconstruct_result713 - self.pretty_context(unwrapped714) + _t1351 = None + return _t1351 + _t1352 = _t1350(msg) + deconstruct_result729 = _t1352 + if deconstruct_result729 is not None: + assert deconstruct_result729 is not None + unwrapped730 = deconstruct_result729 + self.pretty_context(unwrapped730) else: - def _t1321(_dollar_dollar): + def _t1353(_dollar_dollar): if _dollar_dollar.HasField("snapshot"): - _t1322 = _dollar_dollar.snapshot + _t1354 = _dollar_dollar.snapshot else: - _t1322 = None - return _t1322 - _t1323 = _t1321(msg) - deconstruct_result711 = _t1323 - if deconstruct_result711 is not None: - assert deconstruct_result711 is not None - unwrapped712 = deconstruct_result711 - self.pretty_snapshot(unwrapped712) + _t1354 = None + return _t1354 + _t1355 = _t1353(msg) + deconstruct_result727 = _t1355 + if deconstruct_result727 is not None: + assert deconstruct_result727 is not None + unwrapped728 = deconstruct_result727 + self.pretty_snapshot(unwrapped728) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat722 = self._try_flat(msg, self.pretty_define) - if flat722 is not None: - assert flat722 is not None - self.write(flat722) + flat738 = self._try_flat(msg, self.pretty_define) + if flat738 is not None: + assert flat738 is not None + self.write(flat738) return None else: - def _t1324(_dollar_dollar): + def _t1356(_dollar_dollar): return _dollar_dollar.fragment - _t1325 = _t1324(msg) - fields720 = _t1325 - assert fields720 is not None - unwrapped_fields721 = fields720 + _t1357 = _t1356(msg) + fields736 = _t1357 + assert fields736 is not None + unwrapped_fields737 = fields736 self.write("(") self.write("define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields721) + self.pretty_fragment(unwrapped_fields737) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat729 = self._try_flat(msg, self.pretty_fragment) - if flat729 is not None: - assert flat729 is not None - self.write(flat729) + flat745 = self._try_flat(msg, self.pretty_fragment) + if flat745 is not None: + assert flat745 is not None + self.write(flat745) return None else: - def _t1326(_dollar_dollar): + def _t1358(_dollar_dollar): self.start_pretty_fragment(_dollar_dollar) return (_dollar_dollar.id, _dollar_dollar.declarations,) - _t1327 = _t1326(msg) - fields723 = _t1327 - assert fields723 is not None - unwrapped_fields724 = fields723 + _t1359 = _t1358(msg) + fields739 = _t1359 + assert fields739 is not None + unwrapped_fields740 = fields739 self.write("(") self.write("fragment") self.indent_sexp() self.newline() - field725 = unwrapped_fields724[0] - self.pretty_new_fragment_id(field725) - field726 = unwrapped_fields724[1] - if not len(field726) == 0: + field741 = unwrapped_fields740[0] + self.pretty_new_fragment_id(field741) + field742 = unwrapped_fields740[1] + if not len(field742) == 0: self.newline() - for i728, elem727 in enumerate(field726): - if (i728 > 0): + for i744, elem743 in enumerate(field742): + if (i744 > 0): self.newline() - self.pretty_declaration(elem727) + self.pretty_declaration(elem743) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat731 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat731 is not None: - assert flat731 is not None - self.write(flat731) + flat747 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat747 is not None: + assert flat747 is not None + self.write(flat747) return None else: - fields730 = msg - self.pretty_fragment_id(fields730) + fields746 = msg + self.pretty_fragment_id(fields746) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat740 = self._try_flat(msg, self.pretty_declaration) - if flat740 is not None: - assert flat740 is not None - self.write(flat740) + flat756 = self._try_flat(msg, self.pretty_declaration) + if flat756 is not None: + assert flat756 is not None + self.write(flat756) return None else: - def _t1328(_dollar_dollar): + def _t1360(_dollar_dollar): if _dollar_dollar.HasField("def"): - _t1329 = getattr(_dollar_dollar, 'def') + _t1361 = getattr(_dollar_dollar, 'def') else: - _t1329 = None - return _t1329 - _t1330 = _t1328(msg) - deconstruct_result738 = _t1330 - if deconstruct_result738 is not None: - assert deconstruct_result738 is not None - unwrapped739 = deconstruct_result738 - self.pretty_def(unwrapped739) + _t1361 = None + return _t1361 + _t1362 = _t1360(msg) + deconstruct_result754 = _t1362 + if deconstruct_result754 is not None: + assert deconstruct_result754 is not None + unwrapped755 = deconstruct_result754 + self.pretty_def(unwrapped755) else: - def _t1331(_dollar_dollar): + def _t1363(_dollar_dollar): if _dollar_dollar.HasField("algorithm"): - _t1332 = _dollar_dollar.algorithm + _t1364 = _dollar_dollar.algorithm else: - _t1332 = None - return _t1332 - _t1333 = _t1331(msg) - deconstruct_result736 = _t1333 - if deconstruct_result736 is not None: - assert deconstruct_result736 is not None - unwrapped737 = deconstruct_result736 - self.pretty_algorithm(unwrapped737) + _t1364 = None + return _t1364 + _t1365 = _t1363(msg) + deconstruct_result752 = _t1365 + if deconstruct_result752 is not None: + assert deconstruct_result752 is not None + unwrapped753 = deconstruct_result752 + self.pretty_algorithm(unwrapped753) else: - def _t1334(_dollar_dollar): + def _t1366(_dollar_dollar): if _dollar_dollar.HasField("constraint"): - _t1335 = _dollar_dollar.constraint + _t1367 = _dollar_dollar.constraint else: - _t1335 = None - return _t1335 - _t1336 = _t1334(msg) - deconstruct_result734 = _t1336 - if deconstruct_result734 is not None: - assert deconstruct_result734 is not None - unwrapped735 = deconstruct_result734 - self.pretty_constraint(unwrapped735) + _t1367 = None + return _t1367 + _t1368 = _t1366(msg) + deconstruct_result750 = _t1368 + if deconstruct_result750 is not None: + assert deconstruct_result750 is not None + unwrapped751 = deconstruct_result750 + self.pretty_constraint(unwrapped751) else: - def _t1337(_dollar_dollar): + def _t1369(_dollar_dollar): if _dollar_dollar.HasField("data"): - _t1338 = _dollar_dollar.data + _t1370 = _dollar_dollar.data else: - _t1338 = None - return _t1338 - _t1339 = _t1337(msg) - deconstruct_result732 = _t1339 - if deconstruct_result732 is not None: - assert deconstruct_result732 is not None - unwrapped733 = deconstruct_result732 - self.pretty_data(unwrapped733) + _t1370 = None + return _t1370 + _t1371 = _t1369(msg) + deconstruct_result748 = _t1371 + if deconstruct_result748 is not None: + assert deconstruct_result748 is not None + unwrapped749 = deconstruct_result748 + self.pretty_data(unwrapped749) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat747 = self._try_flat(msg, self.pretty_def) - if flat747 is not None: - assert flat747 is not None - self.write(flat747) + flat763 = self._try_flat(msg, self.pretty_def) + if flat763 is not None: + assert flat763 is not None + self.write(flat763) return None else: - def _t1340(_dollar_dollar): + def _t1372(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1341 = _dollar_dollar.attrs + _t1373 = _dollar_dollar.attrs else: - _t1341 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1341,) - _t1342 = _t1340(msg) - fields741 = _t1342 - assert fields741 is not None - unwrapped_fields742 = fields741 + _t1373 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1373,) + _t1374 = _t1372(msg) + fields757 = _t1374 + assert fields757 is not None + unwrapped_fields758 = fields757 self.write("(") self.write("def") self.indent_sexp() self.newline() - field743 = unwrapped_fields742[0] - self.pretty_relation_id(field743) + field759 = unwrapped_fields758[0] + self.pretty_relation_id(field759) self.newline() - field744 = unwrapped_fields742[1] - self.pretty_abstraction(field744) - field745 = unwrapped_fields742[2] - if field745 is not None: + field760 = unwrapped_fields758[1] + self.pretty_abstraction(field760) + field761 = unwrapped_fields758[2] + if field761 is not None: self.newline() - assert field745 is not None - opt_val746 = field745 - self.pretty_attrs(opt_val746) + assert field761 is not None + opt_val762 = field761 + self.pretty_attrs(opt_val762) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat752 = self._try_flat(msg, self.pretty_relation_id) - if flat752 is not None: - assert flat752 is not None - self.write(flat752) + flat768 = self._try_flat(msg, self.pretty_relation_id) + if flat768 is not None: + assert flat768 is not None + self.write(flat768) return None else: - def _t1343(_dollar_dollar): + def _t1375(_dollar_dollar): if self.relation_id_to_string(_dollar_dollar) is not None: - _t1345 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1344 = _t1345 + _t1377 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1376 = _t1377 else: - _t1344 = None - return _t1344 - _t1346 = _t1343(msg) - deconstruct_result750 = _t1346 - if deconstruct_result750 is not None: - assert deconstruct_result750 is not None - unwrapped751 = deconstruct_result750 + _t1376 = None + return _t1376 + _t1378 = _t1375(msg) + deconstruct_result766 = _t1378 + if deconstruct_result766 is not None: + assert deconstruct_result766 is not None + unwrapped767 = deconstruct_result766 self.write(":") - self.write(unwrapped751) + self.write(unwrapped767) else: - def _t1347(_dollar_dollar): - _t1348 = self.deconstruct_relation_id_uint128(_dollar_dollar) - return _t1348 - _t1349 = _t1347(msg) - deconstruct_result748 = _t1349 - if deconstruct_result748 is not None: - assert deconstruct_result748 is not None - unwrapped749 = deconstruct_result748 - self.write(self.format_uint128(unwrapped749)) + def _t1379(_dollar_dollar): + _t1380 = self.deconstruct_relation_id_uint128(_dollar_dollar) + return _t1380 + _t1381 = _t1379(msg) + deconstruct_result764 = _t1381 + if deconstruct_result764 is not None: + assert deconstruct_result764 is not None + unwrapped765 = deconstruct_result764 + self.write(self.format_uint128(unwrapped765)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat757 = self._try_flat(msg, self.pretty_abstraction) - if flat757 is not None: - assert flat757 is not None - self.write(flat757) + flat773 = self._try_flat(msg, self.pretty_abstraction) + if flat773 is not None: + assert flat773 is not None + self.write(flat773) return None else: - def _t1350(_dollar_dollar): - _t1351 = self.deconstruct_bindings(_dollar_dollar) - return (_t1351, _dollar_dollar.value,) - _t1352 = _t1350(msg) - fields753 = _t1352 - assert fields753 is not None - unwrapped_fields754 = fields753 + def _t1382(_dollar_dollar): + _t1383 = self.deconstruct_bindings(_dollar_dollar) + return (_t1383, _dollar_dollar.value,) + _t1384 = _t1382(msg) + fields769 = _t1384 + assert fields769 is not None + unwrapped_fields770 = fields769 self.write("(") self.indent() - field755 = unwrapped_fields754[0] - self.pretty_bindings(field755) + field771 = unwrapped_fields770[0] + self.pretty_bindings(field771) self.newline() - field756 = unwrapped_fields754[1] - self.pretty_formula(field756) + field772 = unwrapped_fields770[1] + self.pretty_formula(field772) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat765 = self._try_flat(msg, self.pretty_bindings) - if flat765 is not None: - assert flat765 is not None - self.write(flat765) + flat781 = self._try_flat(msg, self.pretty_bindings) + if flat781 is not None: + assert flat781 is not None + self.write(flat781) return None else: - def _t1353(_dollar_dollar): + def _t1385(_dollar_dollar): if not len(_dollar_dollar[1]) == 0: - _t1354 = _dollar_dollar[1] + _t1386 = _dollar_dollar[1] else: - _t1354 = None - return (_dollar_dollar[0], _t1354,) - _t1355 = _t1353(msg) - fields758 = _t1355 - assert fields758 is not None - unwrapped_fields759 = fields758 + _t1386 = None + return (_dollar_dollar[0], _t1386,) + _t1387 = _t1385(msg) + fields774 = _t1387 + assert fields774 is not None + unwrapped_fields775 = fields774 self.write("[") self.indent() - field760 = unwrapped_fields759[0] - for i762, elem761 in enumerate(field760): - if (i762 > 0): + field776 = unwrapped_fields775[0] + for i778, elem777 in enumerate(field776): + if (i778 > 0): self.newline() - self.pretty_binding(elem761) - field763 = unwrapped_fields759[1] - if field763 is not None: + self.pretty_binding(elem777) + field779 = unwrapped_fields775[1] + if field779 is not None: self.newline() - assert field763 is not None - opt_val764 = field763 - self.pretty_value_bindings(opt_val764) + assert field779 is not None + opt_val780 = field779 + self.pretty_value_bindings(opt_val780) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat770 = self._try_flat(msg, self.pretty_binding) - if flat770 is not None: - assert flat770 is not None - self.write(flat770) + flat786 = self._try_flat(msg, self.pretty_binding) + if flat786 is not None: + assert flat786 is not None + self.write(flat786) return None else: - def _t1356(_dollar_dollar): + def _t1388(_dollar_dollar): return (_dollar_dollar.var.name, _dollar_dollar.type,) - _t1357 = _t1356(msg) - fields766 = _t1357 - assert fields766 is not None - unwrapped_fields767 = fields766 - field768 = unwrapped_fields767[0] - self.write(field768) + _t1389 = _t1388(msg) + fields782 = _t1389 + assert fields782 is not None + unwrapped_fields783 = fields782 + field784 = unwrapped_fields783[0] + self.write(field784) self.write("::") - field769 = unwrapped_fields767[1] - self.pretty_type(field769) + field785 = unwrapped_fields783[1] + self.pretty_type(field785) def pretty_type(self, msg: logic_pb2.Type): - flat793 = self._try_flat(msg, self.pretty_type) - if flat793 is not None: - assert flat793 is not None - self.write(flat793) + flat809 = self._try_flat(msg, self.pretty_type) + if flat809 is not None: + assert flat809 is not None + self.write(flat809) return None else: - def _t1358(_dollar_dollar): + def _t1390(_dollar_dollar): if _dollar_dollar.HasField("unspecified_type"): - _t1359 = _dollar_dollar.unspecified_type + _t1391 = _dollar_dollar.unspecified_type else: - _t1359 = None - return _t1359 - _t1360 = _t1358(msg) - deconstruct_result791 = _t1360 - if deconstruct_result791 is not None: - assert deconstruct_result791 is not None - unwrapped792 = deconstruct_result791 - self.pretty_unspecified_type(unwrapped792) + _t1391 = None + return _t1391 + _t1392 = _t1390(msg) + deconstruct_result807 = _t1392 + if deconstruct_result807 is not None: + assert deconstruct_result807 is not None + unwrapped808 = deconstruct_result807 + self.pretty_unspecified_type(unwrapped808) else: - def _t1361(_dollar_dollar): + def _t1393(_dollar_dollar): if _dollar_dollar.HasField("string_type"): - _t1362 = _dollar_dollar.string_type + _t1394 = _dollar_dollar.string_type else: - _t1362 = None - return _t1362 - _t1363 = _t1361(msg) - deconstruct_result789 = _t1363 - if deconstruct_result789 is not None: - assert deconstruct_result789 is not None - unwrapped790 = deconstruct_result789 - self.pretty_string_type(unwrapped790) + _t1394 = None + return _t1394 + _t1395 = _t1393(msg) + deconstruct_result805 = _t1395 + if deconstruct_result805 is not None: + assert deconstruct_result805 is not None + unwrapped806 = deconstruct_result805 + self.pretty_string_type(unwrapped806) else: - def _t1364(_dollar_dollar): + def _t1396(_dollar_dollar): if _dollar_dollar.HasField("int_type"): - _t1365 = _dollar_dollar.int_type + _t1397 = _dollar_dollar.int_type else: - _t1365 = None - return _t1365 - _t1366 = _t1364(msg) - deconstruct_result787 = _t1366 - if deconstruct_result787 is not None: - assert deconstruct_result787 is not None - unwrapped788 = deconstruct_result787 - self.pretty_int_type(unwrapped788) + _t1397 = None + return _t1397 + _t1398 = _t1396(msg) + deconstruct_result803 = _t1398 + if deconstruct_result803 is not None: + assert deconstruct_result803 is not None + unwrapped804 = deconstruct_result803 + self.pretty_int_type(unwrapped804) else: - def _t1367(_dollar_dollar): + def _t1399(_dollar_dollar): if _dollar_dollar.HasField("float_type"): - _t1368 = _dollar_dollar.float_type + _t1400 = _dollar_dollar.float_type else: - _t1368 = None - return _t1368 - _t1369 = _t1367(msg) - deconstruct_result785 = _t1369 - if deconstruct_result785 is not None: - assert deconstruct_result785 is not None - unwrapped786 = deconstruct_result785 - self.pretty_float_type(unwrapped786) + _t1400 = None + return _t1400 + _t1401 = _t1399(msg) + deconstruct_result801 = _t1401 + if deconstruct_result801 is not None: + assert deconstruct_result801 is not None + unwrapped802 = deconstruct_result801 + self.pretty_float_type(unwrapped802) else: - def _t1370(_dollar_dollar): + def _t1402(_dollar_dollar): if _dollar_dollar.HasField("uint128_type"): - _t1371 = _dollar_dollar.uint128_type + _t1403 = _dollar_dollar.uint128_type else: - _t1371 = None - return _t1371 - _t1372 = _t1370(msg) - deconstruct_result783 = _t1372 - if deconstruct_result783 is not None: - assert deconstruct_result783 is not None - unwrapped784 = deconstruct_result783 - self.pretty_uint128_type(unwrapped784) + _t1403 = None + return _t1403 + _t1404 = _t1402(msg) + deconstruct_result799 = _t1404 + if deconstruct_result799 is not None: + assert deconstruct_result799 is not None + unwrapped800 = deconstruct_result799 + self.pretty_uint128_type(unwrapped800) else: - def _t1373(_dollar_dollar): + def _t1405(_dollar_dollar): if _dollar_dollar.HasField("int128_type"): - _t1374 = _dollar_dollar.int128_type + _t1406 = _dollar_dollar.int128_type else: - _t1374 = None - return _t1374 - _t1375 = _t1373(msg) - deconstruct_result781 = _t1375 - if deconstruct_result781 is not None: - assert deconstruct_result781 is not None - unwrapped782 = deconstruct_result781 - self.pretty_int128_type(unwrapped782) + _t1406 = None + return _t1406 + _t1407 = _t1405(msg) + deconstruct_result797 = _t1407 + if deconstruct_result797 is not None: + assert deconstruct_result797 is not None + unwrapped798 = deconstruct_result797 + self.pretty_int128_type(unwrapped798) else: - def _t1376(_dollar_dollar): + def _t1408(_dollar_dollar): if _dollar_dollar.HasField("date_type"): - _t1377 = _dollar_dollar.date_type + _t1409 = _dollar_dollar.date_type else: - _t1377 = None - return _t1377 - _t1378 = _t1376(msg) - deconstruct_result779 = _t1378 - if deconstruct_result779 is not None: - assert deconstruct_result779 is not None - unwrapped780 = deconstruct_result779 - self.pretty_date_type(unwrapped780) + _t1409 = None + return _t1409 + _t1410 = _t1408(msg) + deconstruct_result795 = _t1410 + if deconstruct_result795 is not None: + assert deconstruct_result795 is not None + unwrapped796 = deconstruct_result795 + self.pretty_date_type(unwrapped796) else: - def _t1379(_dollar_dollar): + def _t1411(_dollar_dollar): if _dollar_dollar.HasField("datetime_type"): - _t1380 = _dollar_dollar.datetime_type + _t1412 = _dollar_dollar.datetime_type else: - _t1380 = None - return _t1380 - _t1381 = _t1379(msg) - deconstruct_result777 = _t1381 - if deconstruct_result777 is not None: - assert deconstruct_result777 is not None - unwrapped778 = deconstruct_result777 - self.pretty_datetime_type(unwrapped778) + _t1412 = None + return _t1412 + _t1413 = _t1411(msg) + deconstruct_result793 = _t1413 + if deconstruct_result793 is not None: + assert deconstruct_result793 is not None + unwrapped794 = deconstruct_result793 + self.pretty_datetime_type(unwrapped794) else: - def _t1382(_dollar_dollar): + def _t1414(_dollar_dollar): if _dollar_dollar.HasField("missing_type"): - _t1383 = _dollar_dollar.missing_type + _t1415 = _dollar_dollar.missing_type else: - _t1383 = None - return _t1383 - _t1384 = _t1382(msg) - deconstruct_result775 = _t1384 - if deconstruct_result775 is not None: - assert deconstruct_result775 is not None - unwrapped776 = deconstruct_result775 - self.pretty_missing_type(unwrapped776) + _t1415 = None + return _t1415 + _t1416 = _t1414(msg) + deconstruct_result791 = _t1416 + if deconstruct_result791 is not None: + assert deconstruct_result791 is not None + unwrapped792 = deconstruct_result791 + self.pretty_missing_type(unwrapped792) else: - def _t1385(_dollar_dollar): + def _t1417(_dollar_dollar): if _dollar_dollar.HasField("decimal_type"): - _t1386 = _dollar_dollar.decimal_type + _t1418 = _dollar_dollar.decimal_type else: - _t1386 = None - return _t1386 - _t1387 = _t1385(msg) - deconstruct_result773 = _t1387 - if deconstruct_result773 is not None: - assert deconstruct_result773 is not None - unwrapped774 = deconstruct_result773 - self.pretty_decimal_type(unwrapped774) + _t1418 = None + return _t1418 + _t1419 = _t1417(msg) + deconstruct_result789 = _t1419 + if deconstruct_result789 is not None: + assert deconstruct_result789 is not None + unwrapped790 = deconstruct_result789 + self.pretty_decimal_type(unwrapped790) else: - def _t1388(_dollar_dollar): + def _t1420(_dollar_dollar): if _dollar_dollar.HasField("boolean_type"): - _t1389 = _dollar_dollar.boolean_type + _t1421 = _dollar_dollar.boolean_type else: - _t1389 = None - return _t1389 - _t1390 = _t1388(msg) - deconstruct_result771 = _t1390 - if deconstruct_result771 is not None: - assert deconstruct_result771 is not None - unwrapped772 = deconstruct_result771 - self.pretty_boolean_type(unwrapped772) + _t1421 = None + return _t1421 + _t1422 = _t1420(msg) + deconstruct_result787 = _t1422 + if deconstruct_result787 is not None: + assert deconstruct_result787 is not None + unwrapped788 = deconstruct_result787 + self.pretty_boolean_type(unwrapped788) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields794 = msg + fields810 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields795 = msg + fields811 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields796 = msg + fields812 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields797 = msg + fields813 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields798 = msg + fields814 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields799 = msg + fields815 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields800 = msg + fields816 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields801 = msg + fields817 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields802 = msg + fields818 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat807 = self._try_flat(msg, self.pretty_decimal_type) - if flat807 is not None: - assert flat807 is not None - self.write(flat807) + flat823 = self._try_flat(msg, self.pretty_decimal_type) + if flat823 is not None: + assert flat823 is not None + self.write(flat823) return None else: - def _t1391(_dollar_dollar): + def _t1423(_dollar_dollar): return (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - _t1392 = _t1391(msg) - fields803 = _t1392 - assert fields803 is not None - unwrapped_fields804 = fields803 + _t1424 = _t1423(msg) + fields819 = _t1424 + assert fields819 is not None + unwrapped_fields820 = fields819 self.write("(") self.write("DECIMAL") self.indent_sexp() self.newline() - field805 = unwrapped_fields804[0] - self.write(str(field805)) + field821 = unwrapped_fields820[0] + self.write(str(field821)) self.newline() - field806 = unwrapped_fields804[1] - self.write(str(field806)) + field822 = unwrapped_fields820[1] + self.write(str(field822)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields808 = msg + fields824 = msg self.write("BOOLEAN") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat812 = self._try_flat(msg, self.pretty_value_bindings) - if flat812 is not None: - assert flat812 is not None - self.write(flat812) + flat828 = self._try_flat(msg, self.pretty_value_bindings) + if flat828 is not None: + assert flat828 is not None + self.write(flat828) return None else: - fields809 = msg + fields825 = msg self.write("|") - if not len(fields809) == 0: + if not len(fields825) == 0: self.write(" ") - for i811, elem810 in enumerate(fields809): - if (i811 > 0): + for i827, elem826 in enumerate(fields825): + if (i827 > 0): self.newline() - self.pretty_binding(elem810) + self.pretty_binding(elem826) def pretty_formula(self, msg: logic_pb2.Formula): - flat839 = self._try_flat(msg, self.pretty_formula) - if flat839 is not None: - assert flat839 is not None - self.write(flat839) + flat855 = self._try_flat(msg, self.pretty_formula) + if flat855 is not None: + assert flat855 is not None + self.write(flat855) return None else: - def _t1393(_dollar_dollar): + def _t1425(_dollar_dollar): if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1394 = _dollar_dollar.conjunction + _t1426 = _dollar_dollar.conjunction else: - _t1394 = None - return _t1394 - _t1395 = _t1393(msg) - deconstruct_result837 = _t1395 - if deconstruct_result837 is not None: - assert deconstruct_result837 is not None - unwrapped838 = deconstruct_result837 - self.pretty_true(unwrapped838) + _t1426 = None + return _t1426 + _t1427 = _t1425(msg) + deconstruct_result853 = _t1427 + if deconstruct_result853 is not None: + assert deconstruct_result853 is not None + unwrapped854 = deconstruct_result853 + self.pretty_true(unwrapped854) else: - def _t1396(_dollar_dollar): + def _t1428(_dollar_dollar): if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1397 = _dollar_dollar.disjunction + _t1429 = _dollar_dollar.disjunction else: - _t1397 = None - return _t1397 - _t1398 = _t1396(msg) - deconstruct_result835 = _t1398 - if deconstruct_result835 is not None: - assert deconstruct_result835 is not None - unwrapped836 = deconstruct_result835 - self.pretty_false(unwrapped836) + _t1429 = None + return _t1429 + _t1430 = _t1428(msg) + deconstruct_result851 = _t1430 + if deconstruct_result851 is not None: + assert deconstruct_result851 is not None + unwrapped852 = deconstruct_result851 + self.pretty_false(unwrapped852) else: - def _t1399(_dollar_dollar): + def _t1431(_dollar_dollar): if _dollar_dollar.HasField("exists"): - _t1400 = _dollar_dollar.exists + _t1432 = _dollar_dollar.exists else: - _t1400 = None - return _t1400 - _t1401 = _t1399(msg) - deconstruct_result833 = _t1401 - if deconstruct_result833 is not None: - assert deconstruct_result833 is not None - unwrapped834 = deconstruct_result833 - self.pretty_exists(unwrapped834) + _t1432 = None + return _t1432 + _t1433 = _t1431(msg) + deconstruct_result849 = _t1433 + if deconstruct_result849 is not None: + assert deconstruct_result849 is not None + unwrapped850 = deconstruct_result849 + self.pretty_exists(unwrapped850) else: - def _t1402(_dollar_dollar): + def _t1434(_dollar_dollar): if _dollar_dollar.HasField("reduce"): - _t1403 = _dollar_dollar.reduce + _t1435 = _dollar_dollar.reduce else: - _t1403 = None - return _t1403 - _t1404 = _t1402(msg) - deconstruct_result831 = _t1404 - if deconstruct_result831 is not None: - assert deconstruct_result831 is not None - unwrapped832 = deconstruct_result831 - self.pretty_reduce(unwrapped832) + _t1435 = None + return _t1435 + _t1436 = _t1434(msg) + deconstruct_result847 = _t1436 + if deconstruct_result847 is not None: + assert deconstruct_result847 is not None + unwrapped848 = deconstruct_result847 + self.pretty_reduce(unwrapped848) else: - def _t1405(_dollar_dollar): + def _t1437(_dollar_dollar): if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1406 = _dollar_dollar.conjunction + _t1438 = _dollar_dollar.conjunction else: - _t1406 = None - return _t1406 - _t1407 = _t1405(msg) - deconstruct_result829 = _t1407 - if deconstruct_result829 is not None: - assert deconstruct_result829 is not None - unwrapped830 = deconstruct_result829 - self.pretty_conjunction(unwrapped830) + _t1438 = None + return _t1438 + _t1439 = _t1437(msg) + deconstruct_result845 = _t1439 + if deconstruct_result845 is not None: + assert deconstruct_result845 is not None + unwrapped846 = deconstruct_result845 + self.pretty_conjunction(unwrapped846) else: - def _t1408(_dollar_dollar): + def _t1440(_dollar_dollar): if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1409 = _dollar_dollar.disjunction + _t1441 = _dollar_dollar.disjunction else: - _t1409 = None - return _t1409 - _t1410 = _t1408(msg) - deconstruct_result827 = _t1410 - if deconstruct_result827 is not None: - assert deconstruct_result827 is not None - unwrapped828 = deconstruct_result827 - self.pretty_disjunction(unwrapped828) + _t1441 = None + return _t1441 + _t1442 = _t1440(msg) + deconstruct_result843 = _t1442 + if deconstruct_result843 is not None: + assert deconstruct_result843 is not None + unwrapped844 = deconstruct_result843 + self.pretty_disjunction(unwrapped844) else: - def _t1411(_dollar_dollar): + def _t1443(_dollar_dollar): if _dollar_dollar.HasField("not"): - _t1412 = getattr(_dollar_dollar, 'not') + _t1444 = getattr(_dollar_dollar, 'not') else: - _t1412 = None - return _t1412 - _t1413 = _t1411(msg) - deconstruct_result825 = _t1413 - if deconstruct_result825 is not None: - assert deconstruct_result825 is not None - unwrapped826 = deconstruct_result825 - self.pretty_not(unwrapped826) + _t1444 = None + return _t1444 + _t1445 = _t1443(msg) + deconstruct_result841 = _t1445 + if deconstruct_result841 is not None: + assert deconstruct_result841 is not None + unwrapped842 = deconstruct_result841 + self.pretty_not(unwrapped842) else: - def _t1414(_dollar_dollar): + def _t1446(_dollar_dollar): if _dollar_dollar.HasField("ffi"): - _t1415 = _dollar_dollar.ffi + _t1447 = _dollar_dollar.ffi else: - _t1415 = None - return _t1415 - _t1416 = _t1414(msg) - deconstruct_result823 = _t1416 - if deconstruct_result823 is not None: - assert deconstruct_result823 is not None - unwrapped824 = deconstruct_result823 - self.pretty_ffi(unwrapped824) + _t1447 = None + return _t1447 + _t1448 = _t1446(msg) + deconstruct_result839 = _t1448 + if deconstruct_result839 is not None: + assert deconstruct_result839 is not None + unwrapped840 = deconstruct_result839 + self.pretty_ffi(unwrapped840) else: - def _t1417(_dollar_dollar): + def _t1449(_dollar_dollar): if _dollar_dollar.HasField("atom"): - _t1418 = _dollar_dollar.atom + _t1450 = _dollar_dollar.atom else: - _t1418 = None - return _t1418 - _t1419 = _t1417(msg) - deconstruct_result821 = _t1419 - if deconstruct_result821 is not None: - assert deconstruct_result821 is not None - unwrapped822 = deconstruct_result821 - self.pretty_atom(unwrapped822) + _t1450 = None + return _t1450 + _t1451 = _t1449(msg) + deconstruct_result837 = _t1451 + if deconstruct_result837 is not None: + assert deconstruct_result837 is not None + unwrapped838 = deconstruct_result837 + self.pretty_atom(unwrapped838) else: - def _t1420(_dollar_dollar): + def _t1452(_dollar_dollar): if _dollar_dollar.HasField("pragma"): - _t1421 = _dollar_dollar.pragma + _t1453 = _dollar_dollar.pragma else: - _t1421 = None - return _t1421 - _t1422 = _t1420(msg) - deconstruct_result819 = _t1422 - if deconstruct_result819 is not None: - assert deconstruct_result819 is not None - unwrapped820 = deconstruct_result819 - self.pretty_pragma(unwrapped820) + _t1453 = None + return _t1453 + _t1454 = _t1452(msg) + deconstruct_result835 = _t1454 + if deconstruct_result835 is not None: + assert deconstruct_result835 is not None + unwrapped836 = deconstruct_result835 + self.pretty_pragma(unwrapped836) else: - def _t1423(_dollar_dollar): + def _t1455(_dollar_dollar): if _dollar_dollar.HasField("primitive"): - _t1424 = _dollar_dollar.primitive + _t1456 = _dollar_dollar.primitive else: - _t1424 = None - return _t1424 - _t1425 = _t1423(msg) - deconstruct_result817 = _t1425 - if deconstruct_result817 is not None: - assert deconstruct_result817 is not None - unwrapped818 = deconstruct_result817 - self.pretty_primitive(unwrapped818) + _t1456 = None + return _t1456 + _t1457 = _t1455(msg) + deconstruct_result833 = _t1457 + if deconstruct_result833 is not None: + assert deconstruct_result833 is not None + unwrapped834 = deconstruct_result833 + self.pretty_primitive(unwrapped834) else: - def _t1426(_dollar_dollar): + def _t1458(_dollar_dollar): if _dollar_dollar.HasField("rel_atom"): - _t1427 = _dollar_dollar.rel_atom + _t1459 = _dollar_dollar.rel_atom else: - _t1427 = None - return _t1427 - _t1428 = _t1426(msg) - deconstruct_result815 = _t1428 - if deconstruct_result815 is not None: - assert deconstruct_result815 is not None - unwrapped816 = deconstruct_result815 - self.pretty_rel_atom(unwrapped816) + _t1459 = None + return _t1459 + _t1460 = _t1458(msg) + deconstruct_result831 = _t1460 + if deconstruct_result831 is not None: + assert deconstruct_result831 is not None + unwrapped832 = deconstruct_result831 + self.pretty_rel_atom(unwrapped832) else: - def _t1429(_dollar_dollar): + def _t1461(_dollar_dollar): if _dollar_dollar.HasField("cast"): - _t1430 = _dollar_dollar.cast + _t1462 = _dollar_dollar.cast else: - _t1430 = None - return _t1430 - _t1431 = _t1429(msg) - deconstruct_result813 = _t1431 - if deconstruct_result813 is not None: - assert deconstruct_result813 is not None - unwrapped814 = deconstruct_result813 - self.pretty_cast(unwrapped814) + _t1462 = None + return _t1462 + _t1463 = _t1461(msg) + deconstruct_result829 = _t1463 + if deconstruct_result829 is not None: + assert deconstruct_result829 is not None + unwrapped830 = deconstruct_result829 + self.pretty_cast(unwrapped830) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields840 = msg + fields856 = msg self.write("(") self.write("true") self.write(")") def pretty_false(self, msg: logic_pb2.Disjunction): - fields841 = msg + fields857 = msg self.write("(") self.write("false") self.write(")") def pretty_exists(self, msg: logic_pb2.Exists): - flat846 = self._try_flat(msg, self.pretty_exists) - if flat846 is not None: - assert flat846 is not None - self.write(flat846) + flat862 = self._try_flat(msg, self.pretty_exists) + if flat862 is not None: + assert flat862 is not None + self.write(flat862) return None else: - def _t1432(_dollar_dollar): - _t1433 = self.deconstruct_bindings(_dollar_dollar.body) - return (_t1433, _dollar_dollar.body.value,) - _t1434 = _t1432(msg) - fields842 = _t1434 - assert fields842 is not None - unwrapped_fields843 = fields842 + def _t1464(_dollar_dollar): + _t1465 = self.deconstruct_bindings(_dollar_dollar.body) + return (_t1465, _dollar_dollar.body.value,) + _t1466 = _t1464(msg) + fields858 = _t1466 + assert fields858 is not None + unwrapped_fields859 = fields858 self.write("(") self.write("exists") self.indent_sexp() self.newline() - field844 = unwrapped_fields843[0] - self.pretty_bindings(field844) + field860 = unwrapped_fields859[0] + self.pretty_bindings(field860) self.newline() - field845 = unwrapped_fields843[1] - self.pretty_formula(field845) + field861 = unwrapped_fields859[1] + self.pretty_formula(field861) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat852 = self._try_flat(msg, self.pretty_reduce) - if flat852 is not None: - assert flat852 is not None - self.write(flat852) + flat868 = self._try_flat(msg, self.pretty_reduce) + if flat868 is not None: + assert flat868 is not None + self.write(flat868) return None else: - def _t1435(_dollar_dollar): + def _t1467(_dollar_dollar): return (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - _t1436 = _t1435(msg) - fields847 = _t1436 - assert fields847 is not None - unwrapped_fields848 = fields847 + _t1468 = _t1467(msg) + fields863 = _t1468 + assert fields863 is not None + unwrapped_fields864 = fields863 self.write("(") self.write("reduce") self.indent_sexp() self.newline() - field849 = unwrapped_fields848[0] - self.pretty_abstraction(field849) + field865 = unwrapped_fields864[0] + self.pretty_abstraction(field865) self.newline() - field850 = unwrapped_fields848[1] - self.pretty_abstraction(field850) + field866 = unwrapped_fields864[1] + self.pretty_abstraction(field866) self.newline() - field851 = unwrapped_fields848[2] - self.pretty_terms(field851) + field867 = unwrapped_fields864[2] + self.pretty_terms(field867) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat856 = self._try_flat(msg, self.pretty_terms) - if flat856 is not None: - assert flat856 is not None - self.write(flat856) + flat872 = self._try_flat(msg, self.pretty_terms) + if flat872 is not None: + assert flat872 is not None + self.write(flat872) return None else: - fields853 = msg + fields869 = msg self.write("(") self.write("terms") self.indent_sexp() - if not len(fields853) == 0: + if not len(fields869) == 0: self.newline() - for i855, elem854 in enumerate(fields853): - if (i855 > 0): + for i871, elem870 in enumerate(fields869): + if (i871 > 0): self.newline() - self.pretty_term(elem854) + self.pretty_term(elem870) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat861 = self._try_flat(msg, self.pretty_term) - if flat861 is not None: - assert flat861 is not None - self.write(flat861) + flat877 = self._try_flat(msg, self.pretty_term) + if flat877 is not None: + assert flat877 is not None + self.write(flat877) return None else: - def _t1437(_dollar_dollar): + def _t1469(_dollar_dollar): if _dollar_dollar.HasField("var"): - _t1438 = _dollar_dollar.var + _t1470 = _dollar_dollar.var else: - _t1438 = None - return _t1438 - _t1439 = _t1437(msg) - deconstruct_result859 = _t1439 - if deconstruct_result859 is not None: - assert deconstruct_result859 is not None - unwrapped860 = deconstruct_result859 - self.pretty_var(unwrapped860) + _t1470 = None + return _t1470 + _t1471 = _t1469(msg) + deconstruct_result875 = _t1471 + if deconstruct_result875 is not None: + assert deconstruct_result875 is not None + unwrapped876 = deconstruct_result875 + self.pretty_var(unwrapped876) else: - def _t1440(_dollar_dollar): + def _t1472(_dollar_dollar): if _dollar_dollar.HasField("constant"): - _t1441 = _dollar_dollar.constant + _t1473 = _dollar_dollar.constant else: - _t1441 = None - return _t1441 - _t1442 = _t1440(msg) - deconstruct_result857 = _t1442 - if deconstruct_result857 is not None: - assert deconstruct_result857 is not None - unwrapped858 = deconstruct_result857 - self.pretty_constant(unwrapped858) + _t1473 = None + return _t1473 + _t1474 = _t1472(msg) + deconstruct_result873 = _t1474 + if deconstruct_result873 is not None: + assert deconstruct_result873 is not None + unwrapped874 = deconstruct_result873 + self.pretty_constant(unwrapped874) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat864 = self._try_flat(msg, self.pretty_var) - if flat864 is not None: - assert flat864 is not None - self.write(flat864) + flat880 = self._try_flat(msg, self.pretty_var) + if flat880 is not None: + assert flat880 is not None + self.write(flat880) return None else: - def _t1443(_dollar_dollar): + def _t1475(_dollar_dollar): return _dollar_dollar.name - _t1444 = _t1443(msg) - fields862 = _t1444 - assert fields862 is not None - unwrapped_fields863 = fields862 - self.write(unwrapped_fields863) + _t1476 = _t1475(msg) + fields878 = _t1476 + assert fields878 is not None + unwrapped_fields879 = fields878 + self.write(unwrapped_fields879) def pretty_constant(self, msg: logic_pb2.Value): - flat866 = self._try_flat(msg, self.pretty_constant) - if flat866 is not None: - assert flat866 is not None - self.write(flat866) + flat882 = self._try_flat(msg, self.pretty_constant) + if flat882 is not None: + assert flat882 is not None + self.write(flat882) return None else: - fields865 = msg - self.pretty_value(fields865) + fields881 = msg + self.pretty_value(fields881) def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat871 = self._try_flat(msg, self.pretty_conjunction) - if flat871 is not None: - assert flat871 is not None - self.write(flat871) + flat887 = self._try_flat(msg, self.pretty_conjunction) + if flat887 is not None: + assert flat887 is not None + self.write(flat887) return None else: - def _t1445(_dollar_dollar): + def _t1477(_dollar_dollar): return _dollar_dollar.args - _t1446 = _t1445(msg) - fields867 = _t1446 - assert fields867 is not None - unwrapped_fields868 = fields867 + _t1478 = _t1477(msg) + fields883 = _t1478 + assert fields883 is not None + unwrapped_fields884 = fields883 self.write("(") self.write("and") self.indent_sexp() - if not len(unwrapped_fields868) == 0: + if not len(unwrapped_fields884) == 0: self.newline() - for i870, elem869 in enumerate(unwrapped_fields868): - if (i870 > 0): + for i886, elem885 in enumerate(unwrapped_fields884): + if (i886 > 0): self.newline() - self.pretty_formula(elem869) + self.pretty_formula(elem885) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat876 = self._try_flat(msg, self.pretty_disjunction) - if flat876 is not None: - assert flat876 is not None - self.write(flat876) + flat892 = self._try_flat(msg, self.pretty_disjunction) + if flat892 is not None: + assert flat892 is not None + self.write(flat892) return None else: - def _t1447(_dollar_dollar): + def _t1479(_dollar_dollar): return _dollar_dollar.args - _t1448 = _t1447(msg) - fields872 = _t1448 - assert fields872 is not None - unwrapped_fields873 = fields872 + _t1480 = _t1479(msg) + fields888 = _t1480 + assert fields888 is not None + unwrapped_fields889 = fields888 self.write("(") self.write("or") self.indent_sexp() - if not len(unwrapped_fields873) == 0: + if not len(unwrapped_fields889) == 0: self.newline() - for i875, elem874 in enumerate(unwrapped_fields873): - if (i875 > 0): + for i891, elem890 in enumerate(unwrapped_fields889): + if (i891 > 0): self.newline() - self.pretty_formula(elem874) + self.pretty_formula(elem890) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat879 = self._try_flat(msg, self.pretty_not) - if flat879 is not None: - assert flat879 is not None - self.write(flat879) + flat895 = self._try_flat(msg, self.pretty_not) + if flat895 is not None: + assert flat895 is not None + self.write(flat895) return None else: - def _t1449(_dollar_dollar): + def _t1481(_dollar_dollar): return _dollar_dollar.arg - _t1450 = _t1449(msg) - fields877 = _t1450 - assert fields877 is not None - unwrapped_fields878 = fields877 + _t1482 = _t1481(msg) + fields893 = _t1482 + assert fields893 is not None + unwrapped_fields894 = fields893 self.write("(") self.write("not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields878) + self.pretty_formula(unwrapped_fields894) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat885 = self._try_flat(msg, self.pretty_ffi) - if flat885 is not None: - assert flat885 is not None - self.write(flat885) + flat901 = self._try_flat(msg, self.pretty_ffi) + if flat901 is not None: + assert flat901 is not None + self.write(flat901) return None else: - def _t1451(_dollar_dollar): + def _t1483(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - _t1452 = _t1451(msg) - fields880 = _t1452 - assert fields880 is not None - unwrapped_fields881 = fields880 + _t1484 = _t1483(msg) + fields896 = _t1484 + assert fields896 is not None + unwrapped_fields897 = fields896 self.write("(") self.write("ffi") self.indent_sexp() self.newline() - field882 = unwrapped_fields881[0] - self.pretty_name(field882) + field898 = unwrapped_fields897[0] + self.pretty_name(field898) self.newline() - field883 = unwrapped_fields881[1] - self.pretty_ffi_args(field883) + field899 = unwrapped_fields897[1] + self.pretty_ffi_args(field899) self.newline() - field884 = unwrapped_fields881[2] - self.pretty_terms(field884) + field900 = unwrapped_fields897[2] + self.pretty_terms(field900) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat887 = self._try_flat(msg, self.pretty_name) - if flat887 is not None: - assert flat887 is not None - self.write(flat887) + flat903 = self._try_flat(msg, self.pretty_name) + if flat903 is not None: + assert flat903 is not None + self.write(flat903) return None else: - fields886 = msg + fields902 = msg self.write(":") - self.write(fields886) + self.write(fields902) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat891 = self._try_flat(msg, self.pretty_ffi_args) - if flat891 is not None: - assert flat891 is not None - self.write(flat891) + flat907 = self._try_flat(msg, self.pretty_ffi_args) + if flat907 is not None: + assert flat907 is not None + self.write(flat907) return None else: - fields888 = msg + fields904 = msg self.write("(") self.write("args") self.indent_sexp() - if not len(fields888) == 0: + if not len(fields904) == 0: self.newline() - for i890, elem889 in enumerate(fields888): - if (i890 > 0): + for i906, elem905 in enumerate(fields904): + if (i906 > 0): self.newline() - self.pretty_abstraction(elem889) + self.pretty_abstraction(elem905) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat898 = self._try_flat(msg, self.pretty_atom) - if flat898 is not None: - assert flat898 is not None - self.write(flat898) + flat914 = self._try_flat(msg, self.pretty_atom) + if flat914 is not None: + assert flat914 is not None + self.write(flat914) return None else: - def _t1453(_dollar_dollar): + def _t1485(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1454 = _t1453(msg) - fields892 = _t1454 - assert fields892 is not None - unwrapped_fields893 = fields892 + _t1486 = _t1485(msg) + fields908 = _t1486 + assert fields908 is not None + unwrapped_fields909 = fields908 self.write("(") self.write("atom") self.indent_sexp() self.newline() - field894 = unwrapped_fields893[0] - self.pretty_relation_id(field894) - field895 = unwrapped_fields893[1] - if not len(field895) == 0: + field910 = unwrapped_fields909[0] + self.pretty_relation_id(field910) + field911 = unwrapped_fields909[1] + if not len(field911) == 0: self.newline() - for i897, elem896 in enumerate(field895): - if (i897 > 0): + for i913, elem912 in enumerate(field911): + if (i913 > 0): self.newline() - self.pretty_term(elem896) + self.pretty_term(elem912) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat905 = self._try_flat(msg, self.pretty_pragma) - if flat905 is not None: - assert flat905 is not None - self.write(flat905) + flat921 = self._try_flat(msg, self.pretty_pragma) + if flat921 is not None: + assert flat921 is not None + self.write(flat921) return None else: - def _t1455(_dollar_dollar): + def _t1487(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1456 = _t1455(msg) - fields899 = _t1456 - assert fields899 is not None - unwrapped_fields900 = fields899 + _t1488 = _t1487(msg) + fields915 = _t1488 + assert fields915 is not None + unwrapped_fields916 = fields915 self.write("(") self.write("pragma") self.indent_sexp() self.newline() - field901 = unwrapped_fields900[0] - self.pretty_name(field901) - field902 = unwrapped_fields900[1] - if not len(field902) == 0: + field917 = unwrapped_fields916[0] + self.pretty_name(field917) + field918 = unwrapped_fields916[1] + if not len(field918) == 0: self.newline() - for i904, elem903 in enumerate(field902): - if (i904 > 0): + for i920, elem919 in enumerate(field918): + if (i920 > 0): self.newline() - self.pretty_term(elem903) + self.pretty_term(elem919) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat921 = self._try_flat(msg, self.pretty_primitive) - if flat921 is not None: - assert flat921 is not None - self.write(flat921) + flat937 = self._try_flat(msg, self.pretty_primitive) + if flat937 is not None: + assert flat937 is not None + self.write(flat937) return None else: - def _t1457(_dollar_dollar): + def _t1489(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_eq": - _t1458 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1490 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1458 = None - return _t1458 - _t1459 = _t1457(msg) - guard_result920 = _t1459 - if guard_result920 is not None: + _t1490 = None + return _t1490 + _t1491 = _t1489(msg) + guard_result936 = _t1491 + if guard_result936 is not None: self.pretty_eq(msg) else: - def _t1460(_dollar_dollar): + def _t1492(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1461 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1493 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1461 = None - return _t1461 - _t1462 = _t1460(msg) - guard_result919 = _t1462 - if guard_result919 is not None: + _t1493 = None + return _t1493 + _t1494 = _t1492(msg) + guard_result935 = _t1494 + if guard_result935 is not None: self.pretty_lt(msg) else: - def _t1463(_dollar_dollar): + def _t1495(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1464 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1496 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1464 = None - return _t1464 - _t1465 = _t1463(msg) - guard_result918 = _t1465 - if guard_result918 is not None: + _t1496 = None + return _t1496 + _t1497 = _t1495(msg) + guard_result934 = _t1497 + if guard_result934 is not None: self.pretty_lt_eq(msg) else: - def _t1466(_dollar_dollar): + def _t1498(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1467 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1499 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1467 = None - return _t1467 - _t1468 = _t1466(msg) - guard_result917 = _t1468 - if guard_result917 is not None: + _t1499 = None + return _t1499 + _t1500 = _t1498(msg) + guard_result933 = _t1500 + if guard_result933 is not None: self.pretty_gt(msg) else: - def _t1469(_dollar_dollar): + def _t1501(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1470 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1502 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1470 = None - return _t1470 - _t1471 = _t1469(msg) - guard_result916 = _t1471 - if guard_result916 is not None: + _t1502 = None + return _t1502 + _t1503 = _t1501(msg) + guard_result932 = _t1503 + if guard_result932 is not None: self.pretty_gt_eq(msg) else: - def _t1472(_dollar_dollar): + def _t1504(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1473 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1505 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1473 = None - return _t1473 - _t1474 = _t1472(msg) - guard_result915 = _t1474 - if guard_result915 is not None: + _t1505 = None + return _t1505 + _t1506 = _t1504(msg) + guard_result931 = _t1506 + if guard_result931 is not None: self.pretty_add(msg) else: - def _t1475(_dollar_dollar): + def _t1507(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1476 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1508 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1476 = None - return _t1476 - _t1477 = _t1475(msg) - guard_result914 = _t1477 - if guard_result914 is not None: + _t1508 = None + return _t1508 + _t1509 = _t1507(msg) + guard_result930 = _t1509 + if guard_result930 is not None: self.pretty_minus(msg) else: - def _t1478(_dollar_dollar): + def _t1510(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1479 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1511 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1479 = None - return _t1479 - _t1480 = _t1478(msg) - guard_result913 = _t1480 - if guard_result913 is not None: + _t1511 = None + return _t1511 + _t1512 = _t1510(msg) + guard_result929 = _t1512 + if guard_result929 is not None: self.pretty_multiply(msg) else: - def _t1481(_dollar_dollar): + def _t1513(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1482 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1514 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1482 = None - return _t1482 - _t1483 = _t1481(msg) - guard_result912 = _t1483 - if guard_result912 is not None: + _t1514 = None + return _t1514 + _t1515 = _t1513(msg) + guard_result928 = _t1515 + if guard_result928 is not None: self.pretty_divide(msg) else: - def _t1484(_dollar_dollar): + def _t1516(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1485 = _t1484(msg) - fields906 = _t1485 - assert fields906 is not None - unwrapped_fields907 = fields906 + _t1517 = _t1516(msg) + fields922 = _t1517 + assert fields922 is not None + unwrapped_fields923 = fields922 self.write("(") self.write("primitive") self.indent_sexp() self.newline() - field908 = unwrapped_fields907[0] - self.pretty_name(field908) - field909 = unwrapped_fields907[1] - if not len(field909) == 0: + field924 = unwrapped_fields923[0] + self.pretty_name(field924) + field925 = unwrapped_fields923[1] + if not len(field925) == 0: self.newline() - for i911, elem910 in enumerate(field909): - if (i911 > 0): + for i927, elem926 in enumerate(field925): + if (i927 > 0): self.newline() - self.pretty_rel_term(elem910) + self.pretty_rel_term(elem926) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat926 = self._try_flat(msg, self.pretty_eq) - if flat926 is not None: - assert flat926 is not None - self.write(flat926) + flat942 = self._try_flat(msg, self.pretty_eq) + if flat942 is not None: + assert flat942 is not None + self.write(flat942) return None else: - def _t1486(_dollar_dollar): + def _t1518(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_eq": - _t1487 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1519 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1487 = None - return _t1487 - _t1488 = _t1486(msg) - fields922 = _t1488 - assert fields922 is not None - unwrapped_fields923 = fields922 + _t1519 = None + return _t1519 + _t1520 = _t1518(msg) + fields938 = _t1520 + assert fields938 is not None + unwrapped_fields939 = fields938 self.write("(") self.write("=") self.indent_sexp() self.newline() - field924 = unwrapped_fields923[0] - self.pretty_term(field924) + field940 = unwrapped_fields939[0] + self.pretty_term(field940) self.newline() - field925 = unwrapped_fields923[1] - self.pretty_term(field925) + field941 = unwrapped_fields939[1] + self.pretty_term(field941) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat931 = self._try_flat(msg, self.pretty_lt) - if flat931 is not None: - assert flat931 is not None - self.write(flat931) + flat947 = self._try_flat(msg, self.pretty_lt) + if flat947 is not None: + assert flat947 is not None + self.write(flat947) return None else: - def _t1489(_dollar_dollar): + def _t1521(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1490 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1522 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1490 = None - return _t1490 - _t1491 = _t1489(msg) - fields927 = _t1491 - assert fields927 is not None - unwrapped_fields928 = fields927 + _t1522 = None + return _t1522 + _t1523 = _t1521(msg) + fields943 = _t1523 + assert fields943 is not None + unwrapped_fields944 = fields943 self.write("(") self.write("<") self.indent_sexp() self.newline() - field929 = unwrapped_fields928[0] - self.pretty_term(field929) + field945 = unwrapped_fields944[0] + self.pretty_term(field945) self.newline() - field930 = unwrapped_fields928[1] - self.pretty_term(field930) + field946 = unwrapped_fields944[1] + self.pretty_term(field946) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat936 = self._try_flat(msg, self.pretty_lt_eq) - if flat936 is not None: - assert flat936 is not None - self.write(flat936) + flat952 = self._try_flat(msg, self.pretty_lt_eq) + if flat952 is not None: + assert flat952 is not None + self.write(flat952) return None else: - def _t1492(_dollar_dollar): + def _t1524(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1493 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1525 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1493 = None - return _t1493 - _t1494 = _t1492(msg) - fields932 = _t1494 - assert fields932 is not None - unwrapped_fields933 = fields932 + _t1525 = None + return _t1525 + _t1526 = _t1524(msg) + fields948 = _t1526 + assert fields948 is not None + unwrapped_fields949 = fields948 self.write("(") self.write("<=") self.indent_sexp() self.newline() - field934 = unwrapped_fields933[0] - self.pretty_term(field934) + field950 = unwrapped_fields949[0] + self.pretty_term(field950) self.newline() - field935 = unwrapped_fields933[1] - self.pretty_term(field935) + field951 = unwrapped_fields949[1] + self.pretty_term(field951) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat941 = self._try_flat(msg, self.pretty_gt) - if flat941 is not None: - assert flat941 is not None - self.write(flat941) + flat957 = self._try_flat(msg, self.pretty_gt) + if flat957 is not None: + assert flat957 is not None + self.write(flat957) return None else: - def _t1495(_dollar_dollar): + def _t1527(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1496 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1528 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1496 = None - return _t1496 - _t1497 = _t1495(msg) - fields937 = _t1497 - assert fields937 is not None - unwrapped_fields938 = fields937 + _t1528 = None + return _t1528 + _t1529 = _t1527(msg) + fields953 = _t1529 + assert fields953 is not None + unwrapped_fields954 = fields953 self.write("(") self.write(">") self.indent_sexp() self.newline() - field939 = unwrapped_fields938[0] - self.pretty_term(field939) + field955 = unwrapped_fields954[0] + self.pretty_term(field955) self.newline() - field940 = unwrapped_fields938[1] - self.pretty_term(field940) + field956 = unwrapped_fields954[1] + self.pretty_term(field956) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat946 = self._try_flat(msg, self.pretty_gt_eq) - if flat946 is not None: - assert flat946 is not None - self.write(flat946) + flat962 = self._try_flat(msg, self.pretty_gt_eq) + if flat962 is not None: + assert flat962 is not None + self.write(flat962) return None else: - def _t1498(_dollar_dollar): + def _t1530(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1499 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1531 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1499 = None - return _t1499 - _t1500 = _t1498(msg) - fields942 = _t1500 - assert fields942 is not None - unwrapped_fields943 = fields942 + _t1531 = None + return _t1531 + _t1532 = _t1530(msg) + fields958 = _t1532 + assert fields958 is not None + unwrapped_fields959 = fields958 self.write("(") self.write(">=") self.indent_sexp() self.newline() - field944 = unwrapped_fields943[0] - self.pretty_term(field944) + field960 = unwrapped_fields959[0] + self.pretty_term(field960) self.newline() - field945 = unwrapped_fields943[1] - self.pretty_term(field945) + field961 = unwrapped_fields959[1] + self.pretty_term(field961) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat952 = self._try_flat(msg, self.pretty_add) - if flat952 is not None: - assert flat952 is not None - self.write(flat952) + flat968 = self._try_flat(msg, self.pretty_add) + if flat968 is not None: + assert flat968 is not None + self.write(flat968) return None else: - def _t1501(_dollar_dollar): + def _t1533(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1502 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1534 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1502 = None - return _t1502 - _t1503 = _t1501(msg) - fields947 = _t1503 - assert fields947 is not None - unwrapped_fields948 = fields947 + _t1534 = None + return _t1534 + _t1535 = _t1533(msg) + fields963 = _t1535 + assert fields963 is not None + unwrapped_fields964 = fields963 self.write("(") self.write("+") self.indent_sexp() self.newline() - field949 = unwrapped_fields948[0] - self.pretty_term(field949) + field965 = unwrapped_fields964[0] + self.pretty_term(field965) self.newline() - field950 = unwrapped_fields948[1] - self.pretty_term(field950) + field966 = unwrapped_fields964[1] + self.pretty_term(field966) self.newline() - field951 = unwrapped_fields948[2] - self.pretty_term(field951) + field967 = unwrapped_fields964[2] + self.pretty_term(field967) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat958 = self._try_flat(msg, self.pretty_minus) - if flat958 is not None: - assert flat958 is not None - self.write(flat958) + flat974 = self._try_flat(msg, self.pretty_minus) + if flat974 is not None: + assert flat974 is not None + self.write(flat974) return None else: - def _t1504(_dollar_dollar): + def _t1536(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1505 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1537 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1505 = None - return _t1505 - _t1506 = _t1504(msg) - fields953 = _t1506 - assert fields953 is not None - unwrapped_fields954 = fields953 + _t1537 = None + return _t1537 + _t1538 = _t1536(msg) + fields969 = _t1538 + assert fields969 is not None + unwrapped_fields970 = fields969 self.write("(") self.write("-") self.indent_sexp() self.newline() - field955 = unwrapped_fields954[0] - self.pretty_term(field955) + field971 = unwrapped_fields970[0] + self.pretty_term(field971) self.newline() - field956 = unwrapped_fields954[1] - self.pretty_term(field956) + field972 = unwrapped_fields970[1] + self.pretty_term(field972) self.newline() - field957 = unwrapped_fields954[2] - self.pretty_term(field957) + field973 = unwrapped_fields970[2] + self.pretty_term(field973) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat964 = self._try_flat(msg, self.pretty_multiply) - if flat964 is not None: - assert flat964 is not None - self.write(flat964) + flat980 = self._try_flat(msg, self.pretty_multiply) + if flat980 is not None: + assert flat980 is not None + self.write(flat980) return None else: - def _t1507(_dollar_dollar): + def _t1539(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1508 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1540 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1508 = None - return _t1508 - _t1509 = _t1507(msg) - fields959 = _t1509 - assert fields959 is not None - unwrapped_fields960 = fields959 + _t1540 = None + return _t1540 + _t1541 = _t1539(msg) + fields975 = _t1541 + assert fields975 is not None + unwrapped_fields976 = fields975 self.write("(") self.write("*") self.indent_sexp() self.newline() - field961 = unwrapped_fields960[0] - self.pretty_term(field961) + field977 = unwrapped_fields976[0] + self.pretty_term(field977) self.newline() - field962 = unwrapped_fields960[1] - self.pretty_term(field962) + field978 = unwrapped_fields976[1] + self.pretty_term(field978) self.newline() - field963 = unwrapped_fields960[2] - self.pretty_term(field963) + field979 = unwrapped_fields976[2] + self.pretty_term(field979) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat970 = self._try_flat(msg, self.pretty_divide) - if flat970 is not None: - assert flat970 is not None - self.write(flat970) + flat986 = self._try_flat(msg, self.pretty_divide) + if flat986 is not None: + assert flat986 is not None + self.write(flat986) return None else: - def _t1510(_dollar_dollar): + def _t1542(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1511 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1543 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1511 = None - return _t1511 - _t1512 = _t1510(msg) - fields965 = _t1512 - assert fields965 is not None - unwrapped_fields966 = fields965 + _t1543 = None + return _t1543 + _t1544 = _t1542(msg) + fields981 = _t1544 + assert fields981 is not None + unwrapped_fields982 = fields981 self.write("(") self.write("/") self.indent_sexp() self.newline() - field967 = unwrapped_fields966[0] - self.pretty_term(field967) + field983 = unwrapped_fields982[0] + self.pretty_term(field983) self.newline() - field968 = unwrapped_fields966[1] - self.pretty_term(field968) + field984 = unwrapped_fields982[1] + self.pretty_term(field984) self.newline() - field969 = unwrapped_fields966[2] - self.pretty_term(field969) + field985 = unwrapped_fields982[2] + self.pretty_term(field985) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat975 = self._try_flat(msg, self.pretty_rel_term) - if flat975 is not None: - assert flat975 is not None - self.write(flat975) + flat991 = self._try_flat(msg, self.pretty_rel_term) + if flat991 is not None: + assert flat991 is not None + self.write(flat991) return None else: - def _t1513(_dollar_dollar): + def _t1545(_dollar_dollar): if _dollar_dollar.HasField("specialized_value"): - _t1514 = _dollar_dollar.specialized_value + _t1546 = _dollar_dollar.specialized_value else: - _t1514 = None - return _t1514 - _t1515 = _t1513(msg) - deconstruct_result973 = _t1515 - if deconstruct_result973 is not None: - assert deconstruct_result973 is not None - unwrapped974 = deconstruct_result973 - self.pretty_specialized_value(unwrapped974) + _t1546 = None + return _t1546 + _t1547 = _t1545(msg) + deconstruct_result989 = _t1547 + if deconstruct_result989 is not None: + assert deconstruct_result989 is not None + unwrapped990 = deconstruct_result989 + self.pretty_specialized_value(unwrapped990) else: - def _t1516(_dollar_dollar): + def _t1548(_dollar_dollar): if _dollar_dollar.HasField("term"): - _t1517 = _dollar_dollar.term + _t1549 = _dollar_dollar.term else: - _t1517 = None - return _t1517 - _t1518 = _t1516(msg) - deconstruct_result971 = _t1518 - if deconstruct_result971 is not None: - assert deconstruct_result971 is not None - unwrapped972 = deconstruct_result971 - self.pretty_term(unwrapped972) + _t1549 = None + return _t1549 + _t1550 = _t1548(msg) + deconstruct_result987 = _t1550 + if deconstruct_result987 is not None: + assert deconstruct_result987 is not None + unwrapped988 = deconstruct_result987 + self.pretty_term(unwrapped988) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat977 = self._try_flat(msg, self.pretty_specialized_value) - if flat977 is not None: - assert flat977 is not None - self.write(flat977) + flat993 = self._try_flat(msg, self.pretty_specialized_value) + if flat993 is not None: + assert flat993 is not None + self.write(flat993) return None else: - fields976 = msg + fields992 = msg self.write("#") - self.pretty_value(fields976) + self.pretty_value(fields992) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat984 = self._try_flat(msg, self.pretty_rel_atom) - if flat984 is not None: - assert flat984 is not None - self.write(flat984) + flat1000 = self._try_flat(msg, self.pretty_rel_atom) + if flat1000 is not None: + assert flat1000 is not None + self.write(flat1000) return None else: - def _t1519(_dollar_dollar): + def _t1551(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1520 = _t1519(msg) - fields978 = _t1520 - assert fields978 is not None - unwrapped_fields979 = fields978 + _t1552 = _t1551(msg) + fields994 = _t1552 + assert fields994 is not None + unwrapped_fields995 = fields994 self.write("(") self.write("relatom") self.indent_sexp() self.newline() - field980 = unwrapped_fields979[0] - self.pretty_name(field980) - field981 = unwrapped_fields979[1] - if not len(field981) == 0: + field996 = unwrapped_fields995[0] + self.pretty_name(field996) + field997 = unwrapped_fields995[1] + if not len(field997) == 0: self.newline() - for i983, elem982 in enumerate(field981): - if (i983 > 0): + for i999, elem998 in enumerate(field997): + if (i999 > 0): self.newline() - self.pretty_rel_term(elem982) + self.pretty_rel_term(elem998) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat989 = self._try_flat(msg, self.pretty_cast) - if flat989 is not None: - assert flat989 is not None - self.write(flat989) + flat1005 = self._try_flat(msg, self.pretty_cast) + if flat1005 is not None: + assert flat1005 is not None + self.write(flat1005) return None else: - def _t1521(_dollar_dollar): + def _t1553(_dollar_dollar): return (_dollar_dollar.input, _dollar_dollar.result,) - _t1522 = _t1521(msg) - fields985 = _t1522 - assert fields985 is not None - unwrapped_fields986 = fields985 + _t1554 = _t1553(msg) + fields1001 = _t1554 + assert fields1001 is not None + unwrapped_fields1002 = fields1001 self.write("(") self.write("cast") self.indent_sexp() self.newline() - field987 = unwrapped_fields986[0] - self.pretty_term(field987) + field1003 = unwrapped_fields1002[0] + self.pretty_term(field1003) self.newline() - field988 = unwrapped_fields986[1] - self.pretty_term(field988) + field1004 = unwrapped_fields1002[1] + self.pretty_term(field1004) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat993 = self._try_flat(msg, self.pretty_attrs) - if flat993 is not None: - assert flat993 is not None - self.write(flat993) + flat1009 = self._try_flat(msg, self.pretty_attrs) + if flat1009 is not None: + assert flat1009 is not None + self.write(flat1009) return None else: - fields990 = msg + fields1006 = msg self.write("(") self.write("attrs") self.indent_sexp() - if not len(fields990) == 0: + if not len(fields1006) == 0: self.newline() - for i992, elem991 in enumerate(fields990): - if (i992 > 0): + for i1008, elem1007 in enumerate(fields1006): + if (i1008 > 0): self.newline() - self.pretty_attribute(elem991) + self.pretty_attribute(elem1007) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1000 = self._try_flat(msg, self.pretty_attribute) - if flat1000 is not None: - assert flat1000 is not None - self.write(flat1000) + flat1016 = self._try_flat(msg, self.pretty_attribute) + if flat1016 is not None: + assert flat1016 is not None + self.write(flat1016) return None else: - def _t1523(_dollar_dollar): + def _t1555(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.args,) - _t1524 = _t1523(msg) - fields994 = _t1524 - assert fields994 is not None - unwrapped_fields995 = fields994 + _t1556 = _t1555(msg) + fields1010 = _t1556 + assert fields1010 is not None + unwrapped_fields1011 = fields1010 self.write("(") self.write("attribute") self.indent_sexp() self.newline() - field996 = unwrapped_fields995[0] - self.pretty_name(field996) - field997 = unwrapped_fields995[1] - if not len(field997) == 0: + field1012 = unwrapped_fields1011[0] + self.pretty_name(field1012) + field1013 = unwrapped_fields1011[1] + if not len(field1013) == 0: self.newline() - for i999, elem998 in enumerate(field997): - if (i999 > 0): + for i1015, elem1014 in enumerate(field1013): + if (i1015 > 0): self.newline() - self.pretty_value(elem998) + self.pretty_value(elem1014) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1007 = self._try_flat(msg, self.pretty_algorithm) - if flat1007 is not None: - assert flat1007 is not None - self.write(flat1007) + flat1023 = self._try_flat(msg, self.pretty_algorithm) + if flat1023 is not None: + assert flat1023 is not None + self.write(flat1023) return None else: - def _t1525(_dollar_dollar): + def _t1557(_dollar_dollar): return (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,) - _t1526 = _t1525(msg) - fields1001 = _t1526 - assert fields1001 is not None - unwrapped_fields1002 = fields1001 + _t1558 = _t1557(msg) + fields1017 = _t1558 + assert fields1017 is not None + unwrapped_fields1018 = fields1017 self.write("(") self.write("algorithm") self.indent_sexp() - field1003 = unwrapped_fields1002[0] - if not len(field1003) == 0: + field1019 = unwrapped_fields1018[0] + if not len(field1019) == 0: self.newline() - for i1005, elem1004 in enumerate(field1003): - if (i1005 > 0): + for i1021, elem1020 in enumerate(field1019): + if (i1021 > 0): self.newline() - self.pretty_relation_id(elem1004) + self.pretty_relation_id(elem1020) self.newline() - field1006 = unwrapped_fields1002[1] - self.pretty_script(field1006) + field1022 = unwrapped_fields1018[1] + self.pretty_script(field1022) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1012 = self._try_flat(msg, self.pretty_script) - if flat1012 is not None: - assert flat1012 is not None - self.write(flat1012) + flat1028 = self._try_flat(msg, self.pretty_script) + if flat1028 is not None: + assert flat1028 is not None + self.write(flat1028) return None else: - def _t1527(_dollar_dollar): + def _t1559(_dollar_dollar): return _dollar_dollar.constructs - _t1528 = _t1527(msg) - fields1008 = _t1528 - assert fields1008 is not None - unwrapped_fields1009 = fields1008 + _t1560 = _t1559(msg) + fields1024 = _t1560 + assert fields1024 is not None + unwrapped_fields1025 = fields1024 self.write("(") self.write("script") self.indent_sexp() - if not len(unwrapped_fields1009) == 0: + if not len(unwrapped_fields1025) == 0: self.newline() - for i1011, elem1010 in enumerate(unwrapped_fields1009): - if (i1011 > 0): + for i1027, elem1026 in enumerate(unwrapped_fields1025): + if (i1027 > 0): self.newline() - self.pretty_construct(elem1010) + self.pretty_construct(elem1026) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1017 = self._try_flat(msg, self.pretty_construct) - if flat1017 is not None: - assert flat1017 is not None - self.write(flat1017) + flat1033 = self._try_flat(msg, self.pretty_construct) + if flat1033 is not None: + assert flat1033 is not None + self.write(flat1033) return None else: - def _t1529(_dollar_dollar): + def _t1561(_dollar_dollar): if _dollar_dollar.HasField("loop"): - _t1530 = _dollar_dollar.loop + _t1562 = _dollar_dollar.loop else: - _t1530 = None - return _t1530 - _t1531 = _t1529(msg) - deconstruct_result1015 = _t1531 - if deconstruct_result1015 is not None: - assert deconstruct_result1015 is not None - unwrapped1016 = deconstruct_result1015 - self.pretty_loop(unwrapped1016) + _t1562 = None + return _t1562 + _t1563 = _t1561(msg) + deconstruct_result1031 = _t1563 + if deconstruct_result1031 is not None: + assert deconstruct_result1031 is not None + unwrapped1032 = deconstruct_result1031 + self.pretty_loop(unwrapped1032) else: - def _t1532(_dollar_dollar): + def _t1564(_dollar_dollar): if _dollar_dollar.HasField("instruction"): - _t1533 = _dollar_dollar.instruction + _t1565 = _dollar_dollar.instruction else: - _t1533 = None - return _t1533 - _t1534 = _t1532(msg) - deconstruct_result1013 = _t1534 - if deconstruct_result1013 is not None: - assert deconstruct_result1013 is not None - unwrapped1014 = deconstruct_result1013 - self.pretty_instruction(unwrapped1014) + _t1565 = None + return _t1565 + _t1566 = _t1564(msg) + deconstruct_result1029 = _t1566 + if deconstruct_result1029 is not None: + assert deconstruct_result1029 is not None + unwrapped1030 = deconstruct_result1029 + self.pretty_instruction(unwrapped1030) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1022 = self._try_flat(msg, self.pretty_loop) - if flat1022 is not None: - assert flat1022 is not None - self.write(flat1022) + flat1038 = self._try_flat(msg, self.pretty_loop) + if flat1038 is not None: + assert flat1038 is not None + self.write(flat1038) return None else: - def _t1535(_dollar_dollar): + def _t1567(_dollar_dollar): return (_dollar_dollar.init, _dollar_dollar.body,) - _t1536 = _t1535(msg) - fields1018 = _t1536 - assert fields1018 is not None - unwrapped_fields1019 = fields1018 + _t1568 = _t1567(msg) + fields1034 = _t1568 + assert fields1034 is not None + unwrapped_fields1035 = fields1034 self.write("(") self.write("loop") self.indent_sexp() self.newline() - field1020 = unwrapped_fields1019[0] - self.pretty_init(field1020) + field1036 = unwrapped_fields1035[0] + self.pretty_init(field1036) self.newline() - field1021 = unwrapped_fields1019[1] - self.pretty_script(field1021) + field1037 = unwrapped_fields1035[1] + self.pretty_script(field1037) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1026 = self._try_flat(msg, self.pretty_init) - if flat1026 is not None: - assert flat1026 is not None - self.write(flat1026) + flat1042 = self._try_flat(msg, self.pretty_init) + if flat1042 is not None: + assert flat1042 is not None + self.write(flat1042) return None else: - fields1023 = msg + fields1039 = msg self.write("(") self.write("init") self.indent_sexp() - if not len(fields1023) == 0: + if not len(fields1039) == 0: self.newline() - for i1025, elem1024 in enumerate(fields1023): - if (i1025 > 0): + for i1041, elem1040 in enumerate(fields1039): + if (i1041 > 0): self.newline() - self.pretty_instruction(elem1024) + self.pretty_instruction(elem1040) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1037 = self._try_flat(msg, self.pretty_instruction) - if flat1037 is not None: - assert flat1037 is not None - self.write(flat1037) + flat1053 = self._try_flat(msg, self.pretty_instruction) + if flat1053 is not None: + assert flat1053 is not None + self.write(flat1053) return None else: - def _t1537(_dollar_dollar): + def _t1569(_dollar_dollar): if _dollar_dollar.HasField("assign"): - _t1538 = _dollar_dollar.assign + _t1570 = _dollar_dollar.assign else: - _t1538 = None - return _t1538 - _t1539 = _t1537(msg) - deconstruct_result1035 = _t1539 - if deconstruct_result1035 is not None: - assert deconstruct_result1035 is not None - unwrapped1036 = deconstruct_result1035 - self.pretty_assign(unwrapped1036) + _t1570 = None + return _t1570 + _t1571 = _t1569(msg) + deconstruct_result1051 = _t1571 + if deconstruct_result1051 is not None: + assert deconstruct_result1051 is not None + unwrapped1052 = deconstruct_result1051 + self.pretty_assign(unwrapped1052) else: - def _t1540(_dollar_dollar): + def _t1572(_dollar_dollar): if _dollar_dollar.HasField("upsert"): - _t1541 = _dollar_dollar.upsert + _t1573 = _dollar_dollar.upsert else: - _t1541 = None - return _t1541 - _t1542 = _t1540(msg) - deconstruct_result1033 = _t1542 - if deconstruct_result1033 is not None: - assert deconstruct_result1033 is not None - unwrapped1034 = deconstruct_result1033 - self.pretty_upsert(unwrapped1034) + _t1573 = None + return _t1573 + _t1574 = _t1572(msg) + deconstruct_result1049 = _t1574 + if deconstruct_result1049 is not None: + assert deconstruct_result1049 is not None + unwrapped1050 = deconstruct_result1049 + self.pretty_upsert(unwrapped1050) else: - def _t1543(_dollar_dollar): + def _t1575(_dollar_dollar): if _dollar_dollar.HasField("break"): - _t1544 = getattr(_dollar_dollar, 'break') + _t1576 = getattr(_dollar_dollar, 'break') else: - _t1544 = None - return _t1544 - _t1545 = _t1543(msg) - deconstruct_result1031 = _t1545 - if deconstruct_result1031 is not None: - assert deconstruct_result1031 is not None - unwrapped1032 = deconstruct_result1031 - self.pretty_break(unwrapped1032) + _t1576 = None + return _t1576 + _t1577 = _t1575(msg) + deconstruct_result1047 = _t1577 + if deconstruct_result1047 is not None: + assert deconstruct_result1047 is not None + unwrapped1048 = deconstruct_result1047 + self.pretty_break(unwrapped1048) else: - def _t1546(_dollar_dollar): + def _t1578(_dollar_dollar): if _dollar_dollar.HasField("monoid_def"): - _t1547 = _dollar_dollar.monoid_def + _t1579 = _dollar_dollar.monoid_def else: - _t1547 = None - return _t1547 - _t1548 = _t1546(msg) - deconstruct_result1029 = _t1548 - if deconstruct_result1029 is not None: - assert deconstruct_result1029 is not None - unwrapped1030 = deconstruct_result1029 - self.pretty_monoid_def(unwrapped1030) + _t1579 = None + return _t1579 + _t1580 = _t1578(msg) + deconstruct_result1045 = _t1580 + if deconstruct_result1045 is not None: + assert deconstruct_result1045 is not None + unwrapped1046 = deconstruct_result1045 + self.pretty_monoid_def(unwrapped1046) else: - def _t1549(_dollar_dollar): + def _t1581(_dollar_dollar): if _dollar_dollar.HasField("monus_def"): - _t1550 = _dollar_dollar.monus_def + _t1582 = _dollar_dollar.monus_def else: - _t1550 = None - return _t1550 - _t1551 = _t1549(msg) - deconstruct_result1027 = _t1551 - if deconstruct_result1027 is not None: - assert deconstruct_result1027 is not None - unwrapped1028 = deconstruct_result1027 - self.pretty_monus_def(unwrapped1028) + _t1582 = None + return _t1582 + _t1583 = _t1581(msg) + deconstruct_result1043 = _t1583 + if deconstruct_result1043 is not None: + assert deconstruct_result1043 is not None + unwrapped1044 = deconstruct_result1043 + self.pretty_monus_def(unwrapped1044) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1044 = self._try_flat(msg, self.pretty_assign) - if flat1044 is not None: - assert flat1044 is not None - self.write(flat1044) + flat1060 = self._try_flat(msg, self.pretty_assign) + if flat1060 is not None: + assert flat1060 is not None + self.write(flat1060) return None else: - def _t1552(_dollar_dollar): + def _t1584(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1553 = _dollar_dollar.attrs + _t1585 = _dollar_dollar.attrs else: - _t1553 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1553,) - _t1554 = _t1552(msg) - fields1038 = _t1554 - assert fields1038 is not None - unwrapped_fields1039 = fields1038 + _t1585 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1585,) + _t1586 = _t1584(msg) + fields1054 = _t1586 + assert fields1054 is not None + unwrapped_fields1055 = fields1054 self.write("(") self.write("assign") self.indent_sexp() self.newline() - field1040 = unwrapped_fields1039[0] - self.pretty_relation_id(field1040) + field1056 = unwrapped_fields1055[0] + self.pretty_relation_id(field1056) self.newline() - field1041 = unwrapped_fields1039[1] - self.pretty_abstraction(field1041) - field1042 = unwrapped_fields1039[2] - if field1042 is not None: + field1057 = unwrapped_fields1055[1] + self.pretty_abstraction(field1057) + field1058 = unwrapped_fields1055[2] + if field1058 is not None: self.newline() - assert field1042 is not None - opt_val1043 = field1042 - self.pretty_attrs(opt_val1043) + assert field1058 is not None + opt_val1059 = field1058 + self.pretty_attrs(opt_val1059) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1051 = self._try_flat(msg, self.pretty_upsert) - if flat1051 is not None: - assert flat1051 is not None - self.write(flat1051) + flat1067 = self._try_flat(msg, self.pretty_upsert) + if flat1067 is not None: + assert flat1067 is not None + self.write(flat1067) return None else: - def _t1555(_dollar_dollar): + def _t1587(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1556 = _dollar_dollar.attrs + _t1588 = _dollar_dollar.attrs else: - _t1556 = None - return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1556,) - _t1557 = _t1555(msg) - fields1045 = _t1557 - assert fields1045 is not None - unwrapped_fields1046 = fields1045 + _t1588 = None + return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1588,) + _t1589 = _t1587(msg) + fields1061 = _t1589 + assert fields1061 is not None + unwrapped_fields1062 = fields1061 self.write("(") self.write("upsert") self.indent_sexp() self.newline() - field1047 = unwrapped_fields1046[0] - self.pretty_relation_id(field1047) + field1063 = unwrapped_fields1062[0] + self.pretty_relation_id(field1063) self.newline() - field1048 = unwrapped_fields1046[1] - self.pretty_abstraction_with_arity(field1048) - field1049 = unwrapped_fields1046[2] - if field1049 is not None: + field1064 = unwrapped_fields1062[1] + self.pretty_abstraction_with_arity(field1064) + field1065 = unwrapped_fields1062[2] + if field1065 is not None: self.newline() - assert field1049 is not None - opt_val1050 = field1049 - self.pretty_attrs(opt_val1050) + assert field1065 is not None + opt_val1066 = field1065 + self.pretty_attrs(opt_val1066) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1056 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1056 is not None: - assert flat1056 is not None - self.write(flat1056) + flat1072 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1072 is not None: + assert flat1072 is not None + self.write(flat1072) return None else: - def _t1558(_dollar_dollar): - _t1559 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - return (_t1559, _dollar_dollar[0].value,) - _t1560 = _t1558(msg) - fields1052 = _t1560 - assert fields1052 is not None - unwrapped_fields1053 = fields1052 + def _t1590(_dollar_dollar): + _t1591 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + return (_t1591, _dollar_dollar[0].value,) + _t1592 = _t1590(msg) + fields1068 = _t1592 + assert fields1068 is not None + unwrapped_fields1069 = fields1068 self.write("(") self.indent() - field1054 = unwrapped_fields1053[0] - self.pretty_bindings(field1054) + field1070 = unwrapped_fields1069[0] + self.pretty_bindings(field1070) self.newline() - field1055 = unwrapped_fields1053[1] - self.pretty_formula(field1055) + field1071 = unwrapped_fields1069[1] + self.pretty_formula(field1071) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1063 = self._try_flat(msg, self.pretty_break) - if flat1063 is not None: - assert flat1063 is not None - self.write(flat1063) + flat1079 = self._try_flat(msg, self.pretty_break) + if flat1079 is not None: + assert flat1079 is not None + self.write(flat1079) return None else: - def _t1561(_dollar_dollar): + def _t1593(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1562 = _dollar_dollar.attrs + _t1594 = _dollar_dollar.attrs else: - _t1562 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1562,) - _t1563 = _t1561(msg) - fields1057 = _t1563 - assert fields1057 is not None - unwrapped_fields1058 = fields1057 + _t1594 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1594,) + _t1595 = _t1593(msg) + fields1073 = _t1595 + assert fields1073 is not None + unwrapped_fields1074 = fields1073 self.write("(") self.write("break") self.indent_sexp() self.newline() - field1059 = unwrapped_fields1058[0] - self.pretty_relation_id(field1059) + field1075 = unwrapped_fields1074[0] + self.pretty_relation_id(field1075) self.newline() - field1060 = unwrapped_fields1058[1] - self.pretty_abstraction(field1060) - field1061 = unwrapped_fields1058[2] - if field1061 is not None: + field1076 = unwrapped_fields1074[1] + self.pretty_abstraction(field1076) + field1077 = unwrapped_fields1074[2] + if field1077 is not None: self.newline() - assert field1061 is not None - opt_val1062 = field1061 - self.pretty_attrs(opt_val1062) + assert field1077 is not None + opt_val1078 = field1077 + self.pretty_attrs(opt_val1078) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1071 = self._try_flat(msg, self.pretty_monoid_def) - if flat1071 is not None: - assert flat1071 is not None - self.write(flat1071) + flat1087 = self._try_flat(msg, self.pretty_monoid_def) + if flat1087 is not None: + assert flat1087 is not None + self.write(flat1087) return None else: - def _t1564(_dollar_dollar): + def _t1596(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1565 = _dollar_dollar.attrs + _t1597 = _dollar_dollar.attrs else: - _t1565 = None - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1565,) - _t1566 = _t1564(msg) - fields1064 = _t1566 - assert fields1064 is not None - unwrapped_fields1065 = fields1064 + _t1597 = None + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1597,) + _t1598 = _t1596(msg) + fields1080 = _t1598 + assert fields1080 is not None + unwrapped_fields1081 = fields1080 self.write("(") self.write("monoid") self.indent_sexp() self.newline() - field1066 = unwrapped_fields1065[0] - self.pretty_monoid(field1066) + field1082 = unwrapped_fields1081[0] + self.pretty_monoid(field1082) self.newline() - field1067 = unwrapped_fields1065[1] - self.pretty_relation_id(field1067) + field1083 = unwrapped_fields1081[1] + self.pretty_relation_id(field1083) self.newline() - field1068 = unwrapped_fields1065[2] - self.pretty_abstraction_with_arity(field1068) - field1069 = unwrapped_fields1065[3] - if field1069 is not None: + field1084 = unwrapped_fields1081[2] + self.pretty_abstraction_with_arity(field1084) + field1085 = unwrapped_fields1081[3] + if field1085 is not None: self.newline() - assert field1069 is not None - opt_val1070 = field1069 - self.pretty_attrs(opt_val1070) + assert field1085 is not None + opt_val1086 = field1085 + self.pretty_attrs(opt_val1086) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1080 = self._try_flat(msg, self.pretty_monoid) - if flat1080 is not None: - assert flat1080 is not None - self.write(flat1080) + flat1096 = self._try_flat(msg, self.pretty_monoid) + if flat1096 is not None: + assert flat1096 is not None + self.write(flat1096) return None else: - def _t1567(_dollar_dollar): + def _t1599(_dollar_dollar): if _dollar_dollar.HasField("or_monoid"): - _t1568 = _dollar_dollar.or_monoid + _t1600 = _dollar_dollar.or_monoid else: - _t1568 = None - return _t1568 - _t1569 = _t1567(msg) - deconstruct_result1078 = _t1569 - if deconstruct_result1078 is not None: - assert deconstruct_result1078 is not None - unwrapped1079 = deconstruct_result1078 - self.pretty_or_monoid(unwrapped1079) + _t1600 = None + return _t1600 + _t1601 = _t1599(msg) + deconstruct_result1094 = _t1601 + if deconstruct_result1094 is not None: + assert deconstruct_result1094 is not None + unwrapped1095 = deconstruct_result1094 + self.pretty_or_monoid(unwrapped1095) else: - def _t1570(_dollar_dollar): + def _t1602(_dollar_dollar): if _dollar_dollar.HasField("min_monoid"): - _t1571 = _dollar_dollar.min_monoid + _t1603 = _dollar_dollar.min_monoid else: - _t1571 = None - return _t1571 - _t1572 = _t1570(msg) - deconstruct_result1076 = _t1572 - if deconstruct_result1076 is not None: - assert deconstruct_result1076 is not None - unwrapped1077 = deconstruct_result1076 - self.pretty_min_monoid(unwrapped1077) + _t1603 = None + return _t1603 + _t1604 = _t1602(msg) + deconstruct_result1092 = _t1604 + if deconstruct_result1092 is not None: + assert deconstruct_result1092 is not None + unwrapped1093 = deconstruct_result1092 + self.pretty_min_monoid(unwrapped1093) else: - def _t1573(_dollar_dollar): + def _t1605(_dollar_dollar): if _dollar_dollar.HasField("max_monoid"): - _t1574 = _dollar_dollar.max_monoid + _t1606 = _dollar_dollar.max_monoid else: - _t1574 = None - return _t1574 - _t1575 = _t1573(msg) - deconstruct_result1074 = _t1575 - if deconstruct_result1074 is not None: - assert deconstruct_result1074 is not None - unwrapped1075 = deconstruct_result1074 - self.pretty_max_monoid(unwrapped1075) + _t1606 = None + return _t1606 + _t1607 = _t1605(msg) + deconstruct_result1090 = _t1607 + if deconstruct_result1090 is not None: + assert deconstruct_result1090 is not None + unwrapped1091 = deconstruct_result1090 + self.pretty_max_monoid(unwrapped1091) else: - def _t1576(_dollar_dollar): + def _t1608(_dollar_dollar): if _dollar_dollar.HasField("sum_monoid"): - _t1577 = _dollar_dollar.sum_monoid + _t1609 = _dollar_dollar.sum_monoid else: - _t1577 = None - return _t1577 - _t1578 = _t1576(msg) - deconstruct_result1072 = _t1578 - if deconstruct_result1072 is not None: - assert deconstruct_result1072 is not None - unwrapped1073 = deconstruct_result1072 - self.pretty_sum_monoid(unwrapped1073) + _t1609 = None + return _t1609 + _t1610 = _t1608(msg) + deconstruct_result1088 = _t1610 + if deconstruct_result1088 is not None: + assert deconstruct_result1088 is not None + unwrapped1089 = deconstruct_result1088 + self.pretty_sum_monoid(unwrapped1089) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1081 = msg + fields1097 = msg self.write("(") self.write("or") self.write(")") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1084 = self._try_flat(msg, self.pretty_min_monoid) - if flat1084 is not None: - assert flat1084 is not None - self.write(flat1084) + flat1100 = self._try_flat(msg, self.pretty_min_monoid) + if flat1100 is not None: + assert flat1100 is not None + self.write(flat1100) return None else: - def _t1579(_dollar_dollar): + def _t1611(_dollar_dollar): return _dollar_dollar.type - _t1580 = _t1579(msg) - fields1082 = _t1580 - assert fields1082 is not None - unwrapped_fields1083 = fields1082 + _t1612 = _t1611(msg) + fields1098 = _t1612 + assert fields1098 is not None + unwrapped_fields1099 = fields1098 self.write("(") self.write("min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1083) + self.pretty_type(unwrapped_fields1099) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1087 = self._try_flat(msg, self.pretty_max_monoid) - if flat1087 is not None: - assert flat1087 is not None - self.write(flat1087) + flat1103 = self._try_flat(msg, self.pretty_max_monoid) + if flat1103 is not None: + assert flat1103 is not None + self.write(flat1103) return None else: - def _t1581(_dollar_dollar): + def _t1613(_dollar_dollar): return _dollar_dollar.type - _t1582 = _t1581(msg) - fields1085 = _t1582 - assert fields1085 is not None - unwrapped_fields1086 = fields1085 + _t1614 = _t1613(msg) + fields1101 = _t1614 + assert fields1101 is not None + unwrapped_fields1102 = fields1101 self.write("(") self.write("max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1086) + self.pretty_type(unwrapped_fields1102) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1090 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1090 is not None: - assert flat1090 is not None - self.write(flat1090) + flat1106 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1106 is not None: + assert flat1106 is not None + self.write(flat1106) return None else: - def _t1583(_dollar_dollar): + def _t1615(_dollar_dollar): return _dollar_dollar.type - _t1584 = _t1583(msg) - fields1088 = _t1584 - assert fields1088 is not None - unwrapped_fields1089 = fields1088 + _t1616 = _t1615(msg) + fields1104 = _t1616 + assert fields1104 is not None + unwrapped_fields1105 = fields1104 self.write("(") self.write("sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1089) + self.pretty_type(unwrapped_fields1105) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1098 = self._try_flat(msg, self.pretty_monus_def) - if flat1098 is not None: - assert flat1098 is not None - self.write(flat1098) + flat1114 = self._try_flat(msg, self.pretty_monus_def) + if flat1114 is not None: + assert flat1114 is not None + self.write(flat1114) return None else: - def _t1585(_dollar_dollar): + def _t1617(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1586 = _dollar_dollar.attrs + _t1618 = _dollar_dollar.attrs else: - _t1586 = None - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1586,) - _t1587 = _t1585(msg) - fields1091 = _t1587 - assert fields1091 is not None - unwrapped_fields1092 = fields1091 + _t1618 = None + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1618,) + _t1619 = _t1617(msg) + fields1107 = _t1619 + assert fields1107 is not None + unwrapped_fields1108 = fields1107 self.write("(") self.write("monus") self.indent_sexp() self.newline() - field1093 = unwrapped_fields1092[0] - self.pretty_monoid(field1093) + field1109 = unwrapped_fields1108[0] + self.pretty_monoid(field1109) self.newline() - field1094 = unwrapped_fields1092[1] - self.pretty_relation_id(field1094) + field1110 = unwrapped_fields1108[1] + self.pretty_relation_id(field1110) self.newline() - field1095 = unwrapped_fields1092[2] - self.pretty_abstraction_with_arity(field1095) - field1096 = unwrapped_fields1092[3] - if field1096 is not None: + field1111 = unwrapped_fields1108[2] + self.pretty_abstraction_with_arity(field1111) + field1112 = unwrapped_fields1108[3] + if field1112 is not None: self.newline() - assert field1096 is not None - opt_val1097 = field1096 - self.pretty_attrs(opt_val1097) + assert field1112 is not None + opt_val1113 = field1112 + self.pretty_attrs(opt_val1113) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1105 = self._try_flat(msg, self.pretty_constraint) - if flat1105 is not None: - assert flat1105 is not None - self.write(flat1105) + flat1121 = self._try_flat(msg, self.pretty_constraint) + if flat1121 is not None: + assert flat1121 is not None + self.write(flat1121) return None else: - def _t1588(_dollar_dollar): + def _t1620(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - _t1589 = _t1588(msg) - fields1099 = _t1589 - assert fields1099 is not None - unwrapped_fields1100 = fields1099 + _t1621 = _t1620(msg) + fields1115 = _t1621 + assert fields1115 is not None + unwrapped_fields1116 = fields1115 self.write("(") self.write("functional_dependency") self.indent_sexp() self.newline() - field1101 = unwrapped_fields1100[0] - self.pretty_relation_id(field1101) + field1117 = unwrapped_fields1116[0] + self.pretty_relation_id(field1117) self.newline() - field1102 = unwrapped_fields1100[1] - self.pretty_abstraction(field1102) + field1118 = unwrapped_fields1116[1] + self.pretty_abstraction(field1118) self.newline() - field1103 = unwrapped_fields1100[2] - self.pretty_functional_dependency_keys(field1103) + field1119 = unwrapped_fields1116[2] + self.pretty_functional_dependency_keys(field1119) self.newline() - field1104 = unwrapped_fields1100[3] - self.pretty_functional_dependency_values(field1104) + field1120 = unwrapped_fields1116[3] + self.pretty_functional_dependency_values(field1120) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1109 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1109 is not None: - assert flat1109 is not None - self.write(flat1109) + flat1125 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1125 is not None: + assert flat1125 is not None + self.write(flat1125) return None else: - fields1106 = msg + fields1122 = msg self.write("(") self.write("keys") self.indent_sexp() - if not len(fields1106) == 0: + if not len(fields1122) == 0: self.newline() - for i1108, elem1107 in enumerate(fields1106): - if (i1108 > 0): + for i1124, elem1123 in enumerate(fields1122): + if (i1124 > 0): self.newline() - self.pretty_var(elem1107) + self.pretty_var(elem1123) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1113 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1113 is not None: - assert flat1113 is not None - self.write(flat1113) + flat1129 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1129 is not None: + assert flat1129 is not None + self.write(flat1129) return None else: - fields1110 = msg + fields1126 = msg self.write("(") self.write("values") self.indent_sexp() - if not len(fields1110) == 0: + if not len(fields1126) == 0: self.newline() - for i1112, elem1111 in enumerate(fields1110): - if (i1112 > 0): + for i1128, elem1127 in enumerate(fields1126): + if (i1128 > 0): self.newline() - self.pretty_var(elem1111) + self.pretty_var(elem1127) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1120 = self._try_flat(msg, self.pretty_data) - if flat1120 is not None: - assert flat1120 is not None - self.write(flat1120) + flat1136 = self._try_flat(msg, self.pretty_data) + if flat1136 is not None: + assert flat1136 is not None + self.write(flat1136) return None else: - def _t1590(_dollar_dollar): + def _t1622(_dollar_dollar): if _dollar_dollar.HasField("rel_edb"): - _t1591 = _dollar_dollar.rel_edb + _t1623 = _dollar_dollar.rel_edb else: - _t1591 = None - return _t1591 - _t1592 = _t1590(msg) - deconstruct_result1118 = _t1592 - if deconstruct_result1118 is not None: - assert deconstruct_result1118 is not None - unwrapped1119 = deconstruct_result1118 - self.pretty_rel_edb(unwrapped1119) + _t1623 = None + return _t1623 + _t1624 = _t1622(msg) + deconstruct_result1134 = _t1624 + if deconstruct_result1134 is not None: + assert deconstruct_result1134 is not None + unwrapped1135 = deconstruct_result1134 + self.pretty_rel_edb(unwrapped1135) else: - def _t1593(_dollar_dollar): + def _t1625(_dollar_dollar): if _dollar_dollar.HasField("betree_relation"): - _t1594 = _dollar_dollar.betree_relation + _t1626 = _dollar_dollar.betree_relation else: - _t1594 = None - return _t1594 - _t1595 = _t1593(msg) - deconstruct_result1116 = _t1595 - if deconstruct_result1116 is not None: - assert deconstruct_result1116 is not None - unwrapped1117 = deconstruct_result1116 - self.pretty_betree_relation(unwrapped1117) + _t1626 = None + return _t1626 + _t1627 = _t1625(msg) + deconstruct_result1132 = _t1627 + if deconstruct_result1132 is not None: + assert deconstruct_result1132 is not None + unwrapped1133 = deconstruct_result1132 + self.pretty_betree_relation(unwrapped1133) else: - def _t1596(_dollar_dollar): + def _t1628(_dollar_dollar): if _dollar_dollar.HasField("csv_data"): - _t1597 = _dollar_dollar.csv_data + _t1629 = _dollar_dollar.csv_data else: - _t1597 = None - return _t1597 - _t1598 = _t1596(msg) - deconstruct_result1114 = _t1598 - if deconstruct_result1114 is not None: - assert deconstruct_result1114 is not None - unwrapped1115 = deconstruct_result1114 - self.pretty_csv_data(unwrapped1115) + _t1629 = None + return _t1629 + _t1630 = _t1628(msg) + deconstruct_result1130 = _t1630 + if deconstruct_result1130 is not None: + assert deconstruct_result1130 is not None + unwrapped1131 = deconstruct_result1130 + self.pretty_csv_data(unwrapped1131) else: raise ParseError("No matching rule for data") def pretty_rel_edb(self, msg: logic_pb2.RelEDB): - flat1126 = self._try_flat(msg, self.pretty_rel_edb) - if flat1126 is not None: - assert flat1126 is not None - self.write(flat1126) + flat1142 = self._try_flat(msg, self.pretty_rel_edb) + if flat1142 is not None: + assert flat1142 is not None + self.write(flat1142) return None else: - def _t1599(_dollar_dollar): + def _t1631(_dollar_dollar): return (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - _t1600 = _t1599(msg) - fields1121 = _t1600 - assert fields1121 is not None - unwrapped_fields1122 = fields1121 + _t1632 = _t1631(msg) + fields1137 = _t1632 + assert fields1137 is not None + unwrapped_fields1138 = fields1137 self.write("(") self.write("rel_edb") self.indent_sexp() self.newline() - field1123 = unwrapped_fields1122[0] - self.pretty_relation_id(field1123) + field1139 = unwrapped_fields1138[0] + self.pretty_relation_id(field1139) self.newline() - field1124 = unwrapped_fields1122[1] - self.pretty_rel_edb_path(field1124) + field1140 = unwrapped_fields1138[1] + self.pretty_rel_edb_path(field1140) self.newline() - field1125 = unwrapped_fields1122[2] - self.pretty_rel_edb_types(field1125) + field1141 = unwrapped_fields1138[2] + self.pretty_rel_edb_types(field1141) self.dedent() self.write(")") def pretty_rel_edb_path(self, msg: Sequence[str]): - flat1130 = self._try_flat(msg, self.pretty_rel_edb_path) - if flat1130 is not None: - assert flat1130 is not None - self.write(flat1130) + flat1146 = self._try_flat(msg, self.pretty_rel_edb_path) + if flat1146 is not None: + assert flat1146 is not None + self.write(flat1146) return None else: - fields1127 = msg + fields1143 = msg self.write("[") self.indent() - for i1129, elem1128 in enumerate(fields1127): - if (i1129 > 0): + for i1145, elem1144 in enumerate(fields1143): + if (i1145 > 0): self.newline() - self.write(self.format_string_value(elem1128)) + self.write(self.format_string_value(elem1144)) self.dedent() self.write("]") def pretty_rel_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1134 = self._try_flat(msg, self.pretty_rel_edb_types) - if flat1134 is not None: - assert flat1134 is not None - self.write(flat1134) + flat1150 = self._try_flat(msg, self.pretty_rel_edb_types) + if flat1150 is not None: + assert flat1150 is not None + self.write(flat1150) return None else: - fields1131 = msg + fields1147 = msg self.write("[") self.indent() - for i1133, elem1132 in enumerate(fields1131): - if (i1133 > 0): + for i1149, elem1148 in enumerate(fields1147): + if (i1149 > 0): self.newline() - self.pretty_type(elem1132) + self.pretty_type(elem1148) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1139 = self._try_flat(msg, self.pretty_betree_relation) - if flat1139 is not None: - assert flat1139 is not None - self.write(flat1139) + flat1155 = self._try_flat(msg, self.pretty_betree_relation) + if flat1155 is not None: + assert flat1155 is not None + self.write(flat1155) return None else: - def _t1601(_dollar_dollar): + def _t1633(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.relation_info,) - _t1602 = _t1601(msg) - fields1135 = _t1602 - assert fields1135 is not None - unwrapped_fields1136 = fields1135 + _t1634 = _t1633(msg) + fields1151 = _t1634 + assert fields1151 is not None + unwrapped_fields1152 = fields1151 self.write("(") self.write("betree_relation") self.indent_sexp() self.newline() - field1137 = unwrapped_fields1136[0] - self.pretty_relation_id(field1137) + field1153 = unwrapped_fields1152[0] + self.pretty_relation_id(field1153) self.newline() - field1138 = unwrapped_fields1136[1] - self.pretty_betree_info(field1138) + field1154 = unwrapped_fields1152[1] + self.pretty_betree_info(field1154) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1145 = self._try_flat(msg, self.pretty_betree_info) - if flat1145 is not None: - assert flat1145 is not None - self.write(flat1145) + flat1161 = self._try_flat(msg, self.pretty_betree_info) + if flat1161 is not None: + assert flat1161 is not None + self.write(flat1161) return None else: - def _t1603(_dollar_dollar): - _t1604 = self.deconstruct_betree_info_config(_dollar_dollar) - return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1604,) - _t1605 = _t1603(msg) - fields1140 = _t1605 - assert fields1140 is not None - unwrapped_fields1141 = fields1140 + def _t1635(_dollar_dollar): + _t1636 = self.deconstruct_betree_info_config(_dollar_dollar) + return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1636,) + _t1637 = _t1635(msg) + fields1156 = _t1637 + assert fields1156 is not None + unwrapped_fields1157 = fields1156 self.write("(") self.write("betree_info") self.indent_sexp() self.newline() - field1142 = unwrapped_fields1141[0] - self.pretty_betree_info_key_types(field1142) + field1158 = unwrapped_fields1157[0] + self.pretty_betree_info_key_types(field1158) self.newline() - field1143 = unwrapped_fields1141[1] - self.pretty_betree_info_value_types(field1143) + field1159 = unwrapped_fields1157[1] + self.pretty_betree_info_value_types(field1159) self.newline() - field1144 = unwrapped_fields1141[2] - self.pretty_config_dict(field1144) + field1160 = unwrapped_fields1157[2] + self.pretty_config_dict(field1160) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1149 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1149 is not None: - assert flat1149 is not None - self.write(flat1149) + flat1165 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1165 is not None: + assert flat1165 is not None + self.write(flat1165) return None else: - fields1146 = msg + fields1162 = msg self.write("(") self.write("key_types") self.indent_sexp() - if not len(fields1146) == 0: + if not len(fields1162) == 0: self.newline() - for i1148, elem1147 in enumerate(fields1146): - if (i1148 > 0): + for i1164, elem1163 in enumerate(fields1162): + if (i1164 > 0): self.newline() - self.pretty_type(elem1147) + self.pretty_type(elem1163) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1153 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1153 is not None: - assert flat1153 is not None - self.write(flat1153) + flat1169 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1169 is not None: + assert flat1169 is not None + self.write(flat1169) return None else: - fields1150 = msg + fields1166 = msg self.write("(") self.write("value_types") self.indent_sexp() - if not len(fields1150) == 0: + if not len(fields1166) == 0: self.newline() - for i1152, elem1151 in enumerate(fields1150): - if (i1152 > 0): + for i1168, elem1167 in enumerate(fields1166): + if (i1168 > 0): self.newline() - self.pretty_type(elem1151) + self.pretty_type(elem1167) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1160 = self._try_flat(msg, self.pretty_csv_data) - if flat1160 is not None: - assert flat1160 is not None - self.write(flat1160) + flat1176 = self._try_flat(msg, self.pretty_csv_data) + if flat1176 is not None: + assert flat1176 is not None + self.write(flat1176) return None else: - def _t1606(_dollar_dollar): + def _t1638(_dollar_dollar): return (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - _t1607 = _t1606(msg) - fields1154 = _t1607 - assert fields1154 is not None - unwrapped_fields1155 = fields1154 + _t1639 = _t1638(msg) + fields1170 = _t1639 + assert fields1170 is not None + unwrapped_fields1171 = fields1170 self.write("(") self.write("csv_data") self.indent_sexp() self.newline() - field1156 = unwrapped_fields1155[0] - self.pretty_csvlocator(field1156) + field1172 = unwrapped_fields1171[0] + self.pretty_csvlocator(field1172) self.newline() - field1157 = unwrapped_fields1155[1] - self.pretty_csv_config(field1157) + field1173 = unwrapped_fields1171[1] + self.pretty_csv_config(field1173) self.newline() - field1158 = unwrapped_fields1155[2] - self.pretty_csv_columns(field1158) + field1174 = unwrapped_fields1171[2] + self.pretty_csv_columns(field1174) self.newline() - field1159 = unwrapped_fields1155[3] - self.pretty_csv_asof(field1159) + field1175 = unwrapped_fields1171[3] + self.pretty_csv_asof(field1175) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1167 = self._try_flat(msg, self.pretty_csvlocator) - if flat1167 is not None: - assert flat1167 is not None - self.write(flat1167) + flat1183 = self._try_flat(msg, self.pretty_csvlocator) + if flat1183 is not None: + assert flat1183 is not None + self.write(flat1183) return None else: - def _t1608(_dollar_dollar): + def _t1640(_dollar_dollar): if not len(_dollar_dollar.paths) == 0: - _t1609 = _dollar_dollar.paths + _t1641 = _dollar_dollar.paths else: - _t1609 = None + _t1641 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1610 = _dollar_dollar.inline_data.decode('utf-8') + _t1642 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1610 = None - return (_t1609, _t1610,) - _t1611 = _t1608(msg) - fields1161 = _t1611 - assert fields1161 is not None - unwrapped_fields1162 = fields1161 + _t1642 = None + return (_t1641, _t1642,) + _t1643 = _t1640(msg) + fields1177 = _t1643 + assert fields1177 is not None + unwrapped_fields1178 = fields1177 self.write("(") self.write("csv_locator") self.indent_sexp() - field1163 = unwrapped_fields1162[0] - if field1163 is not None: + field1179 = unwrapped_fields1178[0] + if field1179 is not None: self.newline() - assert field1163 is not None - opt_val1164 = field1163 - self.pretty_csv_locator_paths(opt_val1164) - field1165 = unwrapped_fields1162[1] - if field1165 is not None: + assert field1179 is not None + opt_val1180 = field1179 + self.pretty_csv_locator_paths(opt_val1180) + field1181 = unwrapped_fields1178[1] + if field1181 is not None: self.newline() - assert field1165 is not None - opt_val1166 = field1165 - self.pretty_csv_locator_inline_data(opt_val1166) + assert field1181 is not None + opt_val1182 = field1181 + self.pretty_csv_locator_inline_data(opt_val1182) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1171 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1171 is not None: - assert flat1171 is not None - self.write(flat1171) + flat1187 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1187 is not None: + assert flat1187 is not None + self.write(flat1187) return None else: - fields1168 = msg + fields1184 = msg self.write("(") self.write("paths") self.indent_sexp() - if not len(fields1168) == 0: + if not len(fields1184) == 0: self.newline() - for i1170, elem1169 in enumerate(fields1168): - if (i1170 > 0): + for i1186, elem1185 in enumerate(fields1184): + if (i1186 > 0): self.newline() - self.write(self.format_string_value(elem1169)) + self.write(self.format_string_value(elem1185)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1173 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1173 is not None: - assert flat1173 is not None - self.write(flat1173) + flat1189 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1189 is not None: + assert flat1189 is not None + self.write(flat1189) return None else: - fields1172 = msg + fields1188 = msg self.write("(") self.write("inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1172)) + self.write(self.format_string_value(fields1188)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1176 = self._try_flat(msg, self.pretty_csv_config) - if flat1176 is not None: - assert flat1176 is not None - self.write(flat1176) + flat1192 = self._try_flat(msg, self.pretty_csv_config) + if flat1192 is not None: + assert flat1192 is not None + self.write(flat1192) return None else: - def _t1612(_dollar_dollar): - _t1613 = self.deconstruct_csv_config(_dollar_dollar) - return _t1613 - _t1614 = _t1612(msg) - fields1174 = _t1614 - assert fields1174 is not None - unwrapped_fields1175 = fields1174 + def _t1644(_dollar_dollar): + _t1645 = self.deconstruct_csv_config(_dollar_dollar) + return _t1645 + _t1646 = _t1644(msg) + fields1190 = _t1646 + assert fields1190 is not None + unwrapped_fields1191 = fields1190 self.write("(") self.write("csv_config") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields1175) + self.pretty_config_dict(unwrapped_fields1191) self.dedent() self.write(")") def pretty_csv_columns(self, msg: Sequence[logic_pb2.CSVColumn]): - flat1180 = self._try_flat(msg, self.pretty_csv_columns) - if flat1180 is not None: - assert flat1180 is not None - self.write(flat1180) + flat1196 = self._try_flat(msg, self.pretty_csv_columns) + if flat1196 is not None: + assert flat1196 is not None + self.write(flat1196) return None else: - fields1177 = msg + fields1193 = msg self.write("(") self.write("columns") self.indent_sexp() - if not len(fields1177) == 0: + if not len(fields1193) == 0: self.newline() - for i1179, elem1178 in enumerate(fields1177): - if (i1179 > 0): + for i1195, elem1194 in enumerate(fields1193): + if (i1195 > 0): self.newline() - self.pretty_csv_column(elem1178) + self.pretty_csv_column(elem1194) self.dedent() self.write(")") def pretty_csv_column(self, msg: logic_pb2.CSVColumn): - flat1188 = self._try_flat(msg, self.pretty_csv_column) - if flat1188 is not None: - assert flat1188 is not None - self.write(flat1188) + flat1202 = self._try_flat(msg, self.pretty_csv_column) + if flat1202 is not None: + assert flat1202 is not None + self.write(flat1202) return None else: - def _t1615(_dollar_dollar): - return (_dollar_dollar.column_name, _dollar_dollar.target_id, _dollar_dollar.types,) - _t1616 = _t1615(msg) - fields1181 = _t1616 - assert fields1181 is not None - unwrapped_fields1182 = fields1181 + def _t1647(_dollar_dollar): + _t1648 = self.deconstruct_csv_column_tail(_dollar_dollar) + return (_dollar_dollar.column_path, _t1648,) + _t1649 = _t1647(msg) + fields1197 = _t1649 + assert fields1197 is not None + unwrapped_fields1198 = fields1197 self.write("(") self.write("column") self.indent_sexp() self.newline() - field1183 = unwrapped_fields1182[0] - self.write(self.format_string_value(field1183)) - self.newline() - field1184 = unwrapped_fields1182[1] - self.pretty_relation_id(field1184) - self.newline() - self.write("[") - field1185 = unwrapped_fields1182[2] - for i1187, elem1186 in enumerate(field1185): - if (i1187 > 0): - self.newline() - self.pretty_type(elem1186) - self.write("]") + field1199 = unwrapped_fields1198[0] + self.pretty_csv_column_path(field1199) + field1200 = unwrapped_fields1198[1] + if field1200 is not None: + self.newline() + assert field1200 is not None + opt_val1201 = field1200 + self.pretty_csv_column_tail(opt_val1201) self.dedent() self.write(")") + def pretty_csv_column_path(self, msg: Sequence[str]): + flat1209 = self._try_flat(msg, self.pretty_csv_column_path) + if flat1209 is not None: + assert flat1209 is not None + self.write(flat1209) + return None + else: + def _t1650(_dollar_dollar): + if len(_dollar_dollar) == 1: + _t1651 = _dollar_dollar[0] + else: + _t1651 = None + return _t1651 + _t1652 = _t1650(msg) + deconstruct_result1207 = _t1652 + if deconstruct_result1207 is not None: + assert deconstruct_result1207 is not None + unwrapped1208 = deconstruct_result1207 + self.write(self.format_string_value(unwrapped1208)) + else: + def _t1653(_dollar_dollar): + if len(_dollar_dollar) != 1: + _t1654 = _dollar_dollar + else: + _t1654 = None + return _t1654 + _t1655 = _t1653(msg) + deconstruct_result1203 = _t1655 + if deconstruct_result1203 is not None: + assert deconstruct_result1203 is not None + unwrapped1204 = deconstruct_result1203 + self.write("[") + self.indent() + for i1206, elem1205 in enumerate(unwrapped1204): + if (i1206 > 0): + self.newline() + self.write(self.format_string_value(elem1205)) + self.dedent() + self.write("]") + else: + raise ParseError("No matching rule for csv_column_path") + + def pretty_csv_column_tail(self, msg: tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]): + flat1220 = self._try_flat(msg, self.pretty_csv_column_tail) + if flat1220 is not None: + assert flat1220 is not None + self.write(flat1220) + return None + else: + def _t1656(_dollar_dollar): + if _dollar_dollar[0] is not None: + _t1657 = (_dollar_dollar[0], _dollar_dollar[1],) + else: + _t1657 = None + return _t1657 + _t1658 = _t1656(msg) + deconstruct_result1214 = _t1658 + if deconstruct_result1214 is not None: + assert deconstruct_result1214 is not None + unwrapped1215 = deconstruct_result1214 + field1216 = unwrapped1215[0] + self.pretty_relation_id(field1216) + self.write(" ") + self.write("[") + field1217 = unwrapped1215[1] + for i1219, elem1218 in enumerate(field1217): + if (i1219 > 0): + self.newline() + self.pretty_type(elem1218) + self.write("]") + else: + def _t1659(_dollar_dollar): + return _dollar_dollar[1] + _t1660 = _t1659(msg) + fields1210 = _t1660 + assert fields1210 is not None + unwrapped_fields1211 = fields1210 + self.write("[") + self.indent() + for i1213, elem1212 in enumerate(unwrapped_fields1211): + if (i1213 > 0): + self.newline() + self.pretty_type(elem1212) + self.dedent() + self.write("]") + def pretty_csv_asof(self, msg: str): - flat1190 = self._try_flat(msg, self.pretty_csv_asof) - if flat1190 is not None: - assert flat1190 is not None - self.write(flat1190) + flat1222 = self._try_flat(msg, self.pretty_csv_asof) + if flat1222 is not None: + assert flat1222 is not None + self.write(flat1222) return None else: - fields1189 = msg + fields1221 = msg self.write("(") self.write("asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1189)) + self.write(self.format_string_value(fields1221)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1193 = self._try_flat(msg, self.pretty_undefine) - if flat1193 is not None: - assert flat1193 is not None - self.write(flat1193) + flat1225 = self._try_flat(msg, self.pretty_undefine) + if flat1225 is not None: + assert flat1225 is not None + self.write(flat1225) return None else: - def _t1617(_dollar_dollar): + def _t1661(_dollar_dollar): return _dollar_dollar.fragment_id - _t1618 = _t1617(msg) - fields1191 = _t1618 - assert fields1191 is not None - unwrapped_fields1192 = fields1191 + _t1662 = _t1661(msg) + fields1223 = _t1662 + assert fields1223 is not None + unwrapped_fields1224 = fields1223 self.write("(") self.write("undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1192) + self.pretty_fragment_id(unwrapped_fields1224) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1198 = self._try_flat(msg, self.pretty_context) - if flat1198 is not None: - assert flat1198 is not None - self.write(flat1198) + flat1230 = self._try_flat(msg, self.pretty_context) + if flat1230 is not None: + assert flat1230 is not None + self.write(flat1230) return None else: - def _t1619(_dollar_dollar): + def _t1663(_dollar_dollar): return _dollar_dollar.relations - _t1620 = _t1619(msg) - fields1194 = _t1620 - assert fields1194 is not None - unwrapped_fields1195 = fields1194 + _t1664 = _t1663(msg) + fields1226 = _t1664 + assert fields1226 is not None + unwrapped_fields1227 = fields1226 self.write("(") self.write("context") self.indent_sexp() - if not len(unwrapped_fields1195) == 0: + if not len(unwrapped_fields1227) == 0: self.newline() - for i1197, elem1196 in enumerate(unwrapped_fields1195): - if (i1197 > 0): + for i1229, elem1228 in enumerate(unwrapped_fields1227): + if (i1229 > 0): self.newline() - self.pretty_relation_id(elem1196) + self.pretty_relation_id(elem1228) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1203 = self._try_flat(msg, self.pretty_snapshot) - if flat1203 is not None: - assert flat1203 is not None - self.write(flat1203) + flat1235 = self._try_flat(msg, self.pretty_snapshot) + if flat1235 is not None: + assert flat1235 is not None + self.write(flat1235) return None else: - def _t1621(_dollar_dollar): + def _t1665(_dollar_dollar): return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - _t1622 = _t1621(msg) - fields1199 = _t1622 - assert fields1199 is not None - unwrapped_fields1200 = fields1199 + _t1666 = _t1665(msg) + fields1231 = _t1666 + assert fields1231 is not None + unwrapped_fields1232 = fields1231 self.write("(") self.write("snapshot") self.indent_sexp() self.newline() - field1201 = unwrapped_fields1200[0] - self.pretty_rel_edb_path(field1201) + field1233 = unwrapped_fields1232[0] + self.pretty_rel_edb_path(field1233) self.newline() - field1202 = unwrapped_fields1200[1] - self.pretty_relation_id(field1202) + field1234 = unwrapped_fields1232[1] + self.pretty_relation_id(field1234) self.dedent() self.write(")") def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1207 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1207 is not None: - assert flat1207 is not None - self.write(flat1207) + flat1239 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1239 is not None: + assert flat1239 is not None + self.write(flat1239) return None else: - fields1204 = msg + fields1236 = msg self.write("(") self.write("reads") self.indent_sexp() - if not len(fields1204) == 0: + if not len(fields1236) == 0: self.newline() - for i1206, elem1205 in enumerate(fields1204): - if (i1206 > 0): + for i1238, elem1237 in enumerate(fields1236): + if (i1238 > 0): self.newline() - self.pretty_read(elem1205) + self.pretty_read(elem1237) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1218 = self._try_flat(msg, self.pretty_read) - if flat1218 is not None: - assert flat1218 is not None - self.write(flat1218) + flat1250 = self._try_flat(msg, self.pretty_read) + if flat1250 is not None: + assert flat1250 is not None + self.write(flat1250) return None else: - def _t1623(_dollar_dollar): + def _t1667(_dollar_dollar): if _dollar_dollar.HasField("demand"): - _t1624 = _dollar_dollar.demand + _t1668 = _dollar_dollar.demand else: - _t1624 = None - return _t1624 - _t1625 = _t1623(msg) - deconstruct_result1216 = _t1625 - if deconstruct_result1216 is not None: - assert deconstruct_result1216 is not None - unwrapped1217 = deconstruct_result1216 - self.pretty_demand(unwrapped1217) + _t1668 = None + return _t1668 + _t1669 = _t1667(msg) + deconstruct_result1248 = _t1669 + if deconstruct_result1248 is not None: + assert deconstruct_result1248 is not None + unwrapped1249 = deconstruct_result1248 + self.pretty_demand(unwrapped1249) else: - def _t1626(_dollar_dollar): + def _t1670(_dollar_dollar): if _dollar_dollar.HasField("output"): - _t1627 = _dollar_dollar.output + _t1671 = _dollar_dollar.output else: - _t1627 = None - return _t1627 - _t1628 = _t1626(msg) - deconstruct_result1214 = _t1628 - if deconstruct_result1214 is not None: - assert deconstruct_result1214 is not None - unwrapped1215 = deconstruct_result1214 - self.pretty_output(unwrapped1215) + _t1671 = None + return _t1671 + _t1672 = _t1670(msg) + deconstruct_result1246 = _t1672 + if deconstruct_result1246 is not None: + assert deconstruct_result1246 is not None + unwrapped1247 = deconstruct_result1246 + self.pretty_output(unwrapped1247) else: - def _t1629(_dollar_dollar): + def _t1673(_dollar_dollar): if _dollar_dollar.HasField("what_if"): - _t1630 = _dollar_dollar.what_if + _t1674 = _dollar_dollar.what_if else: - _t1630 = None - return _t1630 - _t1631 = _t1629(msg) - deconstruct_result1212 = _t1631 - if deconstruct_result1212 is not None: - assert deconstruct_result1212 is not None - unwrapped1213 = deconstruct_result1212 - self.pretty_what_if(unwrapped1213) + _t1674 = None + return _t1674 + _t1675 = _t1673(msg) + deconstruct_result1244 = _t1675 + if deconstruct_result1244 is not None: + assert deconstruct_result1244 is not None + unwrapped1245 = deconstruct_result1244 + self.pretty_what_if(unwrapped1245) else: - def _t1632(_dollar_dollar): + def _t1676(_dollar_dollar): if _dollar_dollar.HasField("abort"): - _t1633 = _dollar_dollar.abort + _t1677 = _dollar_dollar.abort else: - _t1633 = None - return _t1633 - _t1634 = _t1632(msg) - deconstruct_result1210 = _t1634 - if deconstruct_result1210 is not None: - assert deconstruct_result1210 is not None - unwrapped1211 = deconstruct_result1210 - self.pretty_abort(unwrapped1211) + _t1677 = None + return _t1677 + _t1678 = _t1676(msg) + deconstruct_result1242 = _t1678 + if deconstruct_result1242 is not None: + assert deconstruct_result1242 is not None + unwrapped1243 = deconstruct_result1242 + self.pretty_abort(unwrapped1243) else: - def _t1635(_dollar_dollar): + def _t1679(_dollar_dollar): if _dollar_dollar.HasField("export"): - _t1636 = _dollar_dollar.export + _t1680 = _dollar_dollar.export else: - _t1636 = None - return _t1636 - _t1637 = _t1635(msg) - deconstruct_result1208 = _t1637 - if deconstruct_result1208 is not None: - assert deconstruct_result1208 is not None - unwrapped1209 = deconstruct_result1208 - self.pretty_export(unwrapped1209) + _t1680 = None + return _t1680 + _t1681 = _t1679(msg) + deconstruct_result1240 = _t1681 + if deconstruct_result1240 is not None: + assert deconstruct_result1240 is not None + unwrapped1241 = deconstruct_result1240 + self.pretty_export(unwrapped1241) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1221 = self._try_flat(msg, self.pretty_demand) - if flat1221 is not None: - assert flat1221 is not None - self.write(flat1221) + flat1253 = self._try_flat(msg, self.pretty_demand) + if flat1253 is not None: + assert flat1253 is not None + self.write(flat1253) return None else: - def _t1638(_dollar_dollar): + def _t1682(_dollar_dollar): return _dollar_dollar.relation_id - _t1639 = _t1638(msg) - fields1219 = _t1639 - assert fields1219 is not None - unwrapped_fields1220 = fields1219 + _t1683 = _t1682(msg) + fields1251 = _t1683 + assert fields1251 is not None + unwrapped_fields1252 = fields1251 self.write("(") self.write("demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1220) + self.pretty_relation_id(unwrapped_fields1252) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1226 = self._try_flat(msg, self.pretty_output) - if flat1226 is not None: - assert flat1226 is not None - self.write(flat1226) + flat1258 = self._try_flat(msg, self.pretty_output) + if flat1258 is not None: + assert flat1258 is not None + self.write(flat1258) return None else: - def _t1640(_dollar_dollar): + def _t1684(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.relation_id,) - _t1641 = _t1640(msg) - fields1222 = _t1641 - assert fields1222 is not None - unwrapped_fields1223 = fields1222 + _t1685 = _t1684(msg) + fields1254 = _t1685 + assert fields1254 is not None + unwrapped_fields1255 = fields1254 self.write("(") self.write("output") self.indent_sexp() self.newline() - field1224 = unwrapped_fields1223[0] - self.pretty_name(field1224) + field1256 = unwrapped_fields1255[0] + self.pretty_name(field1256) self.newline() - field1225 = unwrapped_fields1223[1] - self.pretty_relation_id(field1225) + field1257 = unwrapped_fields1255[1] + self.pretty_relation_id(field1257) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1231 = self._try_flat(msg, self.pretty_what_if) - if flat1231 is not None: - assert flat1231 is not None - self.write(flat1231) + flat1263 = self._try_flat(msg, self.pretty_what_if) + if flat1263 is not None: + assert flat1263 is not None + self.write(flat1263) return None else: - def _t1642(_dollar_dollar): + def _t1686(_dollar_dollar): return (_dollar_dollar.branch, _dollar_dollar.epoch,) - _t1643 = _t1642(msg) - fields1227 = _t1643 - assert fields1227 is not None - unwrapped_fields1228 = fields1227 + _t1687 = _t1686(msg) + fields1259 = _t1687 + assert fields1259 is not None + unwrapped_fields1260 = fields1259 self.write("(") self.write("what_if") self.indent_sexp() self.newline() - field1229 = unwrapped_fields1228[0] - self.pretty_name(field1229) + field1261 = unwrapped_fields1260[0] + self.pretty_name(field1261) self.newline() - field1230 = unwrapped_fields1228[1] - self.pretty_epoch(field1230) + field1262 = unwrapped_fields1260[1] + self.pretty_epoch(field1262) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1237 = self._try_flat(msg, self.pretty_abort) - if flat1237 is not None: - assert flat1237 is not None - self.write(flat1237) + flat1269 = self._try_flat(msg, self.pretty_abort) + if flat1269 is not None: + assert flat1269 is not None + self.write(flat1269) return None else: - def _t1644(_dollar_dollar): + def _t1688(_dollar_dollar): if _dollar_dollar.name != "abort": - _t1645 = _dollar_dollar.name + _t1689 = _dollar_dollar.name else: - _t1645 = None - return (_t1645, _dollar_dollar.relation_id,) - _t1646 = _t1644(msg) - fields1232 = _t1646 - assert fields1232 is not None - unwrapped_fields1233 = fields1232 + _t1689 = None + return (_t1689, _dollar_dollar.relation_id,) + _t1690 = _t1688(msg) + fields1264 = _t1690 + assert fields1264 is not None + unwrapped_fields1265 = fields1264 self.write("(") self.write("abort") self.indent_sexp() - field1234 = unwrapped_fields1233[0] - if field1234 is not None: + field1266 = unwrapped_fields1265[0] + if field1266 is not None: self.newline() - assert field1234 is not None - opt_val1235 = field1234 - self.pretty_name(opt_val1235) + assert field1266 is not None + opt_val1267 = field1266 + self.pretty_name(opt_val1267) self.newline() - field1236 = unwrapped_fields1233[1] - self.pretty_relation_id(field1236) + field1268 = unwrapped_fields1265[1] + self.pretty_relation_id(field1268) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1240 = self._try_flat(msg, self.pretty_export) - if flat1240 is not None: - assert flat1240 is not None - self.write(flat1240) + flat1272 = self._try_flat(msg, self.pretty_export) + if flat1272 is not None: + assert flat1272 is not None + self.write(flat1272) return None else: - def _t1647(_dollar_dollar): + def _t1691(_dollar_dollar): return _dollar_dollar.csv_config - _t1648 = _t1647(msg) - fields1238 = _t1648 - assert fields1238 is not None - unwrapped_fields1239 = fields1238 + _t1692 = _t1691(msg) + fields1270 = _t1692 + assert fields1270 is not None + unwrapped_fields1271 = fields1270 self.write("(") self.write("export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped_fields1239) + self.pretty_export_csv_config(unwrapped_fields1271) self.dedent() self.write(")") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1246 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1246 is not None: - assert flat1246 is not None - self.write(flat1246) + flat1278 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1278 is not None: + assert flat1278 is not None + self.write(flat1278) return None else: - def _t1649(_dollar_dollar): - _t1650 = self.deconstruct_export_csv_config(_dollar_dollar) - return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1650,) - _t1651 = _t1649(msg) - fields1241 = _t1651 - assert fields1241 is not None - unwrapped_fields1242 = fields1241 + def _t1693(_dollar_dollar): + _t1694 = self.deconstruct_export_csv_config(_dollar_dollar) + return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1694,) + _t1695 = _t1693(msg) + fields1273 = _t1695 + assert fields1273 is not None + unwrapped_fields1274 = fields1273 self.write("(") self.write("export_csv_config") self.indent_sexp() self.newline() - field1243 = unwrapped_fields1242[0] - self.pretty_export_csv_path(field1243) + field1275 = unwrapped_fields1274[0] + self.pretty_export_csv_path(field1275) self.newline() - field1244 = unwrapped_fields1242[1] - self.pretty_export_csv_columns(field1244) + field1276 = unwrapped_fields1274[1] + self.pretty_export_csv_columns(field1276) self.newline() - field1245 = unwrapped_fields1242[2] - self.pretty_config_dict(field1245) + field1277 = unwrapped_fields1274[2] + self.pretty_config_dict(field1277) self.dedent() self.write(")") def pretty_export_csv_path(self, msg: str): - flat1248 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1248 is not None: - assert flat1248 is not None - self.write(flat1248) + flat1280 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1280 is not None: + assert flat1280 is not None + self.write(flat1280) return None else: - fields1247 = msg + fields1279 = msg self.write("(") self.write("path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1247)) + self.write(self.format_string_value(fields1279)) self.dedent() self.write(")") def pretty_export_csv_columns(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1252 = self._try_flat(msg, self.pretty_export_csv_columns) - if flat1252 is not None: - assert flat1252 is not None - self.write(flat1252) + flat1284 = self._try_flat(msg, self.pretty_export_csv_columns) + if flat1284 is not None: + assert flat1284 is not None + self.write(flat1284) return None else: - fields1249 = msg + fields1281 = msg self.write("(") self.write("columns") self.indent_sexp() - if not len(fields1249) == 0: + if not len(fields1281) == 0: self.newline() - for i1251, elem1250 in enumerate(fields1249): - if (i1251 > 0): + for i1283, elem1282 in enumerate(fields1281): + if (i1283 > 0): self.newline() - self.pretty_export_csv_column(elem1250) + self.pretty_export_csv_column(elem1282) self.dedent() self.write(")") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1257 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1257 is not None: - assert flat1257 is not None - self.write(flat1257) + flat1289 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1289 is not None: + assert flat1289 is not None + self.write(flat1289) return None else: - def _t1652(_dollar_dollar): + def _t1696(_dollar_dollar): return (_dollar_dollar.column_name, _dollar_dollar.column_data,) - _t1653 = _t1652(msg) - fields1253 = _t1653 - assert fields1253 is not None - unwrapped_fields1254 = fields1253 + _t1697 = _t1696(msg) + fields1285 = _t1697 + assert fields1285 is not None + unwrapped_fields1286 = fields1285 self.write("(") self.write("column") self.indent_sexp() self.newline() - field1255 = unwrapped_fields1254[0] - self.write(self.format_string_value(field1255)) + field1287 = unwrapped_fields1286[0] + self.write(self.format_string_value(field1287)) self.newline() - field1256 = unwrapped_fields1254[1] - self.pretty_relation_id(field1256) + field1288 = unwrapped_fields1286[1] + self.pretty_relation_id(field1288) self.dedent() self.write(")") @@ -3804,8 +3893,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1691 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1691) + _t1736 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1736) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") diff --git a/sdks/python/src/lqp/proto/v1/fragments_pb2.py b/sdks/python/src/lqp/proto/v1/fragments_pb2.py index 1ed054e4..54986913 100644 --- a/sdks/python/src/lqp/proto/v1/fragments_pb2.py +++ b/sdks/python/src/lqp/proto/v1/fragments_pb2.py @@ -15,14 +15,14 @@ from lqp.proto.v1 import logic_pb2 as relationalai_dot_lqp_dot_v1_dot_logic__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#relationalai/lqp/v1/fragments.proto\x12\x13relationalai.lqp.v1\x1a\x1frelationalai/lqp/v1/logic.proto\"\xc0\x01\n\x08\x46ragment\x12/\n\x02id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\x02id\x12\x44\n\x0c\x64\x65\x63larations\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.DeclarationR\x0c\x64\x65\x63larations\x12=\n\ndebug_info\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DebugInfoR\tdebugInfo\"]\n\tDebugInfo\x12\x31\n\x03ids\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x03ids\x12\x1d\n\norig_names\x18\x02 \x03(\tR\torigNames\"\x1c\n\nFragmentId\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02idB\x1fZ\x1dlogical-query-protocol/lqp/v1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#relationalai/lqp/v1/fragments.proto\x12\x13relationalai.lqp.v1\x1a\x1frelationalai/lqp/v1/logic.proto\"\xc0\x01\n\x08\x46ragment\x12/\n\x02id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\x02id\x12\x44\n\x0c\x64\x65\x63larations\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.DeclarationR\x0c\x64\x65\x63larations\x12=\n\ndebug_info\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DebugInfoR\tdebugInfo\"]\n\tDebugInfo\x12\x31\n\x03ids\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x03ids\x12\x1d\n\norig_names\x18\x02 \x03(\tR\torigNames\"\x1c\n\nFragmentId\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02idBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'relationalai.lqp.v1.fragments_pb2', _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals['DESCRIPTOR']._options = None - _globals['DESCRIPTOR']._serialized_options = b'Z\035logical-query-protocol/lqp/v1' + _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1' _globals['_FRAGMENT']._serialized_start=94 _globals['_FRAGMENT']._serialized_end=286 _globals['_DEBUGINFO']._serialized_start=288 diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.py b/sdks/python/src/lqp/proto/v1/logic_pb2.py index 3f02d031..b19672d5 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.py +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.py @@ -14,14 +14,14 @@ -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\"u\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\"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\"m\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\"\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\"\xd6\x01\n\x04\x44\x61ta\x12\x36\n\x07rel_edb\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.RelEDBH\x00R\x06relEdb\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\x63svDataB\x0b\n\tdata_type\"\x8b\x01\n\x06RelEDB\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\"\xca\x01\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.CSVColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\xe3\x02\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\"\x9b\x01\n\tCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12<\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\x89\x06\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\x62ooleanTypeB\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\"\xd1\x04\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\x62ooleanValueB\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\x05valueB\x1fZ\x1dlogical-query-protocol/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\"u\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\"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\"m\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\"\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\"\xd6\x01\n\x04\x44\x61ta\x12\x36\n\x07rel_edb\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.RelEDBH\x00R\x06relEdb\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\x63svDataB\x0b\n\tdata_type\"\x8b\x01\n\x06RelEDB\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\"\xca\x01\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.CSVColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\xe3\x02\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\"\xae\x01\n\tCSVColumn\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\"\x89\x06\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\x62ooleanTypeB\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\"\xd1\x04\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\x62ooleanValueB\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) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'relationalai.lqp.v1.logic_pb2', _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals['DESCRIPTOR']._options = None - _globals['DESCRIPTOR']._serialized_options = b'Z\035logical-query-protocol/lqp/v1' + _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1' _globals['_DECLARATION']._serialized_start=57 _globals['_DECLARATION']._serialized_end=316 _globals['_DEF']._serialized_start=319 @@ -115,45 +115,45 @@ _globals['_CSVCONFIG']._serialized_start=6830 _globals['_CSVCONFIG']._serialized_end=7185 _globals['_CSVCOLUMN']._serialized_start=7188 - _globals['_CSVCOLUMN']._serialized_end=7343 - _globals['_RELATIONID']._serialized_start=7345 - _globals['_RELATIONID']._serialized_end=7405 - _globals['_TYPE']._serialized_start=7408 - _globals['_TYPE']._serialized_end=8185 - _globals['_UNSPECIFIEDTYPE']._serialized_start=8187 - _globals['_UNSPECIFIEDTYPE']._serialized_end=8204 - _globals['_STRINGTYPE']._serialized_start=8206 - _globals['_STRINGTYPE']._serialized_end=8218 - _globals['_INTTYPE']._serialized_start=8220 - _globals['_INTTYPE']._serialized_end=8229 - _globals['_FLOATTYPE']._serialized_start=8231 - _globals['_FLOATTYPE']._serialized_end=8242 - _globals['_UINT128TYPE']._serialized_start=8244 - _globals['_UINT128TYPE']._serialized_end=8257 - _globals['_INT128TYPE']._serialized_start=8259 - _globals['_INT128TYPE']._serialized_end=8271 - _globals['_DATETYPE']._serialized_start=8273 - _globals['_DATETYPE']._serialized_end=8283 - _globals['_DATETIMETYPE']._serialized_start=8285 - _globals['_DATETIMETYPE']._serialized_end=8299 - _globals['_MISSINGTYPE']._serialized_start=8301 - _globals['_MISSINGTYPE']._serialized_end=8314 - _globals['_DECIMALTYPE']._serialized_start=8316 - _globals['_DECIMALTYPE']._serialized_end=8381 - _globals['_BOOLEANTYPE']._serialized_start=8383 - _globals['_BOOLEANTYPE']._serialized_end=8396 - _globals['_VALUE']._serialized_start=8399 - _globals['_VALUE']._serialized_end=8992 - _globals['_UINT128VALUE']._serialized_start=8994 - _globals['_UINT128VALUE']._serialized_end=9046 - _globals['_INT128VALUE']._serialized_start=9048 - _globals['_INT128VALUE']._serialized_end=9099 - _globals['_MISSINGVALUE']._serialized_start=9101 - _globals['_MISSINGVALUE']._serialized_end=9115 - _globals['_DATEVALUE']._serialized_start=9117 - _globals['_DATEVALUE']._serialized_end=9188 - _globals['_DATETIMEVALUE']._serialized_start=9191 - _globals['_DATETIMEVALUE']._serialized_end=9368 - _globals['_DECIMALVALUE']._serialized_start=9370 - _globals['_DECIMALVALUE']._serialized_end=9492 + _globals['_CSVCOLUMN']._serialized_end=7362 + _globals['_RELATIONID']._serialized_start=7364 + _globals['_RELATIONID']._serialized_end=7424 + _globals['_TYPE']._serialized_start=7427 + _globals['_TYPE']._serialized_end=8204 + _globals['_UNSPECIFIEDTYPE']._serialized_start=8206 + _globals['_UNSPECIFIEDTYPE']._serialized_end=8223 + _globals['_STRINGTYPE']._serialized_start=8225 + _globals['_STRINGTYPE']._serialized_end=8237 + _globals['_INTTYPE']._serialized_start=8239 + _globals['_INTTYPE']._serialized_end=8248 + _globals['_FLOATTYPE']._serialized_start=8250 + _globals['_FLOATTYPE']._serialized_end=8261 + _globals['_UINT128TYPE']._serialized_start=8263 + _globals['_UINT128TYPE']._serialized_end=8276 + _globals['_INT128TYPE']._serialized_start=8278 + _globals['_INT128TYPE']._serialized_end=8290 + _globals['_DATETYPE']._serialized_start=8292 + _globals['_DATETYPE']._serialized_end=8302 + _globals['_DATETIMETYPE']._serialized_start=8304 + _globals['_DATETIMETYPE']._serialized_end=8318 + _globals['_MISSINGTYPE']._serialized_start=8320 + _globals['_MISSINGTYPE']._serialized_end=8333 + _globals['_DECIMALTYPE']._serialized_start=8335 + _globals['_DECIMALTYPE']._serialized_end=8400 + _globals['_BOOLEANTYPE']._serialized_start=8402 + _globals['_BOOLEANTYPE']._serialized_end=8415 + _globals['_VALUE']._serialized_start=8418 + _globals['_VALUE']._serialized_end=9011 + _globals['_UINT128VALUE']._serialized_start=9013 + _globals['_UINT128VALUE']._serialized_end=9065 + _globals['_INT128VALUE']._serialized_start=9067 + _globals['_INT128VALUE']._serialized_end=9118 + _globals['_MISSINGVALUE']._serialized_start=9120 + _globals['_MISSINGVALUE']._serialized_end=9134 + _globals['_DATEVALUE']._serialized_start=9136 + _globals['_DATEVALUE']._serialized_end=9207 + _globals['_DATETIMEVALUE']._serialized_start=9210 + _globals['_DATETIMEVALUE']._serialized_end=9387 + _globals['_DECIMALVALUE']._serialized_start=9389 + _globals['_DECIMALVALUE']._serialized_end=9511 # @@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 7f98bbcf..2411d8fc 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi @@ -447,14 +447,14 @@ class CSVConfig(_message.Message): def __init__(self, header_row: _Optional[int] = ..., skip: _Optional[int] = ..., new_line: _Optional[str] = ..., delimiter: _Optional[str] = ..., quotechar: _Optional[str] = ..., escapechar: _Optional[str] = ..., comment: _Optional[str] = ..., missing_strings: _Optional[_Iterable[str]] = ..., decimal_separator: _Optional[str] = ..., encoding: _Optional[str] = ..., compression: _Optional[str] = ...) -> None: ... class CSVColumn(_message.Message): - __slots__ = ("column_name", "target_id", "types") - COLUMN_NAME_FIELD_NUMBER: _ClassVar[int] + __slots__ = ("column_path", "target_id", "types") + COLUMN_PATH_FIELD_NUMBER: _ClassVar[int] TARGET_ID_FIELD_NUMBER: _ClassVar[int] TYPES_FIELD_NUMBER: _ClassVar[int] - column_name: str + column_path: _containers.RepeatedScalarFieldContainer[str] target_id: RelationId types: _containers.RepeatedCompositeFieldContainer[Type] - def __init__(self, column_name: _Optional[str] = ..., target_id: _Optional[_Union[RelationId, _Mapping]] = ..., types: _Optional[_Iterable[_Union[Type, _Mapping]]] = ...) -> None: ... + def __init__(self, column_path: _Optional[_Iterable[str]] = ..., target_id: _Optional[_Union[RelationId, _Mapping]] = ..., types: _Optional[_Iterable[_Union[Type, _Mapping]]] = ...) -> None: ... class RelationId(_message.Message): __slots__ = ("id_low", "id_high") diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.py b/sdks/python/src/lqp/proto/v1/transactions_pb2.py index fdca81c0..2da081b7 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.py +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.py @@ -16,14 +16,14 @@ from lqp.proto.v1 import logic_pb2 as relationalai_dot_lqp_dot_v1_dot_logic__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x7f\n\x08Snapshot\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"\xc4\x04\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"`\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x1fZ\x1dlogical-query-protocol/lqp/v1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x7f\n\x08Snapshot\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"\xc4\x04\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"`\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'relationalai.lqp.v1.transactions_pb2', _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals['DESCRIPTOR']._options = None - _globals['DESCRIPTOR']._serialized_options = b'Z\035logical-query-protocol/lqp/v1' + _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1' _globals['_MAINTENANCELEVEL']._serialized_start=2761 _globals['_MAINTENANCELEVEL']._serialized_end=2896 _globals['_TRANSACTION']._serialized_start=134 diff --git a/tests/bin/cdc.bin b/tests/bin/cdc.bin new file mode 100644 index 0000000000000000000000000000000000000000..85b823bcd83c27b46e97744cd995d4f3a9494dcf GIT binary patch literal 664 zcmd<;XXSd#%=Lho>n<}F3l~$Gq0kW~rGrdT`T(MQ0_6yT<@mlmfM#b>4f4a$7M(DCDZQ>7G>6oZs3Tm?&BVs0u>`gpqj{Ej2r zdZd_y7^H-`n813b+OtY=>`w^>>yd`*fk@VN*$F1AT~>lgLR|)t%+lY#&0<2eF-THL z#K^$NRM)^v*T68uz`zQOqNI8mxe(q1GGSf-GGT57GGXolGGVR(GGTTDnJ}A#*mASu zGxLhUG|(+V?4_A0U;z%07r`vf)Vz|+l1fm3u%|+0!3>akQ6XV2m>CF%!G%Fe5RMcQ x6B6Nq+kkMfkhqX27m|f=_X|k~iE$y>kMIt}D425)enW^utcH7(MTm)m5di*ryUPFo literal 0 HcmV?d00001 diff --git a/tests/lqp/cdc.lqp b/tests/lqp/cdc.lqp new file mode 100644 index 00000000..635446b4 --- /dev/null +++ b/tests/lqp/cdc.lqp @@ -0,0 +1,36 @@ +(transaction + (epoch + (writes + (define + (fragment :f1 + ;; CDC load with path-based columns + (csv_data + (csv_locator + (paths "s3://bucket/cdc/batch_001.csv")) + (csv_config {}) + (columns + ;; Unbound column (schema only) + (column "raw_data") + + ;; METADATA$KEY insert + delete deltas + (column ["append" "METADATA$KEY"] :mk_ins [UINT128]) + (column ["delete" "METADATA$KEY"] :mk_del [UINT128]) + + ;; Data columns: insert-only deltas + (column ["append" "user_id"] :uid_ins [INT]) + (column ["append" "name"] :name_ins [STRING]) + + ;; Full snapshot + delta on same column + (column "id" :entity_id [INT]) + (column ["append" "id"] :eid_ins [INT]) + (column ["delete" "id"] :eid_del [INT])) + (asof "2025-06-01T00:00:00Z"))))) + + (reads + (output :mk_ins :mk_ins) + (output :mk_del :mk_del) + (output :uid_ins :uid_ins) + (output :name_ins :name_ins) + (output :entity_id :entity_id) + (output :eid_ins :eid_ins) + (output :eid_del :eid_del)))) diff --git a/tests/pretty/cdc.lqp b/tests/pretty/cdc.lqp new file mode 100644 index 00000000..d58c0e26 --- /dev/null +++ b/tests/pretty/cdc.lqp @@ -0,0 +1,37 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/cdc/batch_001.csv")) + (csv_config + { + :csv_compression "auto" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1 + :csv_quotechar "\"" + :csv_skip 0}) + (columns + (column "raw_data") + (column ["append" "METADATA$KEY"] :mk_ins [UINT128]) + (column ["delete" "METADATA$KEY"] :mk_del [UINT128]) + (column ["append" "user_id"] :uid_ins [INT]) + (column ["append" "name"] :name_ins [STRING]) + (column "id" :entity_id [INT]) + (column ["append" "id"] :eid_ins [INT]) + (column ["delete" "id"] :eid_del [INT])) + (asof "2025-06-01T00:00:00Z"))))) + (reads + (output :mk_ins :mk_ins) + (output :mk_del :mk_del) + (output :uid_ins :uid_ins) + (output :name_ins :name_ins) + (output :entity_id :entity_id) + (output :eid_ins :eid_ins) + (output :eid_del :eid_del)))) diff --git a/tests/pretty_debug/cdc.lqp b/tests/pretty_debug/cdc.lqp new file mode 100644 index 00000000..82e59b79 --- /dev/null +++ b/tests/pretty_debug/cdc.lqp @@ -0,0 +1,48 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/cdc/batch_001.csv")) + (csv_config + { + :csv_compression "auto" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1 + :csv_quotechar "\"" + :csv_skip 0}) + (columns + (column "raw_data") + (column ["append" "METADATA$KEY"] 0xb7219c9b1f7d843d [UINT128]) + (column ["delete" "METADATA$KEY"] 0xc45b4cf618eed32f [UINT128]) + (column ["append" "user_id"] 0x7982cff88800e869 [INT]) + (column ["append" "name"] 0x8cb6c4889f2f67c7 [STRING]) + (column "id" 0x5364bf081a053f95 [INT]) + (column ["append" "id"] 0x22d32663113e8a7d [INT]) + (column ["delete" "id"] 0x337b9038b6bf2f6a [INT])) + (asof "2025-06-01T00:00:00Z"))))) + (reads + (output :mk_ins 0xb7219c9b1f7d843d) + (output :mk_del 0xc45b4cf618eed32f) + (output :uid_ins 0x7982cff88800e869) + (output :name_ins 0x8cb6c4889f2f67c7) + (output :entity_id 0x5364bf081a053f95) + (output :eid_ins 0x22d32663113e8a7d) + (output :eid_del 0x337b9038b6bf2f6a)))) + +;; Debug information +;; ----------------------- +;; Original names +;; ID `0x337b9038b6bf2f6a` -> `eid_del` +;; ID `0x22d32663113e8a7d` -> `eid_ins` +;; ID `0x5364bf081a053f95` -> `entity_id` +;; ID `0xc45b4cf618eed32f` -> `mk_del` +;; ID `0xb7219c9b1f7d843d` -> `mk_ins` +;; ID `0x8cb6c4889f2f67c7` -> `name_ins` +;; ID `0x7982cff88800e869` -> `uid_ins` From 74d4e49c8a8eb7d7b9782f770c109cb35267b6ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 01:41:07 +0100 Subject: [PATCH 2/8] CSVColumn -> GNFColumn --- meta/src/meta/grammar.y | 14 +++++++------- proto/relationalai/lqp/v1/logic.proto | 4 ++-- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index b4fab3e9..5bc4bacc 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -71,10 +71,10 @@ %nonterm construct logic.Construct %nonterm context transactions.Context %nonterm csv_asof String -%nonterm csv_column logic.CSVColumn +%nonterm csv_column logic.GNFColumn %nonterm csv_column_path Sequence[String] %nonterm csv_column_tail Tuple[Optional[logic.RelationId], Sequence[logic.Type]] -%nonterm csv_columns Sequence[logic.CSVColumn] +%nonterm csv_columns Sequence[logic.GNFColumn] %nonterm csv_config logic.CSVConfig %nonterm csv_data logic.CSVData %nonterm csv_locator_inline_data String @@ -961,7 +961,7 @@ csv_data deconstruct: $3: logic.CSVLocator = $$.locator $4: logic.CSVConfig = $$.config - $5: Sequence[logic.CSVColumn] = $$.columns + $5: Sequence[logic.GNFColumn] = $$.columns $6: String = $$.asof csv_locator_paths @@ -1407,14 +1407,14 @@ def deconstruct_export_csv_config(msg: transactions.ExportCSVConfig) -> List[Tup return builtin.list_sort(result) -def construct_csv_column(path: Sequence[String], tail: Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]) -> logic.CSVColumn: +def construct_csv_column(path: Sequence[String], tail: Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]) -> logic.GNFColumn: if tail is not None: t: Tuple[Optional[logic.RelationId], Sequence[logic.Type]] = builtin.unwrap_option(tail) - return logic.CSVColumn(column_path=path, target_id=t[0], types=t[1]) - return logic.CSVColumn(column_path=path, target_id=None, types=list[logic.Type]()) + return logic.GNFColumn(column_path=path, target_id=t[0], types=t[1]) + return logic.GNFColumn(column_path=path, target_id=None, types=list[logic.Type]()) -def deconstruct_csv_column_tail(col: logic.CSVColumn) -> Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]: +def deconstruct_csv_column_tail(col: logic.GNFColumn) -> Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]: if builtin.has_proto_field(col, 'target_id') or not builtin.is_empty(col.types): return builtin.some(builtin.tuple(col.target_id, col.types)) return None diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto index cc8a4c0d..c321c54a 100644 --- a/proto/relationalai/lqp/v1/logic.proto +++ b/proto/relationalai/lqp/v1/logic.proto @@ -277,7 +277,7 @@ message BeTreeLocator { message CSVData { CSVLocator locator = 1; CSVConfig config = 2; - repeated CSVColumn columns = 3; + repeated GNFColumn columns = 3; string asof = 4; // Blob storage timestamp for freshness requirements } @@ -311,7 +311,7 @@ message CSVConfig { string compression = 11; // "none", "gzip", "zstd", "auto" (default: "auto") } -message CSVColumn { +message GNFColumn { repeated string column_path = 1; // Column identifier path (was: string column_name) optional RelationId target_id = 2; // Target relation (now explicit optional) repeated Type types = 3; // Relation signature (key types + value types) From 96a79585b27771173fe69df928eec76f24291b20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 01:42:21 +0100 Subject: [PATCH 3/8] IcebergRelation -> IcebergData --- proto/relationalai/lqp/v1/logic.proto | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto index c321c54a..bfeac63a 100644 --- a/proto/relationalai/lqp/v1/logic.proto +++ b/proto/relationalai/lqp/v1/logic.proto @@ -235,7 +235,7 @@ message Data { RelEDB rel_edb = 1; BeTreeRelation betree_relation = 2; CSVData csv_data = 3; - // IcebergRelation iceberg_relation = 4; + // IcebergData iceberg_data = 4; } } From 2de9f39e638535f97576ac98431ae58d13c71f2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 01:56:09 +0100 Subject: [PATCH 4/8] Simplify grammar and rename csv_column -> gnf_column --- meta/src/meta/grammar.y | 47 ++++++++++---------------------------- tests/lqp/cdc.lqp | 2 +- tests/pretty/cdc.lqp | 2 +- tests/pretty_debug/cdc.lqp | 2 +- 4 files changed, 15 insertions(+), 38 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index 5bc4bacc..3cb6f8d4 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -71,10 +71,9 @@ %nonterm construct logic.Construct %nonterm context transactions.Context %nonterm csv_asof String -%nonterm csv_column logic.GNFColumn -%nonterm csv_column_path Sequence[String] -%nonterm csv_column_tail Tuple[Optional[logic.RelationId], Sequence[logic.Type]] -%nonterm csv_columns Sequence[logic.GNFColumn] +%nonterm gnf_column logic.GNFColumn +%nonterm gnf_column_path Sequence[String] +%nonterm gnf_columns Sequence[logic.GNFColumn] %nonterm csv_config logic.CSVConfig %nonterm csv_data logic.CSVData %nonterm csv_locator_inline_data String @@ -949,14 +948,14 @@ betree_info_key_types betree_info_value_types : "(" "value_types" type* ")" -csv_columns - : "(" "columns" csv_column* ")" +gnf_columns + : "(" "columns" gnf_column* ")" csv_asof : "(" "asof" STRING ")" csv_data - : "(" "csv_data" csvlocator csv_config csv_columns csv_asof ")" + : "(" "csv_data" csvlocator csv_config gnf_columns csv_asof ")" construct: $$ = logic.CSVData(locator=$3, config=$4, columns=$5, asof=$6) deconstruct: $3: logic.CSVLocator = $$.locator @@ -982,7 +981,7 @@ csv_config construct: $$ = construct_csv_config($3) deconstruct: $3: Sequence[Tuple[String, logic.Value]] = deconstruct_csv_config($$) -csv_column_path +gnf_column_path : STRING construct: $$ = [$1] deconstruct if builtin.length($$) == 1: @@ -992,23 +991,13 @@ csv_column_path deconstruct if builtin.length($$) != 1: $2: Sequence[String] = $$ -csv_column_tail - : relation_id "[" type* "]" - construct: $$ = builtin.tuple(builtin.some($1), $3) - deconstruct if $$[0] is not None: - $1: logic.RelationId = $$[0] - $3: Sequence[logic.Type] = $$[1] - | "[" type* "]" - construct: $$ = builtin.tuple(None, $2) - deconstruct: - $2: Sequence[logic.Type] = $$[1] - -csv_column - : "(" "column" csv_column_path csv_column_tail? ")" - construct: $$ = construct_csv_column($3, $4) +gnf_column + : "(" "column" gnf_column_path relation_id? "[" type* "]" ")" + construct: $$ = logic.GNFColumn(column_path=$3, target_id=$4, types=$6) deconstruct: $3: Sequence[String] = $$.column_path - $4: Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]] = deconstruct_csv_column_tail($$) + $4: Optional[logic.RelationId] = $$.target_id if builtin.has_proto_field($$, "target_id") else None + $6: Sequence[logic.Type] = $$.types undefine : "(" "undefine" fragment_id ")" @@ -1407,18 +1396,6 @@ def deconstruct_export_csv_config(msg: transactions.ExportCSVConfig) -> List[Tup return builtin.list_sort(result) -def construct_csv_column(path: Sequence[String], tail: Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]) -> logic.GNFColumn: - if tail is not None: - t: Tuple[Optional[logic.RelationId], Sequence[logic.Type]] = builtin.unwrap_option(tail) - return logic.GNFColumn(column_path=path, target_id=t[0], types=t[1]) - return logic.GNFColumn(column_path=path, target_id=None, types=list[logic.Type]()) - - -def deconstruct_csv_column_tail(col: logic.GNFColumn) -> Optional[Tuple[Optional[logic.RelationId], Sequence[logic.Type]]]: - if builtin.has_proto_field(col, 'target_id') or not builtin.is_empty(col.types): - return builtin.some(builtin.tuple(col.target_id, col.types)) - return None - def deconstruct_relation_id_string(msg: logic.RelationId) -> String: name: Optional[String] = builtin.relation_id_to_string(msg) diff --git a/tests/lqp/cdc.lqp b/tests/lqp/cdc.lqp index 635446b4..0d14a75f 100644 --- a/tests/lqp/cdc.lqp +++ b/tests/lqp/cdc.lqp @@ -10,7 +10,7 @@ (csv_config {}) (columns ;; Unbound column (schema only) - (column "raw_data") + (column "raw_data" []) ;; METADATA$KEY insert + delete deltas (column ["append" "METADATA$KEY"] :mk_ins [UINT128]) diff --git a/tests/pretty/cdc.lqp b/tests/pretty/cdc.lqp index d58c0e26..5f196d30 100644 --- a/tests/pretty/cdc.lqp +++ b/tests/pretty/cdc.lqp @@ -18,7 +18,7 @@ :csv_quotechar "\"" :csv_skip 0}) (columns - (column "raw_data") + (column "raw_data" []) (column ["append" "METADATA$KEY"] :mk_ins [UINT128]) (column ["delete" "METADATA$KEY"] :mk_del [UINT128]) (column ["append" "user_id"] :uid_ins [INT]) diff --git a/tests/pretty_debug/cdc.lqp b/tests/pretty_debug/cdc.lqp index 82e59b79..14da99d1 100644 --- a/tests/pretty_debug/cdc.lqp +++ b/tests/pretty_debug/cdc.lqp @@ -18,7 +18,7 @@ :csv_quotechar "\"" :csv_skip 0}) (columns - (column "raw_data") + (column "raw_data" []) (column ["append" "METADATA$KEY"] 0xb7219c9b1f7d843d [UINT128]) (column ["delete" "METADATA$KEY"] 0xc45b4cf618eed32f [UINT128]) (column ["append" "user_id"] 0x7982cff88800e869 [INT]) From 8c4b474a2b272cf65cd0e9d56df211c1abb7d53b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 02:01:27 +0100 Subject: [PATCH 5/8] RelEDB -> EDB --- meta/src/meta/grammar.y | 26 ++++++++++---------- proto/relationalai/lqp/v1/logic.proto | 4 +-- proto/relationalai/lqp/v1/transactions.proto | 2 +- tests/lqp/edb.lqp | 10 ++++---- tests/lqp/snapshot.lqp | 6 ++--- tests/pretty/edb.lqp | 8 +++--- tests/pretty/snapshot.lqp | 6 ++--- tests/pretty_debug/edb.lqp | 8 +++--- tests/pretty_debug/snapshot.lqp | 6 ++--- 9 files changed, 38 insertions(+), 38 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index 3cb6f8d4..bec04604 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -138,9 +138,9 @@ %nonterm read transactions.Read %nonterm reduce logic.Reduce %nonterm rel_atom logic.RelAtom -%nonterm rel_edb logic.RelEDB -%nonterm rel_edb_path Sequence[String] -%nonterm rel_edb_types Sequence[logic.Type] +%nonterm edb logic.EDB +%nonterm edb_path Sequence[String] +%nonterm edb_types Sequence[logic.Type] %nonterm rel_term logic.RelTerm %nonterm relation_id logic.RelationId %nonterm script logic.Script @@ -900,10 +900,10 @@ functional_dependency_values : "(" "values" var* ")" data - : rel_edb - construct: $$ = logic.Data(rel_edb=$1) - deconstruct if builtin.has_proto_field($$, 'rel_edb'): - $1: logic.RelEDB = $$.rel_edb + : edb + construct: $$ = logic.Data(edb=$1) + deconstruct if builtin.has_proto_field($$, 'edb'): + $1: logic.EDB = $$.edb | betree_relation construct: $$ = logic.Data(betree_relation=$1) deconstruct if builtin.has_proto_field($$, 'betree_relation'): @@ -913,15 +913,15 @@ data deconstruct if builtin.has_proto_field($$, 'csv_data'): $1: logic.CSVData = $$.csv_data -rel_edb_path +edb_path : "[" STRING* "]" -rel_edb_types +edb_types : "[" type* "]" -rel_edb - : "(" "rel_edb" relation_id rel_edb_path rel_edb_types ")" - construct: $$ = logic.RelEDB(target_id=$3, path=$4, types=$5) +edb + : "(" "edb" relation_id edb_path edb_types ")" + construct: $$ = logic.EDB(target_id=$3, path=$4, types=$5) deconstruct: $3: logic.RelationId = $$.target_id $4: Sequence[String] = $$.path @@ -1010,7 +1010,7 @@ context deconstruct: $3: Sequence[logic.RelationId] = $$.relations snapshot - : "(" "snapshot" rel_edb_path relation_id ")" + : "(" "snapshot" edb_path relation_id ")" construct: $$ = transactions.Snapshot(destination_path=$3, source_relation=$4) deconstruct: $3: Sequence[String] = $$.destination_path diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto index bfeac63a..3ae1c8eb 100644 --- a/proto/relationalai/lqp/v1/logic.proto +++ b/proto/relationalai/lqp/v1/logic.proto @@ -232,14 +232,14 @@ message Attribute { // message Data { oneof data_type { - RelEDB rel_edb = 1; + EDB edb = 1; BeTreeRelation betree_relation = 2; CSVData csv_data = 3; // IcebergData iceberg_data = 4; } } -message RelEDB { +message EDB { RelationId target_id = 1; repeated string path = 2; repeated Type types = 3; diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto index e93725b3..a40b5875 100644 --- a/proto/relationalai/lqp/v1/transactions.proto +++ b/proto/relationalai/lqp/v1/transactions.proto @@ -65,7 +65,7 @@ message Context { } // Demand the source IDB, take an immutable snapshot, and turn it into an EDB under the -// given path (specified as a sequence of strings, see RelEDB). +// given path (specified as a sequence of strings, see EDB). message Snapshot { repeated string destination_path = 1; RelationId source_relation = 2; diff --git a/tests/lqp/edb.lqp b/tests/lqp/edb.lqp index b1bee8a5..5f0b9a84 100644 --- a/tests/lqp/edb.lqp +++ b/tests/lqp/edb.lqp @@ -81,18 +81,18 @@ :betree_locator_element_count 10 :betree_locator_tree_height 1 })) - ;; RelEDB examples (formerly BaseRelationPath) + ;; EDB examples (formerly BaseRelationPath) ;; Simple path with basic types - (rel_edb :path_simple ["my_base_relation"] [INT STRING FLOAT]) + (edb :path_simple ["my_base_relation"] [INT STRING FLOAT]) ;; Path with multiple segments - (rel_edb :path_specialized ["another" "path"] [INT STRING]) + (edb :path_specialized ["another" "path"] [INT STRING]) ;; Path with mixed types including decimals - (rel_edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING]) + (edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING]) ;; Path with no types (empty) - (rel_edb :path_empty ["empty_path"] []) + (edb :path_empty ["empty_path"] []) ;; Mix with def and algorithm (def :foo ([x::INT] (= x 1))) diff --git a/tests/lqp/snapshot.lqp b/tests/lqp/snapshot.lqp index a134ba7a..2e73b3ef 100644 --- a/tests/lqp/snapshot.lqp +++ b/tests/lqp/snapshot.lqp @@ -6,9 +6,9 @@ ;; Define the EDBs we're going to be referring to. (define (fragment :snapshots - (rel_edb :snapshot1 ["my_edb"] []) - (rel_edb :snapshot2 ["database" "table"] []) - (rel_edb :snapshot3 ["schema" "namespace" "relation"] []))) + (edb :snapshot1 ["my_edb"] []) + (edb :snapshot2 ["database" "table"] []) + (edb :snapshot3 ["schema" "namespace" "relation"] []))) (define (fragment :frag1 (def :my_rel diff --git a/tests/pretty/edb.lqp b/tests/pretty/edb.lqp index 6a11a6ac..c39dd33a 100644 --- a/tests/pretty/edb.lqp +++ b/tests/pretty/edb.lqp @@ -83,10 +83,10 @@ :betree_locator_element_count 10 :betree_locator_root_pageid 0x7777888899990000111122 :betree_locator_tree_height 1})) - (rel_edb :path_simple ["my_base_relation"] [INT STRING FLOAT]) - (rel_edb :path_specialized ["another" "path"] [INT STRING]) - (rel_edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING]) - (rel_edb :path_empty ["empty_path"] []) + (edb :path_simple ["my_base_relation"] [INT STRING FLOAT]) + (edb :path_specialized ["another" "path"] [INT STRING]) + (edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING]) + (edb :path_empty ["empty_path"] []) (def :foo ([x::INT] (= x 1))) (algorithm :bar :baz (script (assign :bar ([y::INT] (= y 2))))))) (define diff --git a/tests/pretty/snapshot.lqp b/tests/pretty/snapshot.lqp index c3fa0b3c..80483c8e 100644 --- a/tests/pretty/snapshot.lqp +++ b/tests/pretty/snapshot.lqp @@ -5,9 +5,9 @@ (define (fragment :snapshots - (rel_edb :snapshot1 ["my_edb"] []) - (rel_edb :snapshot2 ["database" "table"] []) - (rel_edb :snapshot3 ["schema" "namespace" "relation"] []))) + (edb :snapshot1 ["my_edb"] []) + (edb :snapshot2 ["database" "table"] []) + (edb :snapshot3 ["schema" "namespace" "relation"] []))) (define (fragment :frag1 diff --git a/tests/pretty_debug/edb.lqp b/tests/pretty_debug/edb.lqp index b15872f3..f56235d6 100644 --- a/tests/pretty_debug/edb.lqp +++ b/tests/pretty_debug/edb.lqp @@ -83,10 +83,10 @@ :betree_locator_element_count 10 :betree_locator_root_pageid 0x7777888899990000111122 :betree_locator_tree_height 1})) - (rel_edb 0x15840b06a27cfd50 ["my_base_relation"] [INT STRING FLOAT]) - (rel_edb 0xd18eb5ae6b1c6d60 ["another" "path"] [INT STRING]) - (rel_edb 0x1d55ba4ed7a92d94 ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING]) - (rel_edb 0xce18a64a245dea33 ["empty_path"] []) + (edb 0x15840b06a27cfd50 ["my_base_relation"] [INT STRING FLOAT]) + (edb 0xd18eb5ae6b1c6d60 ["another" "path"] [INT STRING]) + (edb 0x1d55ba4ed7a92d94 ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING]) + (edb 0xce18a64a245dea33 ["empty_path"] []) (def 0x2c26b46b68ffc68f ([x::INT] (= x 1))) (algorithm 0xfcde2b2edba56bf4 diff --git a/tests/pretty_debug/snapshot.lqp b/tests/pretty_debug/snapshot.lqp index 88f2f930..cac6684e 100644 --- a/tests/pretty_debug/snapshot.lqp +++ b/tests/pretty_debug/snapshot.lqp @@ -5,9 +5,9 @@ (define (fragment :snapshots - (rel_edb 0xcd3b9ab2de079088 ["my_edb"] []) - (rel_edb 0xd1e6d3706be27c8 ["database" "table"] []) - (rel_edb 0xc6e65c9a8c481ef1 ["schema" "namespace" "relation"] []))) + (edb 0xcd3b9ab2de079088 ["my_edb"] []) + (edb 0xd1e6d3706be27c8 ["database" "table"] []) + (edb 0xc6e65c9a8c481ef1 ["schema" "namespace" "relation"] []))) (define (fragment :frag1 From 142e4a1cd01cc2671b5c08853d81d0c720227ee8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 02:02:58 +0100 Subject: [PATCH 6/8] Update SDKS --- sdks/go/src/lqp/v1/logic.pb.go | 591 ++- sdks/go/src/lqp/v1/transactions.pb.go | 2 +- sdks/go/src/parser.go | 3930 ++++++++------- sdks/go/src/pretty.go | 3937 ++++++++------- sdks/go/test/extra_print_test.go | 10 +- .../src/LogicalQueryProtocol.jl | 4 +- .../LogicalQueryProtocol.jl/src/equality.jl | 16 +- .../gen/relationalai/lqp/v1/fragments_pb.jl | 2 +- .../src/gen/relationalai/lqp/v1/logic_pb.jl | 194 +- .../relationalai/lqp/v1/transactions_pb.jl | 2 +- .../LogicalQueryProtocol.jl/src/parser.jl | 3239 ++++++------ .../LogicalQueryProtocol.jl/src/pretty.jl | 3967 ++++++++------- .../LogicalQueryProtocol.jl/src/properties.jl | 10 +- .../test/equality_tests.jl | 46 +- .../test/extra_pretty_tests.jl | 6 +- sdks/python/src/lqp/gen/parser.py | 3329 ++++++------- sdks/python/src/lqp/gen/pretty.py | 4384 ++++++++--------- sdks/python/src/lqp/proto/v1/logic_pb2.py | 120 +- sdks/python/src/lqp/proto/v1/logic_pb2.pyi | 16 +- sdks/python/tests/test_extra_pretty.py | 6 +- 20 files changed, 11756 insertions(+), 12055 deletions(-) diff --git a/sdks/go/src/lqp/v1/logic.pb.go b/sdks/go/src/lqp/v1/logic.pb.go index e4f92254..6319fe4f 100644 --- a/sdks/go/src/lqp/v1/logic.pb.go +++ b/sdks/go/src/lqp/v1/logic.pb.go @@ -2464,7 +2464,7 @@ type Data struct { state protoimpl.MessageState `protogen:"open.v1"` // Types that are valid to be assigned to DataType: // - // *Data_RelEdb + // *Data_Edb // *Data_BetreeRelation // *Data_CsvData DataType isData_DataType `protobuf_oneof:"data_type"` @@ -2509,10 +2509,10 @@ func (x *Data) GetDataType() isData_DataType { return nil } -func (x *Data) GetRelEdb() *RelEDB { +func (x *Data) GetEdb() *EDB { if x != nil { - if x, ok := x.DataType.(*Data_RelEdb); ok { - return x.RelEdb + if x, ok := x.DataType.(*Data_Edb); ok { + return x.Edb } } return nil @@ -2540,8 +2540,8 @@ type isData_DataType interface { isData_DataType() } -type Data_RelEdb struct { - RelEdb *RelEDB `protobuf:"bytes,1,opt,name=rel_edb,json=relEdb,proto3,oneof"` +type Data_Edb struct { + Edb *EDB `protobuf:"bytes,1,opt,name=edb,proto3,oneof"` } type Data_BetreeRelation struct { @@ -2549,16 +2549,16 @@ type Data_BetreeRelation struct { } type Data_CsvData struct { - CsvData *CSVData `protobuf:"bytes,3,opt,name=csv_data,json=csvData,proto3,oneof"` // IcebergRelation iceberg_relation = 4; + CsvData *CSVData `protobuf:"bytes,3,opt,name=csv_data,json=csvData,proto3,oneof"` // IcebergData iceberg_data = 4; } -func (*Data_RelEdb) isData_DataType() {} +func (*Data_Edb) isData_DataType() {} func (*Data_BetreeRelation) isData_DataType() {} func (*Data_CsvData) isData_DataType() {} -type RelEDB struct { +type EDB struct { state protoimpl.MessageState `protogen:"open.v1"` TargetId *RelationId `protobuf:"bytes,1,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"` Path []string `protobuf:"bytes,2,rep,name=path,proto3" json:"path,omitempty"` @@ -2567,20 +2567,20 @@ type RelEDB struct { sizeCache protoimpl.SizeCache } -func (x *RelEDB) Reset() { - *x = RelEDB{} +func (x *EDB) Reset() { + *x = EDB{} mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RelEDB) String() string { +func (x *EDB) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RelEDB) ProtoMessage() {} +func (*EDB) ProtoMessage() {} -func (x *RelEDB) ProtoReflect() protoreflect.Message { +func (x *EDB) ProtoReflect() protoreflect.Message { mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2592,26 +2592,26 @@ func (x *RelEDB) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RelEDB.ProtoReflect.Descriptor instead. -func (*RelEDB) Descriptor() ([]byte, []int) { +// Deprecated: Use EDB.ProtoReflect.Descriptor instead. +func (*EDB) Descriptor() ([]byte, []int) { return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{38} } -func (x *RelEDB) GetTargetId() *RelationId { +func (x *EDB) GetTargetId() *RelationId { if x != nil { return x.TargetId } return nil } -func (x *RelEDB) GetPath() []string { +func (x *EDB) GetPath() []string { if x != nil { return x.Path } return nil } -func (x *RelEDB) GetTypes() []*Type { +func (x *EDB) GetTypes() []*Type { if x != nil { return x.Types } @@ -2908,7 +2908,7 @@ type CSVData struct { state protoimpl.MessageState `protogen:"open.v1"` Locator *CSVLocator `protobuf:"bytes,1,opt,name=locator,proto3" json:"locator,omitempty"` Config *CSVConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` - Columns []*CSVColumn `protobuf:"bytes,3,rep,name=columns,proto3" json:"columns,omitempty"` + Columns []*GNFColumn `protobuf:"bytes,3,rep,name=columns,proto3" json:"columns,omitempty"` Asof string `protobuf:"bytes,4,opt,name=asof,proto3" json:"asof,omitempty"` // Blob storage timestamp for freshness requirements unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -2958,7 +2958,7 @@ func (x *CSVData) GetConfig() *CSVConfig { return nil } -func (x *CSVData) GetColumns() []*CSVColumn { +func (x *CSVData) GetColumns() []*GNFColumn { if x != nil { return x.Columns } @@ -3154,7 +3154,7 @@ func (x *CSVConfig) GetCompression() string { return "" } -type CSVColumn struct { +type GNFColumn struct { state protoimpl.MessageState `protogen:"open.v1"` ColumnPath []string `protobuf:"bytes,1,rep,name=column_path,json=columnPath,proto3" json:"column_path,omitempty"` // Column identifier path (was: string column_name) TargetId *RelationId `protobuf:"bytes,2,opt,name=target_id,json=targetId,proto3,oneof" json:"target_id,omitempty"` // Target relation (now explicit optional) @@ -3163,20 +3163,20 @@ type CSVColumn struct { sizeCache protoimpl.SizeCache } -func (x *CSVColumn) Reset() { - *x = CSVColumn{} +func (x *GNFColumn) Reset() { + *x = GNFColumn{} mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CSVColumn) String() string { +func (x *GNFColumn) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CSVColumn) ProtoMessage() {} +func (*GNFColumn) ProtoMessage() {} -func (x *CSVColumn) ProtoReflect() protoreflect.Message { +func (x *GNFColumn) ProtoReflect() protoreflect.Message { mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3188,26 +3188,26 @@ func (x *CSVColumn) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CSVColumn.ProtoReflect.Descriptor instead. -func (*CSVColumn) Descriptor() ([]byte, []int) { +// Deprecated: Use GNFColumn.ProtoReflect.Descriptor instead. +func (*GNFColumn) Descriptor() ([]byte, []int) { return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{46} } -func (x *CSVColumn) GetColumnPath() []string { +func (x *GNFColumn) GetColumnPath() []string { if x != nil { return x.ColumnPath } return nil } -func (x *CSVColumn) GetTargetId() *RelationId { +func (x *GNFColumn) GetTargetId() *RelationId { if x != nil { return x.TargetId } return nil } -func (x *CSVColumn) GetTypes() []*Type { +func (x *GNFColumn) GetTypes() []*Type { if x != nil { return x.Types } @@ -4811,267 +4811,266 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{ 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x04, 0x61, 0x72, 0x67, - 0x73, 0x22, 0xd6, 0x01, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x36, 0x0a, 0x07, 0x72, 0x65, - 0x6c, 0x5f, 0x65, 0x64, 0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, + 0x73, 0x22, 0xcc, 0x01, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x03, 0x65, 0x64, + 0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x44, + 0x42, 0x48, 0x00, 0x52, 0x03, 0x65, 0x64, 0x62, 0x12, 0x4e, 0x0a, 0x0f, 0x62, 0x65, 0x74, 0x72, + 0x65, 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, + 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x52, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x62, 0x65, 0x74, 0x72, 0x65, 0x65, + 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x08, 0x63, 0x73, 0x76, 0x5f, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x53, 0x56, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x07, 0x63, 0x73, 0x76, 0x44, + 0x61, 0x74, 0x61, 0x42, 0x0b, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x22, 0x88, 0x01, 0x0a, 0x03, 0x45, 0x44, 0x42, 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x45, 0x44, 0x42, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x6c, 0x45, - 0x64, 0x62, 0x12, 0x4e, 0x0a, 0x0f, 0x62, 0x65, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x72, 0x65, 0x6c, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, + 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x8b, 0x01, 0x0a, 0x0e, + 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x9f, 0x02, 0x0a, 0x0a, 0x42, 0x65, + 0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x48, 0x00, 0x52, 0x0e, 0x62, 0x65, 0x74, 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x08, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x44, 0x61, - 0x74, 0x61, 0x48, 0x00, 0x52, 0x07, 0x63, 0x73, 0x76, 0x44, 0x61, 0x74, 0x61, 0x42, 0x0b, 0x0a, - 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x06, 0x52, - 0x65, 0x6c, 0x45, 0x44, 0x42, 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, - 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, - 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x8b, 0x01, 0x0a, 0x0e, 0x42, 0x65, 0x54, - 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x04, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, + 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x12, 0x3a, 0x0a, 0x0b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0e, + 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 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, 0x42, 0x65, 0x54, 0x72, 0x65, + 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x4d, 0x0a, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x05, 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, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, + 0x61, 0x74, 0x6f, 0x72, 0x52, 0x0f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, + 0x63, 0x61, 0x74, 0x6f, 0x72, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x81, 0x01, 0x0a, 0x0c, + 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, + 0x65, 0x70, 0x73, 0x69, 0x6c, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x65, + 0x70, 0x73, 0x69, 0x6c, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x69, + 0x76, 0x6f, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x50, + 0x69, 0x76, 0x6f, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, + 0x74, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x44, 0x65, + 0x6c, 0x74, 0x61, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x61, 0x66, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x61, 0x66, 0x22, + 0xca, 0x01, 0x0a, 0x0d, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, + 0x72, 0x12, 0x44, 0x0a, 0x0b, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x69, 0x64, + 0x18, 0x01, 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, 0x0a, 0x72, 0x6f, 0x6f, + 0x74, 0x50, 0x61, 0x67, 0x65, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e, + 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, + 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6c, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0c, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x1f, 0x0a, 0x0b, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x72, 0x65, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x42, 0x0a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xca, 0x01, 0x0a, + 0x07, 0x43, 0x53, 0x56, 0x44, 0x61, 0x74, 0x61, 0x12, 0x39, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, + 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x12, 0x44, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x66, - 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, - 0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x9f, 0x02, 0x0a, 0x0a, 0x42, 0x65, 0x54, 0x72, 0x65, - 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, - 0x79, 0x70, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x3a, 0x0a, - 0x0b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, - 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0e, 0x73, 0x74, 0x6f, - 0x72, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 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, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x12, 0x4d, 0x0a, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61, + 0x74, 0x6f, 0x72, 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x63, + 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 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, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x22, 0x43, 0x0a, 0x0a, 0x43, 0x53, 0x56, + 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x12, 0x1f, 0x0a, + 0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x0a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0xe3, + 0x02, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x09, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x73, + 0x6b, 0x69, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, + 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, + 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x6f, 0x74, + 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, 0x6f, + 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, + 0x63, 0x68, 0x61, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x73, 0x63, 0x61, + 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, + 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, + 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69, + 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x63, + 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x53, 0x65, 0x70, + 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, + 0x6e, 0x67, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, + 0x6e, 0x67, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x09, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75, + 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x70, 0x61, 0x74, + 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x50, + 0x61, 0x74, 0x68, 0x12, 0x41, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x5f, 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x12, 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, 0x89, 0x06, 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, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f, + 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x42, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, + 0x0a, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 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, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, + 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x45, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 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, 0x55, 0x49, 0x6e, 0x74, + 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31, + 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 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, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, + 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61, + 0x74, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, - 0x72, 0x52, 0x0f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x63, 0x61, 0x74, - 0x6f, 0x72, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x81, 0x01, 0x0a, 0x0c, 0x42, 0x65, 0x54, - 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x70, 0x73, - 0x69, 0x6c, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x65, 0x70, 0x73, 0x69, - 0x6c, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x69, 0x76, 0x6f, 0x74, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x50, 0x69, 0x76, 0x6f, - 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x44, 0x65, 0x6c, 0x74, 0x61, - 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x61, 0x66, 0x22, 0xca, 0x01, 0x0a, - 0x0d, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x44, - 0x0a, 0x0b, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x69, 0x64, 0x18, 0x01, 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, 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x50, 0x61, - 0x67, 0x65, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, - 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x6c, - 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6c, 0x65, 0x6d, 0x65, - 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, - 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, - 0x74, 0x72, 0x65, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0a, 0x74, 0x72, 0x65, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x0a, 0x0a, - 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xca, 0x01, 0x0a, 0x07, 0x43, 0x53, - 0x56, 0x44, 0x61, 0x74, 0x61, 0x12, 0x39, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, - 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, - 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, - 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, - 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, - 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x22, 0x43, 0x0a, 0x0a, 0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63, - 0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, - 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x0a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0xe3, 0x02, 0x0a, 0x09, - 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x65, 0x61, - 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x68, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, 0x19, 0x0a, 0x08, - 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x6e, 0x65, 0x77, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, - 0x61, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, - 0x68, 0x61, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, - 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, - 0x68, 0x61, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x27, 0x0a, - 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, - 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, - 0x6c, 0x5f, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x10, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x53, 0x65, 0x70, 0x61, 0x72, 0x61, - 0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x18, - 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, - 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, - 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x50, 0x61, 0x74, 0x68, - 0x12, 0x41, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, - 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x49, 0x64, - 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, - 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, - 0x79, 0x70, 0x65, 0x73, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, - 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, - 0x12, 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, 0x89, 0x06, 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, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x73, - 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, - 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, - 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, - 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x39, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, - 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x66, - 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 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, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, - 0x00, 0x52, 0x09, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, - 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 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, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, - 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x06, 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, 0x49, - 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, - 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x65, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x65, 0x6c, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, + 0x64, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65, + 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 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, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x09, 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, 0x4d, + 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69, + 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63, + 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 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, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, + 0x65, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x45, 0x0a, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x0b, 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, 0x42, 0x6f, 0x6f, + 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c, + 0x65, 0x61, 0x6e, 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, 0xd1, 0x04, 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, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, - 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, - 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 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, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, - 0x00, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x45, 0x0a, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x09, 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, 0x4d, 0x69, 0x73, 0x73, - 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69, 0x73, 0x73, 0x69, - 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, - 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 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, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, - 0x52, 0x0b, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, - 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0b, 0x20, + 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, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, - 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, - 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, - 0xd1, 0x04, 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, 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, + 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, 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 ( @@ -5126,7 +5125,7 @@ var file_relationalai_lqp_v1_logic_proto_goTypes = []any{ (*Var)(nil), // 35: relationalai.lqp.v1.Var (*Attribute)(nil), // 36: relationalai.lqp.v1.Attribute (*Data)(nil), // 37: relationalai.lqp.v1.Data - (*RelEDB)(nil), // 38: relationalai.lqp.v1.RelEDB + (*EDB)(nil), // 38: relationalai.lqp.v1.EDB (*BeTreeRelation)(nil), // 39: relationalai.lqp.v1.BeTreeRelation (*BeTreeInfo)(nil), // 40: relationalai.lqp.v1.BeTreeInfo (*BeTreeConfig)(nil), // 41: relationalai.lqp.v1.BeTreeConfig @@ -5134,7 +5133,7 @@ var file_relationalai_lqp_v1_logic_proto_goTypes = []any{ (*CSVData)(nil), // 43: relationalai.lqp.v1.CSVData (*CSVLocator)(nil), // 44: relationalai.lqp.v1.CSVLocator (*CSVConfig)(nil), // 45: relationalai.lqp.v1.CSVConfig - (*CSVColumn)(nil), // 46: relationalai.lqp.v1.CSVColumn + (*GNFColumn)(nil), // 46: relationalai.lqp.v1.GNFColumn (*RelationId)(nil), // 47: relationalai.lqp.v1.RelationId (*Type)(nil), // 48: relationalai.lqp.v1.Type (*UnspecifiedType)(nil), // 49: relationalai.lqp.v1.UnspecifiedType @@ -5241,11 +5240,11 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 35, // 81: relationalai.lqp.v1.Term.var:type_name -> relationalai.lqp.v1.Var 60, // 82: relationalai.lqp.v1.Term.constant:type_name -> relationalai.lqp.v1.Value 60, // 83: relationalai.lqp.v1.Attribute.args:type_name -> relationalai.lqp.v1.Value - 38, // 84: relationalai.lqp.v1.Data.rel_edb:type_name -> relationalai.lqp.v1.RelEDB + 38, // 84: relationalai.lqp.v1.Data.edb:type_name -> relationalai.lqp.v1.EDB 39, // 85: relationalai.lqp.v1.Data.betree_relation:type_name -> relationalai.lqp.v1.BeTreeRelation 43, // 86: relationalai.lqp.v1.Data.csv_data:type_name -> relationalai.lqp.v1.CSVData - 47, // 87: relationalai.lqp.v1.RelEDB.target_id:type_name -> relationalai.lqp.v1.RelationId - 48, // 88: relationalai.lqp.v1.RelEDB.types:type_name -> relationalai.lqp.v1.Type + 47, // 87: relationalai.lqp.v1.EDB.target_id:type_name -> relationalai.lqp.v1.RelationId + 48, // 88: relationalai.lqp.v1.EDB.types:type_name -> relationalai.lqp.v1.Type 47, // 89: relationalai.lqp.v1.BeTreeRelation.name:type_name -> relationalai.lqp.v1.RelationId 40, // 90: relationalai.lqp.v1.BeTreeRelation.relation_info:type_name -> relationalai.lqp.v1.BeTreeInfo 48, // 91: relationalai.lqp.v1.BeTreeInfo.key_types:type_name -> relationalai.lqp.v1.Type @@ -5255,9 +5254,9 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 61, // 95: relationalai.lqp.v1.BeTreeLocator.root_pageid:type_name -> relationalai.lqp.v1.UInt128Value 44, // 96: relationalai.lqp.v1.CSVData.locator:type_name -> relationalai.lqp.v1.CSVLocator 45, // 97: relationalai.lqp.v1.CSVData.config:type_name -> relationalai.lqp.v1.CSVConfig - 46, // 98: relationalai.lqp.v1.CSVData.columns:type_name -> relationalai.lqp.v1.CSVColumn - 47, // 99: relationalai.lqp.v1.CSVColumn.target_id:type_name -> relationalai.lqp.v1.RelationId - 48, // 100: relationalai.lqp.v1.CSVColumn.types:type_name -> relationalai.lqp.v1.Type + 46, // 98: relationalai.lqp.v1.CSVData.columns:type_name -> relationalai.lqp.v1.GNFColumn + 47, // 99: relationalai.lqp.v1.GNFColumn.target_id:type_name -> relationalai.lqp.v1.RelationId + 48, // 100: relationalai.lqp.v1.GNFColumn.types:type_name -> relationalai.lqp.v1.Type 49, // 101: relationalai.lqp.v1.Type.unspecified_type:type_name -> relationalai.lqp.v1.UnspecifiedType 50, // 102: relationalai.lqp.v1.Type.string_type:type_name -> relationalai.lqp.v1.StringType 51, // 103: relationalai.lqp.v1.Type.int_type:type_name -> relationalai.lqp.v1.IntType @@ -5336,7 +5335,7 @@ func file_relationalai_lqp_v1_logic_proto_init() { (*Term_Constant)(nil), } file_relationalai_lqp_v1_logic_proto_msgTypes[37].OneofWrappers = []any{ - (*Data_RelEdb)(nil), + (*Data_Edb)(nil), (*Data_BetreeRelation)(nil), (*Data_CsvData)(nil), } diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index 1b15522d..7589f230 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -572,7 +572,7 @@ func (x *Context) GetRelations() []*RelationId { } // Demand the source IDB, take an immutable snapshot, and turn it into an EDB under the -// given path (specified as a sequence of strings, see RelEDB). +// given path (specified as a sequence of strings, see EDB). type Snapshot struct { state protoimpl.MessageState `protogen:"open.v1"` DestinationPath []string `protobuf:"bytes,1,rep,name=destination_path,json=destinationPath,proto3" json:"destination_path,omitempty"` diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index ad58a496..4163fa1e 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -524,150 +524,150 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t1359 interface{} + var _t1340 interface{} if (value != nil && hasProtoField(value, "int_value")) { return int32(value.GetIntValue()) } - _ = _t1359 + _ = _t1340 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t1360 interface{} + var _t1341 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t1360 + _ = _t1341 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t1361 interface{} + var _t1342 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t1361 + _ = _t1342 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t1362 interface{} + var _t1343 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t1362 + _ = _t1343 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t1363 interface{} + var _t1344 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t1363 + _ = _t1344 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t1364 interface{} + var _t1345 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t1364 + _ = _t1345 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t1365 interface{} + var _t1346 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t1365 + _ = _t1346 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t1366 interface{} + var _t1347 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t1366 + _ = _t1347 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t1367 interface{} + var _t1348 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t1367 + _ = _t1348 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t1368 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t1368 - _t1369 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t1369 - _t1370 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t1370 - _t1371 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t1371 - _t1372 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t1372 - _t1373 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t1373 - _t1374 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t1374 - _t1375 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t1375 - _t1376 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t1376 - _t1377 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t1377 - _t1378 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") - compression := _t1378 - _t1379 := &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} - return _t1379 + _t1349 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t1349 + _t1350 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t1350 + _t1351 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t1351 + _t1352 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t1352 + _t1353 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t1353 + _t1354 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t1354 + _t1355 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t1355 + _t1356 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t1356 + _t1357 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t1357 + _t1358 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t1358 + _t1359 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") + compression := _t1359 + _t1360 := &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} + return _t1360 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t1380 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t1380 - _t1381 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t1381 - _t1382 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t1382 - _t1383 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t1383 - _t1384 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t1384 - _t1385 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t1385 - _t1386 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t1386 - _t1387 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t1387 - _t1388 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t1388 - _t1389 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t1361 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t1361 + _t1362 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t1362 + _t1363 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t1363 + _t1364 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t1364 + _t1365 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t1365 + _t1366 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t1366 + _t1367 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t1367 + _t1368 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t1368 + _t1369 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t1369 + _t1370 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t1389.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t1370.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t1389.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t1370.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t1389 - _t1390 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t1390 + relation_locator := _t1370 + _t1371 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t1371 } func (p *Parser) default_configure() *pb.Configure { - _t1391 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t1391 - _t1392 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t1392 + _t1372 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t1372 + _t1373 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t1373 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -689,44 +689,32 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t1393 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t1393 - _t1394 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t1394 - _t1395 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t1395 + _t1374 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t1374 + _t1375 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t1375 + _t1376 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t1376 } func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t1396 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t1396 - _t1397 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t1397 - _t1398 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t1398 - _t1399 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t1399 - _t1400 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t1400 - _t1401 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t1401 - _t1402 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t1402 - _t1403 := &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 _t1403 -} - -func (p *Parser) construct_csv_column(path []string, tail []interface{}) *pb.CSVColumn { - var _t1404 interface{} - if tail != nil { - t := tail - _t1405 := &pb.CSVColumn{ColumnPath: path, TargetId: t[0].(*pb.RelationId), Types: t[1].([]*pb.Type)} - return _t1405 - } - _ = _t1404 - _t1406 := &pb.CSVColumn{ColumnPath: path, TargetId: nil, Types: []*pb.Type{}} - return _t1406 + _t1377 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t1377 + _t1378 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t1378 + _t1379 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t1379 + _t1380 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t1380 + _t1381 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t1381 + _t1382 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t1382 + _t1383 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t1383 + _t1384 := &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 _t1384 } // --- Parse functions --- @@ -734,3116 +722,3068 @@ func (p *Parser) construct_csv_column(path []string, tail []interface{}) *pb.CSV func (p *Parser) parse_transaction() *pb.Transaction { p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t736 *pb.Configure + var _t724 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t737 := p.parse_configure() - _t736 = _t737 + _t725 := p.parse_configure() + _t724 = _t725 } - configure368 := _t736 - var _t738 *pb.Sync + configure362 := _t724 + var _t726 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t739 := p.parse_sync() - _t738 = _t739 + _t727 := p.parse_sync() + _t726 = _t727 } - sync369 := _t738 - xs370 := []*pb.Epoch{} - cond371 := p.matchLookaheadLiteral("(", 0) - for cond371 { - _t740 := p.parse_epoch() - item372 := _t740 - xs370 = append(xs370, item372) - cond371 = p.matchLookaheadLiteral("(", 0) + sync363 := _t726 + xs364 := []*pb.Epoch{} + cond365 := p.matchLookaheadLiteral("(", 0) + for cond365 { + _t728 := p.parse_epoch() + item366 := _t728 + xs364 = append(xs364, item366) + cond365 = p.matchLookaheadLiteral("(", 0) } - epochs373 := xs370 + epochs367 := xs364 p.consumeLiteral(")") - _t741 := p.default_configure() - _t742 := configure368 - if configure368 == nil { - _t742 = _t741 + _t729 := p.default_configure() + _t730 := configure362 + if configure362 == nil { + _t730 = _t729 } - _t743 := &pb.Transaction{Epochs: epochs373, Configure: _t742, Sync: sync369} - return _t743 + _t731 := &pb.Transaction{Epochs: epochs367, Configure: _t730, Sync: sync363} + return _t731 } func (p *Parser) parse_configure() *pb.Configure { p.consumeLiteral("(") p.consumeLiteral("configure") - _t744 := p.parse_config_dict() - config_dict374 := _t744 + _t732 := p.parse_config_dict() + config_dict368 := _t732 p.consumeLiteral(")") - _t745 := p.construct_configure(config_dict374) - return _t745 + _t733 := p.construct_configure(config_dict368) + return _t733 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs375 := [][]interface{}{} - cond376 := p.matchLookaheadLiteral(":", 0) - for cond376 { - _t746 := p.parse_config_key_value() - item377 := _t746 - xs375 = append(xs375, item377) - cond376 = p.matchLookaheadLiteral(":", 0) - } - config_key_values378 := xs375 + xs369 := [][]interface{}{} + cond370 := p.matchLookaheadLiteral(":", 0) + for cond370 { + _t734 := p.parse_config_key_value() + item371 := _t734 + xs369 = append(xs369, item371) + cond370 = p.matchLookaheadLiteral(":", 0) + } + config_key_values372 := xs369 p.consumeLiteral("}") - return config_key_values378 + return config_key_values372 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol379 := p.consumeTerminal("SYMBOL").Value.str - _t747 := p.parse_value() - value380 := _t747 - return []interface{}{symbol379, value380} + symbol373 := p.consumeTerminal("SYMBOL").Value.str + _t735 := p.parse_value() + value374 := _t735 + return []interface{}{symbol373, value374} } func (p *Parser) parse_value() *pb.Value { - var _t748 int64 + var _t736 int64 if p.matchLookaheadLiteral("true", 0) { - _t748 = 9 + _t736 = 9 } else { - var _t749 int64 + var _t737 int64 if p.matchLookaheadLiteral("missing", 0) { - _t749 = 8 + _t737 = 8 } else { - var _t750 int64 + var _t738 int64 if p.matchLookaheadLiteral("false", 0) { - _t750 = 9 + _t738 = 9 } else { - var _t751 int64 + var _t739 int64 if p.matchLookaheadLiteral("(", 0) { - var _t752 int64 + var _t740 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t752 = 1 + _t740 = 1 } else { - var _t753 int64 + var _t741 int64 if p.matchLookaheadLiteral("date", 1) { - _t753 = 0 + _t741 = 0 } else { - _t753 = -1 + _t741 = -1 } - _t752 = _t753 + _t740 = _t741 } - _t751 = _t752 + _t739 = _t740 } else { - var _t754 int64 + var _t742 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t754 = 5 + _t742 = 5 } else { - var _t755 int64 + var _t743 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t755 = 2 + _t743 = 2 } else { - var _t756 int64 + var _t744 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t756 = 6 + _t744 = 6 } else { - var _t757 int64 + var _t745 int64 if p.matchLookaheadTerminal("INT", 0) { - _t757 = 3 + _t745 = 3 } else { - var _t758 int64 + var _t746 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t758 = 4 + _t746 = 4 } else { - var _t759 int64 + var _t747 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t759 = 7 + _t747 = 7 } else { - _t759 = -1 + _t747 = -1 } - _t758 = _t759 + _t746 = _t747 } - _t757 = _t758 + _t745 = _t746 } - _t756 = _t757 + _t744 = _t745 } - _t755 = _t756 + _t743 = _t744 } - _t754 = _t755 + _t742 = _t743 } - _t751 = _t754 + _t739 = _t742 } - _t750 = _t751 + _t738 = _t739 } - _t749 = _t750 + _t737 = _t738 } - _t748 = _t749 - } - prediction381 := _t748 - var _t760 *pb.Value - if prediction381 == 9 { - _t761 := p.parse_boolean_value() - boolean_value390 := _t761 - _t762 := &pb.Value{} - _t762.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value390} - _t760 = _t762 + _t736 = _t737 + } + prediction375 := _t736 + var _t748 *pb.Value + if prediction375 == 9 { + _t749 := p.parse_boolean_value() + boolean_value384 := _t749 + _t750 := &pb.Value{} + _t750.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value384} + _t748 = _t750 } else { - var _t763 *pb.Value - if prediction381 == 8 { + var _t751 *pb.Value + if prediction375 == 8 { p.consumeLiteral("missing") - _t764 := &pb.MissingValue{} - _t765 := &pb.Value{} - _t765.Value = &pb.Value_MissingValue{MissingValue: _t764} - _t763 = _t765 + _t752 := &pb.MissingValue{} + _t753 := &pb.Value{} + _t753.Value = &pb.Value_MissingValue{MissingValue: _t752} + _t751 = _t753 } else { - var _t766 *pb.Value - if prediction381 == 7 { - decimal389 := p.consumeTerminal("DECIMAL").Value.decimal - _t767 := &pb.Value{} - _t767.Value = &pb.Value_DecimalValue{DecimalValue: decimal389} - _t766 = _t767 + var _t754 *pb.Value + if prediction375 == 7 { + decimal383 := p.consumeTerminal("DECIMAL").Value.decimal + _t755 := &pb.Value{} + _t755.Value = &pb.Value_DecimalValue{DecimalValue: decimal383} + _t754 = _t755 } else { - var _t768 *pb.Value - if prediction381 == 6 { - int128388 := p.consumeTerminal("INT128").Value.int128 - _t769 := &pb.Value{} - _t769.Value = &pb.Value_Int128Value{Int128Value: int128388} - _t768 = _t769 + var _t756 *pb.Value + if prediction375 == 6 { + int128382 := p.consumeTerminal("INT128").Value.int128 + _t757 := &pb.Value{} + _t757.Value = &pb.Value_Int128Value{Int128Value: int128382} + _t756 = _t757 } else { - var _t770 *pb.Value - if prediction381 == 5 { - uint128387 := p.consumeTerminal("UINT128").Value.uint128 - _t771 := &pb.Value{} - _t771.Value = &pb.Value_Uint128Value{Uint128Value: uint128387} - _t770 = _t771 + var _t758 *pb.Value + if prediction375 == 5 { + uint128381 := p.consumeTerminal("UINT128").Value.uint128 + _t759 := &pb.Value{} + _t759.Value = &pb.Value_Uint128Value{Uint128Value: uint128381} + _t758 = _t759 } else { - var _t772 *pb.Value - if prediction381 == 4 { - float386 := p.consumeTerminal("FLOAT").Value.f64 - _t773 := &pb.Value{} - _t773.Value = &pb.Value_FloatValue{FloatValue: float386} - _t772 = _t773 + var _t760 *pb.Value + if prediction375 == 4 { + float380 := p.consumeTerminal("FLOAT").Value.f64 + _t761 := &pb.Value{} + _t761.Value = &pb.Value_FloatValue{FloatValue: float380} + _t760 = _t761 } else { - var _t774 *pb.Value - if prediction381 == 3 { - int385 := p.consumeTerminal("INT").Value.i64 - _t775 := &pb.Value{} - _t775.Value = &pb.Value_IntValue{IntValue: int385} - _t774 = _t775 + var _t762 *pb.Value + if prediction375 == 3 { + int379 := p.consumeTerminal("INT").Value.i64 + _t763 := &pb.Value{} + _t763.Value = &pb.Value_IntValue{IntValue: int379} + _t762 = _t763 } else { - var _t776 *pb.Value - if prediction381 == 2 { - string384 := p.consumeTerminal("STRING").Value.str - _t777 := &pb.Value{} - _t777.Value = &pb.Value_StringValue{StringValue: string384} - _t776 = _t777 + var _t764 *pb.Value + if prediction375 == 2 { + string378 := p.consumeTerminal("STRING").Value.str + _t765 := &pb.Value{} + _t765.Value = &pb.Value_StringValue{StringValue: string378} + _t764 = _t765 } else { - var _t778 *pb.Value - if prediction381 == 1 { - _t779 := p.parse_datetime() - datetime383 := _t779 - _t780 := &pb.Value{} - _t780.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime383} - _t778 = _t780 + var _t766 *pb.Value + if prediction375 == 1 { + _t767 := p.parse_datetime() + datetime377 := _t767 + _t768 := &pb.Value{} + _t768.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime377} + _t766 = _t768 } else { - var _t781 *pb.Value - if prediction381 == 0 { - _t782 := p.parse_date() - date382 := _t782 - _t783 := &pb.Value{} - _t783.Value = &pb.Value_DateValue{DateValue: date382} - _t781 = _t783 + var _t769 *pb.Value + if prediction375 == 0 { + _t770 := p.parse_date() + date376 := _t770 + _t771 := &pb.Value{} + _t771.Value = &pb.Value_DateValue{DateValue: date376} + _t769 = _t771 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t778 = _t781 + _t766 = _t769 } - _t776 = _t778 + _t764 = _t766 } - _t774 = _t776 + _t762 = _t764 } - _t772 = _t774 + _t760 = _t762 } - _t770 = _t772 + _t758 = _t760 } - _t768 = _t770 + _t756 = _t758 } - _t766 = _t768 + _t754 = _t756 } - _t763 = _t766 + _t751 = _t754 } - _t760 = _t763 + _t748 = _t751 } - return _t760 + return _t748 } func (p *Parser) parse_date() *pb.DateValue { p.consumeLiteral("(") p.consumeLiteral("date") - int391 := p.consumeTerminal("INT").Value.i64 - int_3392 := p.consumeTerminal("INT").Value.i64 - int_4393 := p.consumeTerminal("INT").Value.i64 + int385 := p.consumeTerminal("INT").Value.i64 + int_3386 := p.consumeTerminal("INT").Value.i64 + int_4387 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t784 := &pb.DateValue{Year: int32(int391), Month: int32(int_3392), Day: int32(int_4393)} - return _t784 + _t772 := &pb.DateValue{Year: int32(int385), Month: int32(int_3386), Day: int32(int_4387)} + return _t772 } func (p *Parser) parse_datetime() *pb.DateTimeValue { p.consumeLiteral("(") p.consumeLiteral("datetime") - int394 := p.consumeTerminal("INT").Value.i64 - int_3395 := p.consumeTerminal("INT").Value.i64 - int_4396 := p.consumeTerminal("INT").Value.i64 - int_5397 := p.consumeTerminal("INT").Value.i64 - int_6398 := p.consumeTerminal("INT").Value.i64 - int_7399 := p.consumeTerminal("INT").Value.i64 - var _t785 *int64 + int388 := p.consumeTerminal("INT").Value.i64 + int_3389 := p.consumeTerminal("INT").Value.i64 + int_4390 := p.consumeTerminal("INT").Value.i64 + int_5391 := p.consumeTerminal("INT").Value.i64 + int_6392 := p.consumeTerminal("INT").Value.i64 + int_7393 := p.consumeTerminal("INT").Value.i64 + var _t773 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t785 = ptr(p.consumeTerminal("INT").Value.i64) + _t773 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8400 := _t785 + int_8394 := _t773 p.consumeLiteral(")") - _t786 := &pb.DateTimeValue{Year: int32(int394), Month: int32(int_3395), Day: int32(int_4396), Hour: int32(int_5397), Minute: int32(int_6398), Second: int32(int_7399), Microsecond: int32(deref(int_8400, 0))} - return _t786 + _t774 := &pb.DateTimeValue{Year: int32(int388), Month: int32(int_3389), Day: int32(int_4390), Hour: int32(int_5391), Minute: int32(int_6392), Second: int32(int_7393), Microsecond: int32(deref(int_8394, 0))} + return _t774 } func (p *Parser) parse_boolean_value() bool { - var _t787 int64 + var _t775 int64 if p.matchLookaheadLiteral("true", 0) { - _t787 = 0 + _t775 = 0 } else { - var _t788 int64 + var _t776 int64 if p.matchLookaheadLiteral("false", 0) { - _t788 = 1 + _t776 = 1 } else { - _t788 = -1 + _t776 = -1 } - _t787 = _t788 + _t775 = _t776 } - prediction401 := _t787 - var _t789 bool - if prediction401 == 1 { + prediction395 := _t775 + var _t777 bool + if prediction395 == 1 { p.consumeLiteral("false") - _t789 = false + _t777 = false } else { - var _t790 bool - if prediction401 == 0 { + var _t778 bool + if prediction395 == 0 { p.consumeLiteral("true") - _t790 = true + _t778 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t789 = _t790 + _t777 = _t778 } - return _t789 + return _t777 } func (p *Parser) parse_sync() *pb.Sync { p.consumeLiteral("(") p.consumeLiteral("sync") - xs402 := []*pb.FragmentId{} - cond403 := p.matchLookaheadLiteral(":", 0) - for cond403 { - _t791 := p.parse_fragment_id() - item404 := _t791 - xs402 = append(xs402, item404) - cond403 = p.matchLookaheadLiteral(":", 0) + xs396 := []*pb.FragmentId{} + cond397 := p.matchLookaheadLiteral(":", 0) + for cond397 { + _t779 := p.parse_fragment_id() + item398 := _t779 + xs396 = append(xs396, item398) + cond397 = p.matchLookaheadLiteral(":", 0) } - fragment_ids405 := xs402 + fragment_ids399 := xs396 p.consumeLiteral(")") - _t792 := &pb.Sync{Fragments: fragment_ids405} - return _t792 + _t780 := &pb.Sync{Fragments: fragment_ids399} + return _t780 } func (p *Parser) parse_fragment_id() *pb.FragmentId { p.consumeLiteral(":") - symbol406 := p.consumeTerminal("SYMBOL").Value.str - return &pb.FragmentId{Id: []byte(symbol406)} + symbol400 := p.consumeTerminal("SYMBOL").Value.str + return &pb.FragmentId{Id: []byte(symbol400)} } func (p *Parser) parse_epoch() *pb.Epoch { p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t793 []*pb.Write + var _t781 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t794 := p.parse_epoch_writes() - _t793 = _t794 + _t782 := p.parse_epoch_writes() + _t781 = _t782 } - epoch_writes407 := _t793 - var _t795 []*pb.Read + epoch_writes401 := _t781 + var _t783 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t796 := p.parse_epoch_reads() - _t795 = _t796 + _t784 := p.parse_epoch_reads() + _t783 = _t784 } - epoch_reads408 := _t795 + epoch_reads402 := _t783 p.consumeLiteral(")") - _t797 := epoch_writes407 - if epoch_writes407 == nil { - _t797 = []*pb.Write{} + _t785 := epoch_writes401 + if epoch_writes401 == nil { + _t785 = []*pb.Write{} } - _t798 := epoch_reads408 - if epoch_reads408 == nil { - _t798 = []*pb.Read{} + _t786 := epoch_reads402 + if epoch_reads402 == nil { + _t786 = []*pb.Read{} } - _t799 := &pb.Epoch{Writes: _t797, Reads: _t798} - return _t799 + _t787 := &pb.Epoch{Writes: _t785, Reads: _t786} + return _t787 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs409 := []*pb.Write{} - cond410 := p.matchLookaheadLiteral("(", 0) - for cond410 { - _t800 := p.parse_write() - item411 := _t800 - xs409 = append(xs409, item411) - cond410 = p.matchLookaheadLiteral("(", 0) + xs403 := []*pb.Write{} + cond404 := p.matchLookaheadLiteral("(", 0) + for cond404 { + _t788 := p.parse_write() + item405 := _t788 + xs403 = append(xs403, item405) + cond404 = p.matchLookaheadLiteral("(", 0) } - writes412 := xs409 + writes406 := xs403 p.consumeLiteral(")") - return writes412 + return writes406 } func (p *Parser) parse_write() *pb.Write { - var _t801 int64 + var _t789 int64 if p.matchLookaheadLiteral("(", 0) { - var _t802 int64 + var _t790 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t802 = 1 + _t790 = 1 } else { - var _t803 int64 + var _t791 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t803 = 3 + _t791 = 3 } else { - var _t804 int64 + var _t792 int64 if p.matchLookaheadLiteral("define", 1) { - _t804 = 0 + _t792 = 0 } else { - var _t805 int64 + var _t793 int64 if p.matchLookaheadLiteral("context", 1) { - _t805 = 2 + _t793 = 2 } else { - _t805 = -1 + _t793 = -1 } - _t804 = _t805 + _t792 = _t793 } - _t803 = _t804 + _t791 = _t792 } - _t802 = _t803 + _t790 = _t791 } - _t801 = _t802 + _t789 = _t790 } else { - _t801 = -1 - } - prediction413 := _t801 - var _t806 *pb.Write - if prediction413 == 3 { - _t807 := p.parse_snapshot() - snapshot417 := _t807 - _t808 := &pb.Write{} - _t808.WriteType = &pb.Write_Snapshot{Snapshot: snapshot417} - _t806 = _t808 + _t789 = -1 + } + prediction407 := _t789 + var _t794 *pb.Write + if prediction407 == 3 { + _t795 := p.parse_snapshot() + snapshot411 := _t795 + _t796 := &pb.Write{} + _t796.WriteType = &pb.Write_Snapshot{Snapshot: snapshot411} + _t794 = _t796 } else { - var _t809 *pb.Write - if prediction413 == 2 { - _t810 := p.parse_context() - context416 := _t810 - _t811 := &pb.Write{} - _t811.WriteType = &pb.Write_Context{Context: context416} - _t809 = _t811 + var _t797 *pb.Write + if prediction407 == 2 { + _t798 := p.parse_context() + context410 := _t798 + _t799 := &pb.Write{} + _t799.WriteType = &pb.Write_Context{Context: context410} + _t797 = _t799 } else { - var _t812 *pb.Write - if prediction413 == 1 { - _t813 := p.parse_undefine() - undefine415 := _t813 - _t814 := &pb.Write{} - _t814.WriteType = &pb.Write_Undefine{Undefine: undefine415} - _t812 = _t814 + var _t800 *pb.Write + if prediction407 == 1 { + _t801 := p.parse_undefine() + undefine409 := _t801 + _t802 := &pb.Write{} + _t802.WriteType = &pb.Write_Undefine{Undefine: undefine409} + _t800 = _t802 } else { - var _t815 *pb.Write - if prediction413 == 0 { - _t816 := p.parse_define() - define414 := _t816 - _t817 := &pb.Write{} - _t817.WriteType = &pb.Write_Define{Define: define414} - _t815 = _t817 + var _t803 *pb.Write + if prediction407 == 0 { + _t804 := p.parse_define() + define408 := _t804 + _t805 := &pb.Write{} + _t805.WriteType = &pb.Write_Define{Define: define408} + _t803 = _t805 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t812 = _t815 + _t800 = _t803 } - _t809 = _t812 + _t797 = _t800 } - _t806 = _t809 + _t794 = _t797 } - return _t806 + return _t794 } func (p *Parser) parse_define() *pb.Define { p.consumeLiteral("(") p.consumeLiteral("define") - _t818 := p.parse_fragment() - fragment418 := _t818 + _t806 := p.parse_fragment() + fragment412 := _t806 p.consumeLiteral(")") - _t819 := &pb.Define{Fragment: fragment418} - return _t819 + _t807 := &pb.Define{Fragment: fragment412} + return _t807 } func (p *Parser) parse_fragment() *pb.Fragment { p.consumeLiteral("(") p.consumeLiteral("fragment") - _t820 := p.parse_new_fragment_id() - new_fragment_id419 := _t820 - xs420 := []*pb.Declaration{} - cond421 := p.matchLookaheadLiteral("(", 0) - for cond421 { - _t821 := p.parse_declaration() - item422 := _t821 - xs420 = append(xs420, item422) - cond421 = p.matchLookaheadLiteral("(", 0) + _t808 := p.parse_new_fragment_id() + new_fragment_id413 := _t808 + xs414 := []*pb.Declaration{} + cond415 := p.matchLookaheadLiteral("(", 0) + for cond415 { + _t809 := p.parse_declaration() + item416 := _t809 + xs414 = append(xs414, item416) + cond415 = p.matchLookaheadLiteral("(", 0) } - declarations423 := xs420 + declarations417 := xs414 p.consumeLiteral(")") - return p.constructFragment(new_fragment_id419, declarations423) + return p.constructFragment(new_fragment_id413, declarations417) } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - _t822 := p.parse_fragment_id() - fragment_id424 := _t822 - p.startFragment(fragment_id424) - return fragment_id424 + _t810 := p.parse_fragment_id() + fragment_id418 := _t810 + p.startFragment(fragment_id418) + return fragment_id418 } func (p *Parser) parse_declaration() *pb.Declaration { - var _t823 int64 + var _t811 int64 if p.matchLookaheadLiteral("(", 0) { - var _t824 int64 - if p.matchLookaheadLiteral("rel_edb", 1) { - _t824 = 3 + var _t812 int64 + if p.matchLookaheadLiteral("functional_dependency", 1) { + _t812 = 2 } else { - var _t825 int64 - if p.matchLookaheadLiteral("functional_dependency", 1) { - _t825 = 2 + var _t813 int64 + if p.matchLookaheadLiteral("edb", 1) { + _t813 = 3 } else { - var _t826 int64 + var _t814 int64 if p.matchLookaheadLiteral("def", 1) { - _t826 = 0 + _t814 = 0 } else { - var _t827 int64 + var _t815 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t827 = 3 + _t815 = 3 } else { - var _t828 int64 + var _t816 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t828 = 3 + _t816 = 3 } else { - var _t829 int64 + var _t817 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t829 = 1 + _t817 = 1 } else { - _t829 = -1 + _t817 = -1 } - _t828 = _t829 + _t816 = _t817 } - _t827 = _t828 + _t815 = _t816 } - _t826 = _t827 + _t814 = _t815 } - _t825 = _t826 + _t813 = _t814 } - _t824 = _t825 + _t812 = _t813 } - _t823 = _t824 + _t811 = _t812 } else { - _t823 = -1 - } - prediction425 := _t823 - var _t830 *pb.Declaration - if prediction425 == 3 { - _t831 := p.parse_data() - data429 := _t831 - _t832 := &pb.Declaration{} - _t832.DeclarationType = &pb.Declaration_Data{Data: data429} - _t830 = _t832 + _t811 = -1 + } + prediction419 := _t811 + var _t818 *pb.Declaration + if prediction419 == 3 { + _t819 := p.parse_data() + data423 := _t819 + _t820 := &pb.Declaration{} + _t820.DeclarationType = &pb.Declaration_Data{Data: data423} + _t818 = _t820 } else { - var _t833 *pb.Declaration - if prediction425 == 2 { - _t834 := p.parse_constraint() - constraint428 := _t834 - _t835 := &pb.Declaration{} - _t835.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint428} - _t833 = _t835 + var _t821 *pb.Declaration + if prediction419 == 2 { + _t822 := p.parse_constraint() + constraint422 := _t822 + _t823 := &pb.Declaration{} + _t823.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint422} + _t821 = _t823 } else { - var _t836 *pb.Declaration - if prediction425 == 1 { - _t837 := p.parse_algorithm() - algorithm427 := _t837 - _t838 := &pb.Declaration{} - _t838.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm427} - _t836 = _t838 + var _t824 *pb.Declaration + if prediction419 == 1 { + _t825 := p.parse_algorithm() + algorithm421 := _t825 + _t826 := &pb.Declaration{} + _t826.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm421} + _t824 = _t826 } else { - var _t839 *pb.Declaration - if prediction425 == 0 { - _t840 := p.parse_def() - def426 := _t840 - _t841 := &pb.Declaration{} - _t841.DeclarationType = &pb.Declaration_Def{Def: def426} - _t839 = _t841 + var _t827 *pb.Declaration + if prediction419 == 0 { + _t828 := p.parse_def() + def420 := _t828 + _t829 := &pb.Declaration{} + _t829.DeclarationType = &pb.Declaration_Def{Def: def420} + _t827 = _t829 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t836 = _t839 + _t824 = _t827 } - _t833 = _t836 + _t821 = _t824 } - _t830 = _t833 + _t818 = _t821 } - return _t830 + return _t818 } func (p *Parser) parse_def() *pb.Def { p.consumeLiteral("(") p.consumeLiteral("def") - _t842 := p.parse_relation_id() - relation_id430 := _t842 - _t843 := p.parse_abstraction() - abstraction431 := _t843 - var _t844 []*pb.Attribute + _t830 := p.parse_relation_id() + relation_id424 := _t830 + _t831 := p.parse_abstraction() + abstraction425 := _t831 + var _t832 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t845 := p.parse_attrs() - _t844 = _t845 + _t833 := p.parse_attrs() + _t832 = _t833 } - attrs432 := _t844 + attrs426 := _t832 p.consumeLiteral(")") - _t846 := attrs432 - if attrs432 == nil { - _t846 = []*pb.Attribute{} + _t834 := attrs426 + if attrs426 == nil { + _t834 = []*pb.Attribute{} } - _t847 := &pb.Def{Name: relation_id430, Body: abstraction431, Attrs: _t846} - return _t847 + _t835 := &pb.Def{Name: relation_id424, Body: abstraction425, Attrs: _t834} + return _t835 } func (p *Parser) parse_relation_id() *pb.RelationId { - var _t848 int64 + var _t836 int64 if p.matchLookaheadLiteral(":", 0) { - _t848 = 0 + _t836 = 0 } else { - var _t849 int64 + var _t837 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t849 = 1 + _t837 = 1 } else { - _t849 = -1 + _t837 = -1 } - _t848 = _t849 - } - prediction433 := _t848 - var _t850 *pb.RelationId - if prediction433 == 1 { - uint128435 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128435 - _t850 = &pb.RelationId{IdLow: uint128435.Low, IdHigh: uint128435.High} + _t836 = _t837 + } + prediction427 := _t836 + var _t838 *pb.RelationId + if prediction427 == 1 { + uint128429 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128429 + _t838 = &pb.RelationId{IdLow: uint128429.Low, IdHigh: uint128429.High} } else { - var _t851 *pb.RelationId - if prediction433 == 0 { + var _t839 *pb.RelationId + if prediction427 == 0 { p.consumeLiteral(":") - symbol434 := p.consumeTerminal("SYMBOL").Value.str - _t851 = p.relationIdFromString(symbol434) + symbol428 := p.consumeTerminal("SYMBOL").Value.str + _t839 = p.relationIdFromString(symbol428) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t850 = _t851 + _t838 = _t839 } - return _t850 + return _t838 } func (p *Parser) parse_abstraction() *pb.Abstraction { p.consumeLiteral("(") - _t852 := p.parse_bindings() - bindings436 := _t852 - _t853 := p.parse_formula() - formula437 := _t853 + _t840 := p.parse_bindings() + bindings430 := _t840 + _t841 := p.parse_formula() + formula431 := _t841 p.consumeLiteral(")") - _t854 := &pb.Abstraction{Vars: listConcat(bindings436[0].([]*pb.Binding), bindings436[1].([]*pb.Binding)), Value: formula437} - return _t854 + _t842 := &pb.Abstraction{Vars: listConcat(bindings430[0].([]*pb.Binding), bindings430[1].([]*pb.Binding)), Value: formula431} + return _t842 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs438 := []*pb.Binding{} - cond439 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond439 { - _t855 := p.parse_binding() - item440 := _t855 - xs438 = append(xs438, item440) - cond439 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings441 := xs438 - var _t856 []*pb.Binding + xs432 := []*pb.Binding{} + cond433 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond433 { + _t843 := p.parse_binding() + item434 := _t843 + xs432 = append(xs432, item434) + cond433 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings435 := xs432 + var _t844 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t857 := p.parse_value_bindings() - _t856 = _t857 + _t845 := p.parse_value_bindings() + _t844 = _t845 } - value_bindings442 := _t856 + value_bindings436 := _t844 p.consumeLiteral("]") - _t858 := value_bindings442 - if value_bindings442 == nil { - _t858 = []*pb.Binding{} + _t846 := value_bindings436 + if value_bindings436 == nil { + _t846 = []*pb.Binding{} } - return []interface{}{bindings441, _t858} + return []interface{}{bindings435, _t846} } func (p *Parser) parse_binding() *pb.Binding { - symbol443 := p.consumeTerminal("SYMBOL").Value.str + symbol437 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t859 := p.parse_type() - type444 := _t859 - _t860 := &pb.Var{Name: symbol443} - _t861 := &pb.Binding{Var: _t860, Type: type444} - return _t861 + _t847 := p.parse_type() + type438 := _t847 + _t848 := &pb.Var{Name: symbol437} + _t849 := &pb.Binding{Var: _t848, Type: type438} + return _t849 } func (p *Parser) parse_type() *pb.Type { - var _t862 int64 + var _t850 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t862 = 0 + _t850 = 0 } else { - var _t863 int64 + var _t851 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t863 = 4 + _t851 = 4 } else { - var _t864 int64 + var _t852 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t864 = 1 + _t852 = 1 } else { - var _t865 int64 + var _t853 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t865 = 8 + _t853 = 8 } else { - var _t866 int64 + var _t854 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t866 = 5 + _t854 = 5 } else { - var _t867 int64 + var _t855 int64 if p.matchLookaheadLiteral("INT", 0) { - _t867 = 2 + _t855 = 2 } else { - var _t868 int64 + var _t856 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t868 = 3 + _t856 = 3 } else { - var _t869 int64 + var _t857 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t869 = 7 + _t857 = 7 } else { - var _t870 int64 + var _t858 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t870 = 6 + _t858 = 6 } else { - var _t871 int64 + var _t859 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t871 = 10 + _t859 = 10 } else { - var _t872 int64 + var _t860 int64 if p.matchLookaheadLiteral("(", 0) { - _t872 = 9 + _t860 = 9 } else { - _t872 = -1 + _t860 = -1 } - _t871 = _t872 + _t859 = _t860 } - _t870 = _t871 + _t858 = _t859 } - _t869 = _t870 + _t857 = _t858 } - _t868 = _t869 + _t856 = _t857 } - _t867 = _t868 + _t855 = _t856 } - _t866 = _t867 + _t854 = _t855 } - _t865 = _t866 + _t853 = _t854 } - _t864 = _t865 + _t852 = _t853 } - _t863 = _t864 + _t851 = _t852 } - _t862 = _t863 - } - prediction445 := _t862 - var _t873 *pb.Type - if prediction445 == 10 { - _t874 := p.parse_boolean_type() - boolean_type456 := _t874 - _t875 := &pb.Type{} - _t875.Type = &pb.Type_BooleanType{BooleanType: boolean_type456} - _t873 = _t875 + _t850 = _t851 + } + prediction439 := _t850 + var _t861 *pb.Type + if prediction439 == 10 { + _t862 := p.parse_boolean_type() + boolean_type450 := _t862 + _t863 := &pb.Type{} + _t863.Type = &pb.Type_BooleanType{BooleanType: boolean_type450} + _t861 = _t863 } else { - var _t876 *pb.Type - if prediction445 == 9 { - _t877 := p.parse_decimal_type() - decimal_type455 := _t877 - _t878 := &pb.Type{} - _t878.Type = &pb.Type_DecimalType{DecimalType: decimal_type455} - _t876 = _t878 + var _t864 *pb.Type + if prediction439 == 9 { + _t865 := p.parse_decimal_type() + decimal_type449 := _t865 + _t866 := &pb.Type{} + _t866.Type = &pb.Type_DecimalType{DecimalType: decimal_type449} + _t864 = _t866 } else { - var _t879 *pb.Type - if prediction445 == 8 { - _t880 := p.parse_missing_type() - missing_type454 := _t880 - _t881 := &pb.Type{} - _t881.Type = &pb.Type_MissingType{MissingType: missing_type454} - _t879 = _t881 + var _t867 *pb.Type + if prediction439 == 8 { + _t868 := p.parse_missing_type() + missing_type448 := _t868 + _t869 := &pb.Type{} + _t869.Type = &pb.Type_MissingType{MissingType: missing_type448} + _t867 = _t869 } else { - var _t882 *pb.Type - if prediction445 == 7 { - _t883 := p.parse_datetime_type() - datetime_type453 := _t883 - _t884 := &pb.Type{} - _t884.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type453} - _t882 = _t884 + var _t870 *pb.Type + if prediction439 == 7 { + _t871 := p.parse_datetime_type() + datetime_type447 := _t871 + _t872 := &pb.Type{} + _t872.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type447} + _t870 = _t872 } else { - var _t885 *pb.Type - if prediction445 == 6 { - _t886 := p.parse_date_type() - date_type452 := _t886 - _t887 := &pb.Type{} - _t887.Type = &pb.Type_DateType{DateType: date_type452} - _t885 = _t887 + var _t873 *pb.Type + if prediction439 == 6 { + _t874 := p.parse_date_type() + date_type446 := _t874 + _t875 := &pb.Type{} + _t875.Type = &pb.Type_DateType{DateType: date_type446} + _t873 = _t875 } else { - var _t888 *pb.Type - if prediction445 == 5 { - _t889 := p.parse_int128_type() - int128_type451 := _t889 - _t890 := &pb.Type{} - _t890.Type = &pb.Type_Int128Type{Int128Type: int128_type451} - _t888 = _t890 + var _t876 *pb.Type + if prediction439 == 5 { + _t877 := p.parse_int128_type() + int128_type445 := _t877 + _t878 := &pb.Type{} + _t878.Type = &pb.Type_Int128Type{Int128Type: int128_type445} + _t876 = _t878 } else { - var _t891 *pb.Type - if prediction445 == 4 { - _t892 := p.parse_uint128_type() - uint128_type450 := _t892 - _t893 := &pb.Type{} - _t893.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type450} - _t891 = _t893 + var _t879 *pb.Type + if prediction439 == 4 { + _t880 := p.parse_uint128_type() + uint128_type444 := _t880 + _t881 := &pb.Type{} + _t881.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type444} + _t879 = _t881 } else { - var _t894 *pb.Type - if prediction445 == 3 { - _t895 := p.parse_float_type() - float_type449 := _t895 - _t896 := &pb.Type{} - _t896.Type = &pb.Type_FloatType{FloatType: float_type449} - _t894 = _t896 + var _t882 *pb.Type + if prediction439 == 3 { + _t883 := p.parse_float_type() + float_type443 := _t883 + _t884 := &pb.Type{} + _t884.Type = &pb.Type_FloatType{FloatType: float_type443} + _t882 = _t884 } else { - var _t897 *pb.Type - if prediction445 == 2 { - _t898 := p.parse_int_type() - int_type448 := _t898 - _t899 := &pb.Type{} - _t899.Type = &pb.Type_IntType{IntType: int_type448} - _t897 = _t899 + var _t885 *pb.Type + if prediction439 == 2 { + _t886 := p.parse_int_type() + int_type442 := _t886 + _t887 := &pb.Type{} + _t887.Type = &pb.Type_IntType{IntType: int_type442} + _t885 = _t887 } else { - var _t900 *pb.Type - if prediction445 == 1 { - _t901 := p.parse_string_type() - string_type447 := _t901 - _t902 := &pb.Type{} - _t902.Type = &pb.Type_StringType{StringType: string_type447} - _t900 = _t902 + var _t888 *pb.Type + if prediction439 == 1 { + _t889 := p.parse_string_type() + string_type441 := _t889 + _t890 := &pb.Type{} + _t890.Type = &pb.Type_StringType{StringType: string_type441} + _t888 = _t890 } else { - var _t903 *pb.Type - if prediction445 == 0 { - _t904 := p.parse_unspecified_type() - unspecified_type446 := _t904 - _t905 := &pb.Type{} - _t905.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type446} - _t903 = _t905 + var _t891 *pb.Type + if prediction439 == 0 { + _t892 := p.parse_unspecified_type() + unspecified_type440 := _t892 + _t893 := &pb.Type{} + _t893.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type440} + _t891 = _t893 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t900 = _t903 + _t888 = _t891 } - _t897 = _t900 + _t885 = _t888 } - _t894 = _t897 + _t882 = _t885 } - _t891 = _t894 + _t879 = _t882 } - _t888 = _t891 + _t876 = _t879 } - _t885 = _t888 + _t873 = _t876 } - _t882 = _t885 + _t870 = _t873 } - _t879 = _t882 + _t867 = _t870 } - _t876 = _t879 + _t864 = _t867 } - _t873 = _t876 + _t861 = _t864 } - return _t873 + return _t861 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { p.consumeLiteral("UNKNOWN") - _t906 := &pb.UnspecifiedType{} - return _t906 + _t894 := &pb.UnspecifiedType{} + return _t894 } func (p *Parser) parse_string_type() *pb.StringType { p.consumeLiteral("STRING") - _t907 := &pb.StringType{} - return _t907 + _t895 := &pb.StringType{} + return _t895 } func (p *Parser) parse_int_type() *pb.IntType { p.consumeLiteral("INT") - _t908 := &pb.IntType{} - return _t908 + _t896 := &pb.IntType{} + return _t896 } func (p *Parser) parse_float_type() *pb.FloatType { p.consumeLiteral("FLOAT") - _t909 := &pb.FloatType{} - return _t909 + _t897 := &pb.FloatType{} + return _t897 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { p.consumeLiteral("UINT128") - _t910 := &pb.UInt128Type{} - return _t910 + _t898 := &pb.UInt128Type{} + return _t898 } func (p *Parser) parse_int128_type() *pb.Int128Type { p.consumeLiteral("INT128") - _t911 := &pb.Int128Type{} - return _t911 + _t899 := &pb.Int128Type{} + return _t899 } func (p *Parser) parse_date_type() *pb.DateType { p.consumeLiteral("DATE") - _t912 := &pb.DateType{} - return _t912 + _t900 := &pb.DateType{} + return _t900 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { p.consumeLiteral("DATETIME") - _t913 := &pb.DateTimeType{} - return _t913 + _t901 := &pb.DateTimeType{} + return _t901 } func (p *Parser) parse_missing_type() *pb.MissingType { p.consumeLiteral("MISSING") - _t914 := &pb.MissingType{} - return _t914 + _t902 := &pb.MissingType{} + return _t902 } func (p *Parser) parse_decimal_type() *pb.DecimalType { p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int457 := p.consumeTerminal("INT").Value.i64 - int_3458 := p.consumeTerminal("INT").Value.i64 + int451 := p.consumeTerminal("INT").Value.i64 + int_3452 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t915 := &pb.DecimalType{Precision: int32(int457), Scale: int32(int_3458)} - return _t915 + _t903 := &pb.DecimalType{Precision: int32(int451), Scale: int32(int_3452)} + return _t903 } func (p *Parser) parse_boolean_type() *pb.BooleanType { p.consumeLiteral("BOOLEAN") - _t916 := &pb.BooleanType{} - return _t916 + _t904 := &pb.BooleanType{} + return _t904 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs459 := []*pb.Binding{} - cond460 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond460 { - _t917 := p.parse_binding() - item461 := _t917 - xs459 = append(xs459, item461) - cond460 = p.matchLookaheadTerminal("SYMBOL", 0) + xs453 := []*pb.Binding{} + cond454 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond454 { + _t905 := p.parse_binding() + item455 := _t905 + xs453 = append(xs453, item455) + cond454 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings462 := xs459 - return bindings462 + bindings456 := xs453 + return bindings456 } func (p *Parser) parse_formula() *pb.Formula { - var _t918 int64 + var _t906 int64 if p.matchLookaheadLiteral("(", 0) { - var _t919 int64 + var _t907 int64 if p.matchLookaheadLiteral("true", 1) { - _t919 = 0 + _t907 = 0 } else { - var _t920 int64 + var _t908 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t920 = 11 + _t908 = 11 } else { - var _t921 int64 + var _t909 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t921 = 3 + _t909 = 3 } else { - var _t922 int64 + var _t910 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t922 = 10 + _t910 = 10 } else { - var _t923 int64 + var _t911 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t923 = 9 + _t911 = 9 } else { - var _t924 int64 + var _t912 int64 if p.matchLookaheadLiteral("or", 1) { - _t924 = 5 + _t912 = 5 } else { - var _t925 int64 + var _t913 int64 if p.matchLookaheadLiteral("not", 1) { - _t925 = 6 + _t913 = 6 } else { - var _t926 int64 + var _t914 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t926 = 7 + _t914 = 7 } else { - var _t927 int64 + var _t915 int64 if p.matchLookaheadLiteral("false", 1) { - _t927 = 1 + _t915 = 1 } else { - var _t928 int64 + var _t916 int64 if p.matchLookaheadLiteral("exists", 1) { - _t928 = 2 + _t916 = 2 } else { - var _t929 int64 + var _t917 int64 if p.matchLookaheadLiteral("cast", 1) { - _t929 = 12 + _t917 = 12 } else { - var _t930 int64 + var _t918 int64 if p.matchLookaheadLiteral("atom", 1) { - _t930 = 8 + _t918 = 8 } else { - var _t931 int64 + var _t919 int64 if p.matchLookaheadLiteral("and", 1) { - _t931 = 4 + _t919 = 4 } else { - var _t932 int64 + var _t920 int64 if p.matchLookaheadLiteral(">=", 1) { - _t932 = 10 + _t920 = 10 } else { - var _t933 int64 + var _t921 int64 if p.matchLookaheadLiteral(">", 1) { - _t933 = 10 + _t921 = 10 } else { - var _t934 int64 + var _t922 int64 if p.matchLookaheadLiteral("=", 1) { - _t934 = 10 + _t922 = 10 } else { - var _t935 int64 + var _t923 int64 if p.matchLookaheadLiteral("<=", 1) { - _t935 = 10 + _t923 = 10 } else { - var _t936 int64 + var _t924 int64 if p.matchLookaheadLiteral("<", 1) { - _t936 = 10 + _t924 = 10 } else { - var _t937 int64 + var _t925 int64 if p.matchLookaheadLiteral("/", 1) { - _t937 = 10 + _t925 = 10 } else { - var _t938 int64 + var _t926 int64 if p.matchLookaheadLiteral("-", 1) { - _t938 = 10 + _t926 = 10 } else { - var _t939 int64 + var _t927 int64 if p.matchLookaheadLiteral("+", 1) { - _t939 = 10 + _t927 = 10 } else { - var _t940 int64 + var _t928 int64 if p.matchLookaheadLiteral("*", 1) { - _t940 = 10 + _t928 = 10 } else { - _t940 = -1 + _t928 = -1 } - _t939 = _t940 + _t927 = _t928 } - _t938 = _t939 + _t926 = _t927 } - _t937 = _t938 + _t925 = _t926 } - _t936 = _t937 + _t924 = _t925 } - _t935 = _t936 + _t923 = _t924 } - _t934 = _t935 + _t922 = _t923 } - _t933 = _t934 + _t921 = _t922 } - _t932 = _t933 + _t920 = _t921 } - _t931 = _t932 + _t919 = _t920 } - _t930 = _t931 + _t918 = _t919 } - _t929 = _t930 + _t917 = _t918 } - _t928 = _t929 + _t916 = _t917 } - _t927 = _t928 + _t915 = _t916 } - _t926 = _t927 + _t914 = _t915 } - _t925 = _t926 + _t913 = _t914 } - _t924 = _t925 + _t912 = _t913 } - _t923 = _t924 + _t911 = _t912 } - _t922 = _t923 + _t910 = _t911 } - _t921 = _t922 + _t909 = _t910 } - _t920 = _t921 + _t908 = _t909 } - _t919 = _t920 + _t907 = _t908 } - _t918 = _t919 + _t906 = _t907 } else { - _t918 = -1 - } - prediction463 := _t918 - var _t941 *pb.Formula - if prediction463 == 12 { - _t942 := p.parse_cast() - cast476 := _t942 - _t943 := &pb.Formula{} - _t943.FormulaType = &pb.Formula_Cast{Cast: cast476} - _t941 = _t943 + _t906 = -1 + } + prediction457 := _t906 + var _t929 *pb.Formula + if prediction457 == 12 { + _t930 := p.parse_cast() + cast470 := _t930 + _t931 := &pb.Formula{} + _t931.FormulaType = &pb.Formula_Cast{Cast: cast470} + _t929 = _t931 } else { - var _t944 *pb.Formula - if prediction463 == 11 { - _t945 := p.parse_rel_atom() - rel_atom475 := _t945 - _t946 := &pb.Formula{} - _t946.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom475} - _t944 = _t946 + var _t932 *pb.Formula + if prediction457 == 11 { + _t933 := p.parse_rel_atom() + rel_atom469 := _t933 + _t934 := &pb.Formula{} + _t934.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom469} + _t932 = _t934 } else { - var _t947 *pb.Formula - if prediction463 == 10 { - _t948 := p.parse_primitive() - primitive474 := _t948 - _t949 := &pb.Formula{} - _t949.FormulaType = &pb.Formula_Primitive{Primitive: primitive474} - _t947 = _t949 + var _t935 *pb.Formula + if prediction457 == 10 { + _t936 := p.parse_primitive() + primitive468 := _t936 + _t937 := &pb.Formula{} + _t937.FormulaType = &pb.Formula_Primitive{Primitive: primitive468} + _t935 = _t937 } else { - var _t950 *pb.Formula - if prediction463 == 9 { - _t951 := p.parse_pragma() - pragma473 := _t951 - _t952 := &pb.Formula{} - _t952.FormulaType = &pb.Formula_Pragma{Pragma: pragma473} - _t950 = _t952 + var _t938 *pb.Formula + if prediction457 == 9 { + _t939 := p.parse_pragma() + pragma467 := _t939 + _t940 := &pb.Formula{} + _t940.FormulaType = &pb.Formula_Pragma{Pragma: pragma467} + _t938 = _t940 } else { - var _t953 *pb.Formula - if prediction463 == 8 { - _t954 := p.parse_atom() - atom472 := _t954 - _t955 := &pb.Formula{} - _t955.FormulaType = &pb.Formula_Atom{Atom: atom472} - _t953 = _t955 + var _t941 *pb.Formula + if prediction457 == 8 { + _t942 := p.parse_atom() + atom466 := _t942 + _t943 := &pb.Formula{} + _t943.FormulaType = &pb.Formula_Atom{Atom: atom466} + _t941 = _t943 } else { - var _t956 *pb.Formula - if prediction463 == 7 { - _t957 := p.parse_ffi() - ffi471 := _t957 - _t958 := &pb.Formula{} - _t958.FormulaType = &pb.Formula_Ffi{Ffi: ffi471} - _t956 = _t958 + var _t944 *pb.Formula + if prediction457 == 7 { + _t945 := p.parse_ffi() + ffi465 := _t945 + _t946 := &pb.Formula{} + _t946.FormulaType = &pb.Formula_Ffi{Ffi: ffi465} + _t944 = _t946 } else { - var _t959 *pb.Formula - if prediction463 == 6 { - _t960 := p.parse_not() - not470 := _t960 - _t961 := &pb.Formula{} - _t961.FormulaType = &pb.Formula_Not{Not: not470} - _t959 = _t961 + var _t947 *pb.Formula + if prediction457 == 6 { + _t948 := p.parse_not() + not464 := _t948 + _t949 := &pb.Formula{} + _t949.FormulaType = &pb.Formula_Not{Not: not464} + _t947 = _t949 } else { - var _t962 *pb.Formula - if prediction463 == 5 { - _t963 := p.parse_disjunction() - disjunction469 := _t963 - _t964 := &pb.Formula{} - _t964.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction469} - _t962 = _t964 + var _t950 *pb.Formula + if prediction457 == 5 { + _t951 := p.parse_disjunction() + disjunction463 := _t951 + _t952 := &pb.Formula{} + _t952.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction463} + _t950 = _t952 } else { - var _t965 *pb.Formula - if prediction463 == 4 { - _t966 := p.parse_conjunction() - conjunction468 := _t966 - _t967 := &pb.Formula{} - _t967.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction468} - _t965 = _t967 + var _t953 *pb.Formula + if prediction457 == 4 { + _t954 := p.parse_conjunction() + conjunction462 := _t954 + _t955 := &pb.Formula{} + _t955.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction462} + _t953 = _t955 } else { - var _t968 *pb.Formula - if prediction463 == 3 { - _t969 := p.parse_reduce() - reduce467 := _t969 - _t970 := &pb.Formula{} - _t970.FormulaType = &pb.Formula_Reduce{Reduce: reduce467} - _t968 = _t970 + var _t956 *pb.Formula + if prediction457 == 3 { + _t957 := p.parse_reduce() + reduce461 := _t957 + _t958 := &pb.Formula{} + _t958.FormulaType = &pb.Formula_Reduce{Reduce: reduce461} + _t956 = _t958 } else { - var _t971 *pb.Formula - if prediction463 == 2 { - _t972 := p.parse_exists() - exists466 := _t972 - _t973 := &pb.Formula{} - _t973.FormulaType = &pb.Formula_Exists{Exists: exists466} - _t971 = _t973 + var _t959 *pb.Formula + if prediction457 == 2 { + _t960 := p.parse_exists() + exists460 := _t960 + _t961 := &pb.Formula{} + _t961.FormulaType = &pb.Formula_Exists{Exists: exists460} + _t959 = _t961 } else { - var _t974 *pb.Formula - if prediction463 == 1 { - _t975 := p.parse_false() - false465 := _t975 - _t976 := &pb.Formula{} - _t976.FormulaType = &pb.Formula_Disjunction{Disjunction: false465} - _t974 = _t976 + var _t962 *pb.Formula + if prediction457 == 1 { + _t963 := p.parse_false() + false459 := _t963 + _t964 := &pb.Formula{} + _t964.FormulaType = &pb.Formula_Disjunction{Disjunction: false459} + _t962 = _t964 } else { - var _t977 *pb.Formula - if prediction463 == 0 { - _t978 := p.parse_true() - true464 := _t978 - _t979 := &pb.Formula{} - _t979.FormulaType = &pb.Formula_Conjunction{Conjunction: true464} - _t977 = _t979 + var _t965 *pb.Formula + if prediction457 == 0 { + _t966 := p.parse_true() + true458 := _t966 + _t967 := &pb.Formula{} + _t967.FormulaType = &pb.Formula_Conjunction{Conjunction: true458} + _t965 = _t967 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t974 = _t977 + _t962 = _t965 } - _t971 = _t974 + _t959 = _t962 } - _t968 = _t971 + _t956 = _t959 } - _t965 = _t968 + _t953 = _t956 } - _t962 = _t965 + _t950 = _t953 } - _t959 = _t962 + _t947 = _t950 } - _t956 = _t959 + _t944 = _t947 } - _t953 = _t956 + _t941 = _t944 } - _t950 = _t953 + _t938 = _t941 } - _t947 = _t950 + _t935 = _t938 } - _t944 = _t947 + _t932 = _t935 } - _t941 = _t944 + _t929 = _t932 } - return _t941 + return _t929 } func (p *Parser) parse_true() *pb.Conjunction { p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t980 := &pb.Conjunction{Args: []*pb.Formula{}} - return _t980 + _t968 := &pb.Conjunction{Args: []*pb.Formula{}} + return _t968 } func (p *Parser) parse_false() *pb.Disjunction { p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t981 := &pb.Disjunction{Args: []*pb.Formula{}} - return _t981 + _t969 := &pb.Disjunction{Args: []*pb.Formula{}} + return _t969 } func (p *Parser) parse_exists() *pb.Exists { p.consumeLiteral("(") p.consumeLiteral("exists") - _t982 := p.parse_bindings() - bindings477 := _t982 - _t983 := p.parse_formula() - formula478 := _t983 + _t970 := p.parse_bindings() + bindings471 := _t970 + _t971 := p.parse_formula() + formula472 := _t971 p.consumeLiteral(")") - _t984 := &pb.Abstraction{Vars: listConcat(bindings477[0].([]*pb.Binding), bindings477[1].([]*pb.Binding)), Value: formula478} - _t985 := &pb.Exists{Body: _t984} - return _t985 + _t972 := &pb.Abstraction{Vars: listConcat(bindings471[0].([]*pb.Binding), bindings471[1].([]*pb.Binding)), Value: formula472} + _t973 := &pb.Exists{Body: _t972} + return _t973 } func (p *Parser) parse_reduce() *pb.Reduce { p.consumeLiteral("(") p.consumeLiteral("reduce") - _t986 := p.parse_abstraction() - abstraction479 := _t986 - _t987 := p.parse_abstraction() - abstraction_3480 := _t987 - _t988 := p.parse_terms() - terms481 := _t988 + _t974 := p.parse_abstraction() + abstraction473 := _t974 + _t975 := p.parse_abstraction() + abstraction_3474 := _t975 + _t976 := p.parse_terms() + terms475 := _t976 p.consumeLiteral(")") - _t989 := &pb.Reduce{Op: abstraction479, Body: abstraction_3480, Terms: terms481} - return _t989 + _t977 := &pb.Reduce{Op: abstraction473, Body: abstraction_3474, Terms: terms475} + return _t977 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs482 := []*pb.Term{} - cond483 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond483 { - _t990 := p.parse_term() - item484 := _t990 - xs482 = append(xs482, item484) - cond483 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + xs476 := []*pb.Term{} + cond477 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond477 { + _t978 := p.parse_term() + item478 := _t978 + xs476 = append(xs476, item478) + cond477 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - terms485 := xs482 + terms479 := xs476 p.consumeLiteral(")") - return terms485 + return terms479 } func (p *Parser) parse_term() *pb.Term { - var _t991 int64 + var _t979 int64 if p.matchLookaheadLiteral("true", 0) { - _t991 = 1 + _t979 = 1 } else { - var _t992 int64 + var _t980 int64 if p.matchLookaheadLiteral("missing", 0) { - _t992 = 1 + _t980 = 1 } else { - var _t993 int64 + var _t981 int64 if p.matchLookaheadLiteral("false", 0) { - _t993 = 1 + _t981 = 1 } else { - var _t994 int64 + var _t982 int64 if p.matchLookaheadLiteral("(", 0) { - _t994 = 1 + _t982 = 1 } else { - var _t995 int64 + var _t983 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t995 = 1 + _t983 = 1 } else { - var _t996 int64 + var _t984 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t996 = 0 + _t984 = 0 } else { - var _t997 int64 + var _t985 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t997 = 1 + _t985 = 1 } else { - var _t998 int64 + var _t986 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t998 = 1 + _t986 = 1 } else { - var _t999 int64 + var _t987 int64 if p.matchLookaheadTerminal("INT", 0) { - _t999 = 1 + _t987 = 1 } else { - var _t1000 int64 + var _t988 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1000 = 1 + _t988 = 1 } else { - var _t1001 int64 + var _t989 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1001 = 1 + _t989 = 1 } else { - _t1001 = -1 + _t989 = -1 } - _t1000 = _t1001 + _t988 = _t989 } - _t999 = _t1000 + _t987 = _t988 } - _t998 = _t999 + _t986 = _t987 } - _t997 = _t998 + _t985 = _t986 } - _t996 = _t997 + _t984 = _t985 } - _t995 = _t996 + _t983 = _t984 } - _t994 = _t995 + _t982 = _t983 } - _t993 = _t994 + _t981 = _t982 } - _t992 = _t993 + _t980 = _t981 } - _t991 = _t992 - } - prediction486 := _t991 - var _t1002 *pb.Term - if prediction486 == 1 { - _t1003 := p.parse_constant() - constant488 := _t1003 - _t1004 := &pb.Term{} - _t1004.TermType = &pb.Term_Constant{Constant: constant488} - _t1002 = _t1004 + _t979 = _t980 + } + prediction480 := _t979 + var _t990 *pb.Term + if prediction480 == 1 { + _t991 := p.parse_constant() + constant482 := _t991 + _t992 := &pb.Term{} + _t992.TermType = &pb.Term_Constant{Constant: constant482} + _t990 = _t992 } else { - var _t1005 *pb.Term - if prediction486 == 0 { - _t1006 := p.parse_var() - var487 := _t1006 - _t1007 := &pb.Term{} - _t1007.TermType = &pb.Term_Var{Var: var487} - _t1005 = _t1007 + var _t993 *pb.Term + if prediction480 == 0 { + _t994 := p.parse_var() + var481 := _t994 + _t995 := &pb.Term{} + _t995.TermType = &pb.Term_Var{Var: var481} + _t993 = _t995 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1002 = _t1005 + _t990 = _t993 } - return _t1002 + return _t990 } func (p *Parser) parse_var() *pb.Var { - symbol489 := p.consumeTerminal("SYMBOL").Value.str - _t1008 := &pb.Var{Name: symbol489} - return _t1008 + symbol483 := p.consumeTerminal("SYMBOL").Value.str + _t996 := &pb.Var{Name: symbol483} + return _t996 } func (p *Parser) parse_constant() *pb.Value { - _t1009 := p.parse_value() - value490 := _t1009 - return value490 + _t997 := p.parse_value() + value484 := _t997 + return value484 } func (p *Parser) parse_conjunction() *pb.Conjunction { p.consumeLiteral("(") p.consumeLiteral("and") - xs491 := []*pb.Formula{} - cond492 := p.matchLookaheadLiteral("(", 0) - for cond492 { - _t1010 := p.parse_formula() - item493 := _t1010 - xs491 = append(xs491, item493) - cond492 = p.matchLookaheadLiteral("(", 0) + xs485 := []*pb.Formula{} + cond486 := p.matchLookaheadLiteral("(", 0) + for cond486 { + _t998 := p.parse_formula() + item487 := _t998 + xs485 = append(xs485, item487) + cond486 = p.matchLookaheadLiteral("(", 0) } - formulas494 := xs491 + formulas488 := xs485 p.consumeLiteral(")") - _t1011 := &pb.Conjunction{Args: formulas494} - return _t1011 + _t999 := &pb.Conjunction{Args: formulas488} + return _t999 } func (p *Parser) parse_disjunction() *pb.Disjunction { p.consumeLiteral("(") p.consumeLiteral("or") - xs495 := []*pb.Formula{} - cond496 := p.matchLookaheadLiteral("(", 0) - for cond496 { - _t1012 := p.parse_formula() - item497 := _t1012 - xs495 = append(xs495, item497) - cond496 = p.matchLookaheadLiteral("(", 0) + xs489 := []*pb.Formula{} + cond490 := p.matchLookaheadLiteral("(", 0) + for cond490 { + _t1000 := p.parse_formula() + item491 := _t1000 + xs489 = append(xs489, item491) + cond490 = p.matchLookaheadLiteral("(", 0) } - formulas498 := xs495 + formulas492 := xs489 p.consumeLiteral(")") - _t1013 := &pb.Disjunction{Args: formulas498} - return _t1013 + _t1001 := &pb.Disjunction{Args: formulas492} + return _t1001 } func (p *Parser) parse_not() *pb.Not { p.consumeLiteral("(") p.consumeLiteral("not") - _t1014 := p.parse_formula() - formula499 := _t1014 + _t1002 := p.parse_formula() + formula493 := _t1002 p.consumeLiteral(")") - _t1015 := &pb.Not{Arg: formula499} - return _t1015 + _t1003 := &pb.Not{Arg: formula493} + return _t1003 } func (p *Parser) parse_ffi() *pb.FFI { p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1016 := p.parse_name() - name500 := _t1016 - _t1017 := p.parse_ffi_args() - ffi_args501 := _t1017 - _t1018 := p.parse_terms() - terms502 := _t1018 + _t1004 := p.parse_name() + name494 := _t1004 + _t1005 := p.parse_ffi_args() + ffi_args495 := _t1005 + _t1006 := p.parse_terms() + terms496 := _t1006 p.consumeLiteral(")") - _t1019 := &pb.FFI{Name: name500, Args: ffi_args501, Terms: terms502} - return _t1019 + _t1007 := &pb.FFI{Name: name494, Args: ffi_args495, Terms: terms496} + return _t1007 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol503 := p.consumeTerminal("SYMBOL").Value.str - return symbol503 + symbol497 := p.consumeTerminal("SYMBOL").Value.str + return symbol497 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs504 := []*pb.Abstraction{} - cond505 := p.matchLookaheadLiteral("(", 0) - for cond505 { - _t1020 := p.parse_abstraction() - item506 := _t1020 - xs504 = append(xs504, item506) - cond505 = p.matchLookaheadLiteral("(", 0) + xs498 := []*pb.Abstraction{} + cond499 := p.matchLookaheadLiteral("(", 0) + for cond499 { + _t1008 := p.parse_abstraction() + item500 := _t1008 + xs498 = append(xs498, item500) + cond499 = p.matchLookaheadLiteral("(", 0) } - abstractions507 := xs504 + abstractions501 := xs498 p.consumeLiteral(")") - return abstractions507 + return abstractions501 } func (p *Parser) parse_atom() *pb.Atom { p.consumeLiteral("(") p.consumeLiteral("atom") - _t1021 := p.parse_relation_id() - relation_id508 := _t1021 - xs509 := []*pb.Term{} - cond510 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond510 { - _t1022 := p.parse_term() - item511 := _t1022 - xs509 = append(xs509, item511) - cond510 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - } - terms512 := xs509 - p.consumeLiteral(")") - _t1023 := &pb.Atom{Name: relation_id508, Terms: terms512} - return _t1023 + _t1009 := p.parse_relation_id() + relation_id502 := _t1009 + xs503 := []*pb.Term{} + cond504 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond504 { + _t1010 := p.parse_term() + item505 := _t1010 + xs503 = append(xs503, item505) + cond504 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + } + terms506 := xs503 + p.consumeLiteral(")") + _t1011 := &pb.Atom{Name: relation_id502, Terms: terms506} + return _t1011 } func (p *Parser) parse_pragma() *pb.Pragma { p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1024 := p.parse_name() - name513 := _t1024 - xs514 := []*pb.Term{} - cond515 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond515 { - _t1025 := p.parse_term() - item516 := _t1025 - xs514 = append(xs514, item516) - cond515 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - } - terms517 := xs514 - p.consumeLiteral(")") - _t1026 := &pb.Pragma{Name: name513, Terms: terms517} - return _t1026 + _t1012 := p.parse_name() + name507 := _t1012 + xs508 := []*pb.Term{} + cond509 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond509 { + _t1013 := p.parse_term() + item510 := _t1013 + xs508 = append(xs508, item510) + cond509 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + } + terms511 := xs508 + p.consumeLiteral(")") + _t1014 := &pb.Pragma{Name: name507, Terms: terms511} + return _t1014 } func (p *Parser) parse_primitive() *pb.Primitive { - var _t1027 int64 + var _t1015 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1028 int64 + var _t1016 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1028 = 9 + _t1016 = 9 } else { - var _t1029 int64 + var _t1017 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1029 = 4 + _t1017 = 4 } else { - var _t1030 int64 + var _t1018 int64 if p.matchLookaheadLiteral(">", 1) { - _t1030 = 3 + _t1018 = 3 } else { - var _t1031 int64 + var _t1019 int64 if p.matchLookaheadLiteral("=", 1) { - _t1031 = 0 + _t1019 = 0 } else { - var _t1032 int64 + var _t1020 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1032 = 2 + _t1020 = 2 } else { - var _t1033 int64 + var _t1021 int64 if p.matchLookaheadLiteral("<", 1) { - _t1033 = 1 + _t1021 = 1 } else { - var _t1034 int64 + var _t1022 int64 if p.matchLookaheadLiteral("/", 1) { - _t1034 = 8 + _t1022 = 8 } else { - var _t1035 int64 + var _t1023 int64 if p.matchLookaheadLiteral("-", 1) { - _t1035 = 6 + _t1023 = 6 } else { - var _t1036 int64 + var _t1024 int64 if p.matchLookaheadLiteral("+", 1) { - _t1036 = 5 + _t1024 = 5 } else { - var _t1037 int64 + var _t1025 int64 if p.matchLookaheadLiteral("*", 1) { - _t1037 = 7 + _t1025 = 7 } else { - _t1037 = -1 + _t1025 = -1 } - _t1036 = _t1037 + _t1024 = _t1025 } - _t1035 = _t1036 + _t1023 = _t1024 } - _t1034 = _t1035 + _t1022 = _t1023 } - _t1033 = _t1034 + _t1021 = _t1022 } - _t1032 = _t1033 + _t1020 = _t1021 } - _t1031 = _t1032 + _t1019 = _t1020 } - _t1030 = _t1031 + _t1018 = _t1019 } - _t1029 = _t1030 + _t1017 = _t1018 } - _t1028 = _t1029 + _t1016 = _t1017 } - _t1027 = _t1028 + _t1015 = _t1016 } else { - _t1027 = -1 + _t1015 = -1 } - prediction518 := _t1027 - var _t1038 *pb.Primitive - if prediction518 == 9 { + prediction512 := _t1015 + var _t1026 *pb.Primitive + if prediction512 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1039 := p.parse_name() - name528 := _t1039 - xs529 := []*pb.RelTerm{} - cond530 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond530 { - _t1040 := p.parse_rel_term() - item531 := _t1040 - xs529 = append(xs529, item531) - cond530 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1027 := p.parse_name() + name522 := _t1027 + xs523 := []*pb.RelTerm{} + cond524 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond524 { + _t1028 := p.parse_rel_term() + item525 := _t1028 + xs523 = append(xs523, item525) + cond524 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - rel_terms532 := xs529 + rel_terms526 := xs523 p.consumeLiteral(")") - _t1041 := &pb.Primitive{Name: name528, Terms: rel_terms532} - _t1038 = _t1041 + _t1029 := &pb.Primitive{Name: name522, Terms: rel_terms526} + _t1026 = _t1029 } else { - var _t1042 *pb.Primitive - if prediction518 == 8 { - _t1043 := p.parse_divide() - divide527 := _t1043 - _t1042 = divide527 + var _t1030 *pb.Primitive + if prediction512 == 8 { + _t1031 := p.parse_divide() + divide521 := _t1031 + _t1030 = divide521 } else { - var _t1044 *pb.Primitive - if prediction518 == 7 { - _t1045 := p.parse_multiply() - multiply526 := _t1045 - _t1044 = multiply526 + var _t1032 *pb.Primitive + if prediction512 == 7 { + _t1033 := p.parse_multiply() + multiply520 := _t1033 + _t1032 = multiply520 } else { - var _t1046 *pb.Primitive - if prediction518 == 6 { - _t1047 := p.parse_minus() - minus525 := _t1047 - _t1046 = minus525 + var _t1034 *pb.Primitive + if prediction512 == 6 { + _t1035 := p.parse_minus() + minus519 := _t1035 + _t1034 = minus519 } else { - var _t1048 *pb.Primitive - if prediction518 == 5 { - _t1049 := p.parse_add() - add524 := _t1049 - _t1048 = add524 + var _t1036 *pb.Primitive + if prediction512 == 5 { + _t1037 := p.parse_add() + add518 := _t1037 + _t1036 = add518 } else { - var _t1050 *pb.Primitive - if prediction518 == 4 { - _t1051 := p.parse_gt_eq() - gt_eq523 := _t1051 - _t1050 = gt_eq523 + var _t1038 *pb.Primitive + if prediction512 == 4 { + _t1039 := p.parse_gt_eq() + gt_eq517 := _t1039 + _t1038 = gt_eq517 } else { - var _t1052 *pb.Primitive - if prediction518 == 3 { - _t1053 := p.parse_gt() - gt522 := _t1053 - _t1052 = gt522 + var _t1040 *pb.Primitive + if prediction512 == 3 { + _t1041 := p.parse_gt() + gt516 := _t1041 + _t1040 = gt516 } else { - var _t1054 *pb.Primitive - if prediction518 == 2 { - _t1055 := p.parse_lt_eq() - lt_eq521 := _t1055 - _t1054 = lt_eq521 + var _t1042 *pb.Primitive + if prediction512 == 2 { + _t1043 := p.parse_lt_eq() + lt_eq515 := _t1043 + _t1042 = lt_eq515 } else { - var _t1056 *pb.Primitive - if prediction518 == 1 { - _t1057 := p.parse_lt() - lt520 := _t1057 - _t1056 = lt520 + var _t1044 *pb.Primitive + if prediction512 == 1 { + _t1045 := p.parse_lt() + lt514 := _t1045 + _t1044 = lt514 } else { - var _t1058 *pb.Primitive - if prediction518 == 0 { - _t1059 := p.parse_eq() - eq519 := _t1059 - _t1058 = eq519 + var _t1046 *pb.Primitive + if prediction512 == 0 { + _t1047 := p.parse_eq() + eq513 := _t1047 + _t1046 = eq513 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1056 = _t1058 + _t1044 = _t1046 } - _t1054 = _t1056 + _t1042 = _t1044 } - _t1052 = _t1054 + _t1040 = _t1042 } - _t1050 = _t1052 + _t1038 = _t1040 } - _t1048 = _t1050 + _t1036 = _t1038 } - _t1046 = _t1048 + _t1034 = _t1036 } - _t1044 = _t1046 + _t1032 = _t1034 } - _t1042 = _t1044 + _t1030 = _t1032 } - _t1038 = _t1042 + _t1026 = _t1030 } - return _t1038 + return _t1026 } func (p *Parser) parse_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("=") - _t1060 := p.parse_term() - term533 := _t1060 - _t1061 := p.parse_term() - term_3534 := _t1061 + _t1048 := p.parse_term() + term527 := _t1048 + _t1049 := p.parse_term() + term_3528 := _t1049 p.consumeLiteral(")") - _t1062 := &pb.RelTerm{} - _t1062.RelTermType = &pb.RelTerm_Term{Term: term533} - _t1063 := &pb.RelTerm{} - _t1063.RelTermType = &pb.RelTerm_Term{Term: term_3534} - _t1064 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1062, _t1063}} - return _t1064 + _t1050 := &pb.RelTerm{} + _t1050.RelTermType = &pb.RelTerm_Term{Term: term527} + _t1051 := &pb.RelTerm{} + _t1051.RelTermType = &pb.RelTerm_Term{Term: term_3528} + _t1052 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1050, _t1051}} + return _t1052 } func (p *Parser) parse_lt() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("<") - _t1065 := p.parse_term() - term535 := _t1065 - _t1066 := p.parse_term() - term_3536 := _t1066 + _t1053 := p.parse_term() + term529 := _t1053 + _t1054 := p.parse_term() + term_3530 := _t1054 p.consumeLiteral(")") - _t1067 := &pb.RelTerm{} - _t1067.RelTermType = &pb.RelTerm_Term{Term: term535} - _t1068 := &pb.RelTerm{} - _t1068.RelTermType = &pb.RelTerm_Term{Term: term_3536} - _t1069 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1067, _t1068}} - return _t1069 + _t1055 := &pb.RelTerm{} + _t1055.RelTermType = &pb.RelTerm_Term{Term: term529} + _t1056 := &pb.RelTerm{} + _t1056.RelTermType = &pb.RelTerm_Term{Term: term_3530} + _t1057 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1055, _t1056}} + return _t1057 } func (p *Parser) parse_lt_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("<=") - _t1070 := p.parse_term() - term537 := _t1070 - _t1071 := p.parse_term() - term_3538 := _t1071 + _t1058 := p.parse_term() + term531 := _t1058 + _t1059 := p.parse_term() + term_3532 := _t1059 p.consumeLiteral(")") - _t1072 := &pb.RelTerm{} - _t1072.RelTermType = &pb.RelTerm_Term{Term: term537} - _t1073 := &pb.RelTerm{} - _t1073.RelTermType = &pb.RelTerm_Term{Term: term_3538} - _t1074 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1072, _t1073}} - return _t1074 + _t1060 := &pb.RelTerm{} + _t1060.RelTermType = &pb.RelTerm_Term{Term: term531} + _t1061 := &pb.RelTerm{} + _t1061.RelTermType = &pb.RelTerm_Term{Term: term_3532} + _t1062 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1060, _t1061}} + return _t1062 } func (p *Parser) parse_gt() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral(">") - _t1075 := p.parse_term() - term539 := _t1075 - _t1076 := p.parse_term() - term_3540 := _t1076 + _t1063 := p.parse_term() + term533 := _t1063 + _t1064 := p.parse_term() + term_3534 := _t1064 p.consumeLiteral(")") - _t1077 := &pb.RelTerm{} - _t1077.RelTermType = &pb.RelTerm_Term{Term: term539} - _t1078 := &pb.RelTerm{} - _t1078.RelTermType = &pb.RelTerm_Term{Term: term_3540} - _t1079 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1077, _t1078}} - return _t1079 + _t1065 := &pb.RelTerm{} + _t1065.RelTermType = &pb.RelTerm_Term{Term: term533} + _t1066 := &pb.RelTerm{} + _t1066.RelTermType = &pb.RelTerm_Term{Term: term_3534} + _t1067 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1065, _t1066}} + return _t1067 } func (p *Parser) parse_gt_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral(">=") - _t1080 := p.parse_term() - term541 := _t1080 - _t1081 := p.parse_term() - term_3542 := _t1081 + _t1068 := p.parse_term() + term535 := _t1068 + _t1069 := p.parse_term() + term_3536 := _t1069 p.consumeLiteral(")") - _t1082 := &pb.RelTerm{} - _t1082.RelTermType = &pb.RelTerm_Term{Term: term541} - _t1083 := &pb.RelTerm{} - _t1083.RelTermType = &pb.RelTerm_Term{Term: term_3542} - _t1084 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1082, _t1083}} - return _t1084 + _t1070 := &pb.RelTerm{} + _t1070.RelTermType = &pb.RelTerm_Term{Term: term535} + _t1071 := &pb.RelTerm{} + _t1071.RelTermType = &pb.RelTerm_Term{Term: term_3536} + _t1072 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1070, _t1071}} + return _t1072 } func (p *Parser) parse_add() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("+") - _t1085 := p.parse_term() - term543 := _t1085 - _t1086 := p.parse_term() - term_3544 := _t1086 - _t1087 := p.parse_term() - term_4545 := _t1087 + _t1073 := p.parse_term() + term537 := _t1073 + _t1074 := p.parse_term() + term_3538 := _t1074 + _t1075 := p.parse_term() + term_4539 := _t1075 p.consumeLiteral(")") - _t1088 := &pb.RelTerm{} - _t1088.RelTermType = &pb.RelTerm_Term{Term: term543} - _t1089 := &pb.RelTerm{} - _t1089.RelTermType = &pb.RelTerm_Term{Term: term_3544} - _t1090 := &pb.RelTerm{} - _t1090.RelTermType = &pb.RelTerm_Term{Term: term_4545} - _t1091 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1088, _t1089, _t1090}} - return _t1091 + _t1076 := &pb.RelTerm{} + _t1076.RelTermType = &pb.RelTerm_Term{Term: term537} + _t1077 := &pb.RelTerm{} + _t1077.RelTermType = &pb.RelTerm_Term{Term: term_3538} + _t1078 := &pb.RelTerm{} + _t1078.RelTermType = &pb.RelTerm_Term{Term: term_4539} + _t1079 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1076, _t1077, _t1078}} + return _t1079 } func (p *Parser) parse_minus() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("-") - _t1092 := p.parse_term() - term546 := _t1092 - _t1093 := p.parse_term() - term_3547 := _t1093 - _t1094 := p.parse_term() - term_4548 := _t1094 + _t1080 := p.parse_term() + term540 := _t1080 + _t1081 := p.parse_term() + term_3541 := _t1081 + _t1082 := p.parse_term() + term_4542 := _t1082 p.consumeLiteral(")") - _t1095 := &pb.RelTerm{} - _t1095.RelTermType = &pb.RelTerm_Term{Term: term546} - _t1096 := &pb.RelTerm{} - _t1096.RelTermType = &pb.RelTerm_Term{Term: term_3547} - _t1097 := &pb.RelTerm{} - _t1097.RelTermType = &pb.RelTerm_Term{Term: term_4548} - _t1098 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1095, _t1096, _t1097}} - return _t1098 + _t1083 := &pb.RelTerm{} + _t1083.RelTermType = &pb.RelTerm_Term{Term: term540} + _t1084 := &pb.RelTerm{} + _t1084.RelTermType = &pb.RelTerm_Term{Term: term_3541} + _t1085 := &pb.RelTerm{} + _t1085.RelTermType = &pb.RelTerm_Term{Term: term_4542} + _t1086 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1083, _t1084, _t1085}} + return _t1086 } func (p *Parser) parse_multiply() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("*") - _t1099 := p.parse_term() - term549 := _t1099 - _t1100 := p.parse_term() - term_3550 := _t1100 - _t1101 := p.parse_term() - term_4551 := _t1101 - p.consumeLiteral(")") - _t1102 := &pb.RelTerm{} - _t1102.RelTermType = &pb.RelTerm_Term{Term: term549} - _t1103 := &pb.RelTerm{} - _t1103.RelTermType = &pb.RelTerm_Term{Term: term_3550} - _t1104 := &pb.RelTerm{} - _t1104.RelTermType = &pb.RelTerm_Term{Term: term_4551} - _t1105 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1102, _t1103, _t1104}} - return _t1105 + _t1087 := p.parse_term() + term543 := _t1087 + _t1088 := p.parse_term() + term_3544 := _t1088 + _t1089 := p.parse_term() + term_4545 := _t1089 + p.consumeLiteral(")") + _t1090 := &pb.RelTerm{} + _t1090.RelTermType = &pb.RelTerm_Term{Term: term543} + _t1091 := &pb.RelTerm{} + _t1091.RelTermType = &pb.RelTerm_Term{Term: term_3544} + _t1092 := &pb.RelTerm{} + _t1092.RelTermType = &pb.RelTerm_Term{Term: term_4545} + _t1093 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1090, _t1091, _t1092}} + return _t1093 } func (p *Parser) parse_divide() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("/") - _t1106 := p.parse_term() - term552 := _t1106 - _t1107 := p.parse_term() - term_3553 := _t1107 - _t1108 := p.parse_term() - term_4554 := _t1108 - p.consumeLiteral(")") - _t1109 := &pb.RelTerm{} - _t1109.RelTermType = &pb.RelTerm_Term{Term: term552} - _t1110 := &pb.RelTerm{} - _t1110.RelTermType = &pb.RelTerm_Term{Term: term_3553} - _t1111 := &pb.RelTerm{} - _t1111.RelTermType = &pb.RelTerm_Term{Term: term_4554} - _t1112 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1109, _t1110, _t1111}} - return _t1112 + _t1094 := p.parse_term() + term546 := _t1094 + _t1095 := p.parse_term() + term_3547 := _t1095 + _t1096 := p.parse_term() + term_4548 := _t1096 + p.consumeLiteral(")") + _t1097 := &pb.RelTerm{} + _t1097.RelTermType = &pb.RelTerm_Term{Term: term546} + _t1098 := &pb.RelTerm{} + _t1098.RelTermType = &pb.RelTerm_Term{Term: term_3547} + _t1099 := &pb.RelTerm{} + _t1099.RelTermType = &pb.RelTerm_Term{Term: term_4548} + _t1100 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1097, _t1098, _t1099}} + return _t1100 } func (p *Parser) parse_rel_term() *pb.RelTerm { - var _t1113 int64 + var _t1101 int64 if p.matchLookaheadLiteral("true", 0) { - _t1113 = 1 + _t1101 = 1 } else { - var _t1114 int64 + var _t1102 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1114 = 1 + _t1102 = 1 } else { - var _t1115 int64 + var _t1103 int64 if p.matchLookaheadLiteral("false", 0) { - _t1115 = 1 + _t1103 = 1 } else { - var _t1116 int64 + var _t1104 int64 if p.matchLookaheadLiteral("(", 0) { - _t1116 = 1 + _t1104 = 1 } else { - var _t1117 int64 + var _t1105 int64 if p.matchLookaheadLiteral("#", 0) { - _t1117 = 0 + _t1105 = 0 } else { - var _t1118 int64 + var _t1106 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1118 = 1 + _t1106 = 1 } else { - var _t1119 int64 + var _t1107 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1119 = 1 + _t1107 = 1 } else { - var _t1120 int64 + var _t1108 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1120 = 1 + _t1108 = 1 } else { - var _t1121 int64 + var _t1109 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1121 = 1 + _t1109 = 1 } else { - var _t1122 int64 + var _t1110 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1122 = 1 + _t1110 = 1 } else { - var _t1123 int64 + var _t1111 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1123 = 1 + _t1111 = 1 } else { - var _t1124 int64 + var _t1112 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1124 = 1 + _t1112 = 1 } else { - _t1124 = -1 + _t1112 = -1 } - _t1123 = _t1124 + _t1111 = _t1112 } - _t1122 = _t1123 + _t1110 = _t1111 } - _t1121 = _t1122 + _t1109 = _t1110 } - _t1120 = _t1121 + _t1108 = _t1109 } - _t1119 = _t1120 + _t1107 = _t1108 } - _t1118 = _t1119 + _t1106 = _t1107 } - _t1117 = _t1118 + _t1105 = _t1106 } - _t1116 = _t1117 + _t1104 = _t1105 } - _t1115 = _t1116 + _t1103 = _t1104 } - _t1114 = _t1115 + _t1102 = _t1103 } - _t1113 = _t1114 - } - prediction555 := _t1113 - var _t1125 *pb.RelTerm - if prediction555 == 1 { - _t1126 := p.parse_term() - term557 := _t1126 - _t1127 := &pb.RelTerm{} - _t1127.RelTermType = &pb.RelTerm_Term{Term: term557} - _t1125 = _t1127 + _t1101 = _t1102 + } + prediction549 := _t1101 + var _t1113 *pb.RelTerm + if prediction549 == 1 { + _t1114 := p.parse_term() + term551 := _t1114 + _t1115 := &pb.RelTerm{} + _t1115.RelTermType = &pb.RelTerm_Term{Term: term551} + _t1113 = _t1115 } else { - var _t1128 *pb.RelTerm - if prediction555 == 0 { - _t1129 := p.parse_specialized_value() - specialized_value556 := _t1129 - _t1130 := &pb.RelTerm{} - _t1130.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value556} - _t1128 = _t1130 + var _t1116 *pb.RelTerm + if prediction549 == 0 { + _t1117 := p.parse_specialized_value() + specialized_value550 := _t1117 + _t1118 := &pb.RelTerm{} + _t1118.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value550} + _t1116 = _t1118 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1125 = _t1128 + _t1113 = _t1116 } - return _t1125 + return _t1113 } func (p *Parser) parse_specialized_value() *pb.Value { p.consumeLiteral("#") - _t1131 := p.parse_value() - value558 := _t1131 - return value558 + _t1119 := p.parse_value() + value552 := _t1119 + return value552 } func (p *Parser) parse_rel_atom() *pb.RelAtom { p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1132 := p.parse_name() - name559 := _t1132 - xs560 := []*pb.RelTerm{} - cond561 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond561 { - _t1133 := p.parse_rel_term() - item562 := _t1133 - xs560 = append(xs560, item562) - cond561 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1120 := p.parse_name() + name553 := _t1120 + xs554 := []*pb.RelTerm{} + cond555 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond555 { + _t1121 := p.parse_rel_term() + item556 := _t1121 + xs554 = append(xs554, item556) + cond555 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - rel_terms563 := xs560 + rel_terms557 := xs554 p.consumeLiteral(")") - _t1134 := &pb.RelAtom{Name: name559, Terms: rel_terms563} - return _t1134 + _t1122 := &pb.RelAtom{Name: name553, Terms: rel_terms557} + return _t1122 } func (p *Parser) parse_cast() *pb.Cast { p.consumeLiteral("(") p.consumeLiteral("cast") - _t1135 := p.parse_term() - term564 := _t1135 - _t1136 := p.parse_term() - term_3565 := _t1136 + _t1123 := p.parse_term() + term558 := _t1123 + _t1124 := p.parse_term() + term_3559 := _t1124 p.consumeLiteral(")") - _t1137 := &pb.Cast{Input: term564, Result: term_3565} - return _t1137 + _t1125 := &pb.Cast{Input: term558, Result: term_3559} + return _t1125 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs566 := []*pb.Attribute{} - cond567 := p.matchLookaheadLiteral("(", 0) - for cond567 { - _t1138 := p.parse_attribute() - item568 := _t1138 - xs566 = append(xs566, item568) - cond567 = p.matchLookaheadLiteral("(", 0) + xs560 := []*pb.Attribute{} + cond561 := p.matchLookaheadLiteral("(", 0) + for cond561 { + _t1126 := p.parse_attribute() + item562 := _t1126 + xs560 = append(xs560, item562) + cond561 = p.matchLookaheadLiteral("(", 0) } - attributes569 := xs566 + attributes563 := xs560 p.consumeLiteral(")") - return attributes569 + return attributes563 } func (p *Parser) parse_attribute() *pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1139 := p.parse_name() - name570 := _t1139 - xs571 := []*pb.Value{} - cond572 := (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond572 { - _t1140 := p.parse_value() - item573 := _t1140 - xs571 = append(xs571, item573) - cond572 = (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1127 := p.parse_name() + name564 := _t1127 + xs565 := []*pb.Value{} + cond566 := (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond566 { + _t1128 := p.parse_value() + item567 := _t1128 + xs565 = append(xs565, item567) + cond566 = (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - values574 := xs571 + values568 := xs565 p.consumeLiteral(")") - _t1141 := &pb.Attribute{Name: name570, Args: values574} - return _t1141 + _t1129 := &pb.Attribute{Name: name564, Args: values568} + return _t1129 } func (p *Parser) parse_algorithm() *pb.Algorithm { p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs575 := []*pb.RelationId{} - cond576 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond576 { - _t1142 := p.parse_relation_id() - item577 := _t1142 - xs575 = append(xs575, item577) - cond576 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + xs569 := []*pb.RelationId{} + cond570 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond570 { + _t1130 := p.parse_relation_id() + item571 := _t1130 + xs569 = append(xs569, item571) + cond570 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) } - relation_ids578 := xs575 - _t1143 := p.parse_script() - script579 := _t1143 + relation_ids572 := xs569 + _t1131 := p.parse_script() + script573 := _t1131 p.consumeLiteral(")") - _t1144 := &pb.Algorithm{Global: relation_ids578, Body: script579} - return _t1144 + _t1132 := &pb.Algorithm{Global: relation_ids572, Body: script573} + return _t1132 } func (p *Parser) parse_script() *pb.Script { p.consumeLiteral("(") p.consumeLiteral("script") - xs580 := []*pb.Construct{} - cond581 := p.matchLookaheadLiteral("(", 0) - for cond581 { - _t1145 := p.parse_construct() - item582 := _t1145 - xs580 = append(xs580, item582) - cond581 = p.matchLookaheadLiteral("(", 0) + xs574 := []*pb.Construct{} + cond575 := p.matchLookaheadLiteral("(", 0) + for cond575 { + _t1133 := p.parse_construct() + item576 := _t1133 + xs574 = append(xs574, item576) + cond575 = p.matchLookaheadLiteral("(", 0) } - constructs583 := xs580 + constructs577 := xs574 p.consumeLiteral(")") - _t1146 := &pb.Script{Constructs: constructs583} - return _t1146 + _t1134 := &pb.Script{Constructs: constructs577} + return _t1134 } func (p *Parser) parse_construct() *pb.Construct { - var _t1147 int64 + var _t1135 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1148 int64 + var _t1136 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1148 = 1 + _t1136 = 1 } else { - var _t1149 int64 + var _t1137 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1149 = 1 + _t1137 = 1 } else { - var _t1150 int64 + var _t1138 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1150 = 1 + _t1138 = 1 } else { - var _t1151 int64 + var _t1139 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1151 = 0 + _t1139 = 0 } else { - var _t1152 int64 + var _t1140 int64 if p.matchLookaheadLiteral("break", 1) { - _t1152 = 1 + _t1140 = 1 } else { - var _t1153 int64 + var _t1141 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1153 = 1 + _t1141 = 1 } else { - _t1153 = -1 + _t1141 = -1 } - _t1152 = _t1153 + _t1140 = _t1141 } - _t1151 = _t1152 + _t1139 = _t1140 } - _t1150 = _t1151 + _t1138 = _t1139 } - _t1149 = _t1150 + _t1137 = _t1138 } - _t1148 = _t1149 + _t1136 = _t1137 } - _t1147 = _t1148 + _t1135 = _t1136 } else { - _t1147 = -1 - } - prediction584 := _t1147 - var _t1154 *pb.Construct - if prediction584 == 1 { - _t1155 := p.parse_instruction() - instruction586 := _t1155 - _t1156 := &pb.Construct{} - _t1156.ConstructType = &pb.Construct_Instruction{Instruction: instruction586} - _t1154 = _t1156 + _t1135 = -1 + } + prediction578 := _t1135 + var _t1142 *pb.Construct + if prediction578 == 1 { + _t1143 := p.parse_instruction() + instruction580 := _t1143 + _t1144 := &pb.Construct{} + _t1144.ConstructType = &pb.Construct_Instruction{Instruction: instruction580} + _t1142 = _t1144 } else { - var _t1157 *pb.Construct - if prediction584 == 0 { - _t1158 := p.parse_loop() - loop585 := _t1158 - _t1159 := &pb.Construct{} - _t1159.ConstructType = &pb.Construct_Loop{Loop: loop585} - _t1157 = _t1159 + var _t1145 *pb.Construct + if prediction578 == 0 { + _t1146 := p.parse_loop() + loop579 := _t1146 + _t1147 := &pb.Construct{} + _t1147.ConstructType = &pb.Construct_Loop{Loop: loop579} + _t1145 = _t1147 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1154 = _t1157 + _t1142 = _t1145 } - return _t1154 + return _t1142 } func (p *Parser) parse_loop() *pb.Loop { p.consumeLiteral("(") p.consumeLiteral("loop") - _t1160 := p.parse_init() - init587 := _t1160 - _t1161 := p.parse_script() - script588 := _t1161 + _t1148 := p.parse_init() + init581 := _t1148 + _t1149 := p.parse_script() + script582 := _t1149 p.consumeLiteral(")") - _t1162 := &pb.Loop{Init: init587, Body: script588} - return _t1162 + _t1150 := &pb.Loop{Init: init581, Body: script582} + return _t1150 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs589 := []*pb.Instruction{} - cond590 := p.matchLookaheadLiteral("(", 0) - for cond590 { - _t1163 := p.parse_instruction() - item591 := _t1163 - xs589 = append(xs589, item591) - cond590 = p.matchLookaheadLiteral("(", 0) + xs583 := []*pb.Instruction{} + cond584 := p.matchLookaheadLiteral("(", 0) + for cond584 { + _t1151 := p.parse_instruction() + item585 := _t1151 + xs583 = append(xs583, item585) + cond584 = p.matchLookaheadLiteral("(", 0) } - instructions592 := xs589 + instructions586 := xs583 p.consumeLiteral(")") - return instructions592 + return instructions586 } func (p *Parser) parse_instruction() *pb.Instruction { - var _t1164 int64 + var _t1152 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1165 int64 + var _t1153 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1165 = 1 + _t1153 = 1 } else { - var _t1166 int64 + var _t1154 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1166 = 4 + _t1154 = 4 } else { - var _t1167 int64 + var _t1155 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1167 = 3 + _t1155 = 3 } else { - var _t1168 int64 + var _t1156 int64 if p.matchLookaheadLiteral("break", 1) { - _t1168 = 2 + _t1156 = 2 } else { - var _t1169 int64 + var _t1157 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1169 = 0 + _t1157 = 0 } else { - _t1169 = -1 + _t1157 = -1 } - _t1168 = _t1169 + _t1156 = _t1157 } - _t1167 = _t1168 + _t1155 = _t1156 } - _t1166 = _t1167 + _t1154 = _t1155 } - _t1165 = _t1166 + _t1153 = _t1154 } - _t1164 = _t1165 + _t1152 = _t1153 } else { - _t1164 = -1 - } - prediction593 := _t1164 - var _t1170 *pb.Instruction - if prediction593 == 4 { - _t1171 := p.parse_monus_def() - monus_def598 := _t1171 - _t1172 := &pb.Instruction{} - _t1172.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def598} - _t1170 = _t1172 + _t1152 = -1 + } + prediction587 := _t1152 + var _t1158 *pb.Instruction + if prediction587 == 4 { + _t1159 := p.parse_monus_def() + monus_def592 := _t1159 + _t1160 := &pb.Instruction{} + _t1160.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def592} + _t1158 = _t1160 } else { - var _t1173 *pb.Instruction - if prediction593 == 3 { - _t1174 := p.parse_monoid_def() - monoid_def597 := _t1174 - _t1175 := &pb.Instruction{} - _t1175.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def597} - _t1173 = _t1175 + var _t1161 *pb.Instruction + if prediction587 == 3 { + _t1162 := p.parse_monoid_def() + monoid_def591 := _t1162 + _t1163 := &pb.Instruction{} + _t1163.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def591} + _t1161 = _t1163 } else { - var _t1176 *pb.Instruction - if prediction593 == 2 { - _t1177 := p.parse_break() - break596 := _t1177 - _t1178 := &pb.Instruction{} - _t1178.InstrType = &pb.Instruction_Break{Break: break596} - _t1176 = _t1178 + var _t1164 *pb.Instruction + if prediction587 == 2 { + _t1165 := p.parse_break() + break590 := _t1165 + _t1166 := &pb.Instruction{} + _t1166.InstrType = &pb.Instruction_Break{Break: break590} + _t1164 = _t1166 } else { - var _t1179 *pb.Instruction - if prediction593 == 1 { - _t1180 := p.parse_upsert() - upsert595 := _t1180 - _t1181 := &pb.Instruction{} - _t1181.InstrType = &pb.Instruction_Upsert{Upsert: upsert595} - _t1179 = _t1181 + var _t1167 *pb.Instruction + if prediction587 == 1 { + _t1168 := p.parse_upsert() + upsert589 := _t1168 + _t1169 := &pb.Instruction{} + _t1169.InstrType = &pb.Instruction_Upsert{Upsert: upsert589} + _t1167 = _t1169 } else { - var _t1182 *pb.Instruction - if prediction593 == 0 { - _t1183 := p.parse_assign() - assign594 := _t1183 - _t1184 := &pb.Instruction{} - _t1184.InstrType = &pb.Instruction_Assign{Assign: assign594} - _t1182 = _t1184 + var _t1170 *pb.Instruction + if prediction587 == 0 { + _t1171 := p.parse_assign() + assign588 := _t1171 + _t1172 := &pb.Instruction{} + _t1172.InstrType = &pb.Instruction_Assign{Assign: assign588} + _t1170 = _t1172 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1179 = _t1182 + _t1167 = _t1170 } - _t1176 = _t1179 + _t1164 = _t1167 } - _t1173 = _t1176 + _t1161 = _t1164 } - _t1170 = _t1173 + _t1158 = _t1161 } - return _t1170 + return _t1158 } func (p *Parser) parse_assign() *pb.Assign { p.consumeLiteral("(") p.consumeLiteral("assign") - _t1185 := p.parse_relation_id() - relation_id599 := _t1185 - _t1186 := p.parse_abstraction() - abstraction600 := _t1186 - var _t1187 []*pb.Attribute + _t1173 := p.parse_relation_id() + relation_id593 := _t1173 + _t1174 := p.parse_abstraction() + abstraction594 := _t1174 + var _t1175 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1188 := p.parse_attrs() - _t1187 = _t1188 + _t1176 := p.parse_attrs() + _t1175 = _t1176 } - attrs601 := _t1187 + attrs595 := _t1175 p.consumeLiteral(")") - _t1189 := attrs601 - if attrs601 == nil { - _t1189 = []*pb.Attribute{} + _t1177 := attrs595 + if attrs595 == nil { + _t1177 = []*pb.Attribute{} } - _t1190 := &pb.Assign{Name: relation_id599, Body: abstraction600, Attrs: _t1189} - return _t1190 + _t1178 := &pb.Assign{Name: relation_id593, Body: abstraction594, Attrs: _t1177} + return _t1178 } func (p *Parser) parse_upsert() *pb.Upsert { p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1191 := p.parse_relation_id() - relation_id602 := _t1191 - _t1192 := p.parse_abstraction_with_arity() - abstraction_with_arity603 := _t1192 - var _t1193 []*pb.Attribute + _t1179 := p.parse_relation_id() + relation_id596 := _t1179 + _t1180 := p.parse_abstraction_with_arity() + abstraction_with_arity597 := _t1180 + var _t1181 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1194 := p.parse_attrs() - _t1193 = _t1194 + _t1182 := p.parse_attrs() + _t1181 = _t1182 } - attrs604 := _t1193 + attrs598 := _t1181 p.consumeLiteral(")") - _t1195 := attrs604 - if attrs604 == nil { - _t1195 = []*pb.Attribute{} + _t1183 := attrs598 + if attrs598 == nil { + _t1183 = []*pb.Attribute{} } - _t1196 := &pb.Upsert{Name: relation_id602, Body: abstraction_with_arity603[0].(*pb.Abstraction), Attrs: _t1195, ValueArity: abstraction_with_arity603[1].(int64)} - return _t1196 + _t1184 := &pb.Upsert{Name: relation_id596, Body: abstraction_with_arity597[0].(*pb.Abstraction), Attrs: _t1183, ValueArity: abstraction_with_arity597[1].(int64)} + return _t1184 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1197 := p.parse_bindings() - bindings605 := _t1197 - _t1198 := p.parse_formula() - formula606 := _t1198 + _t1185 := p.parse_bindings() + bindings599 := _t1185 + _t1186 := p.parse_formula() + formula600 := _t1186 p.consumeLiteral(")") - _t1199 := &pb.Abstraction{Vars: listConcat(bindings605[0].([]*pb.Binding), bindings605[1].([]*pb.Binding)), Value: formula606} - return []interface{}{_t1199, int64(len(bindings605[1].([]*pb.Binding)))} + _t1187 := &pb.Abstraction{Vars: listConcat(bindings599[0].([]*pb.Binding), bindings599[1].([]*pb.Binding)), Value: formula600} + return []interface{}{_t1187, int64(len(bindings599[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { p.consumeLiteral("(") p.consumeLiteral("break") - _t1200 := p.parse_relation_id() - relation_id607 := _t1200 - _t1201 := p.parse_abstraction() - abstraction608 := _t1201 - var _t1202 []*pb.Attribute + _t1188 := p.parse_relation_id() + relation_id601 := _t1188 + _t1189 := p.parse_abstraction() + abstraction602 := _t1189 + var _t1190 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1203 := p.parse_attrs() - _t1202 = _t1203 + _t1191 := p.parse_attrs() + _t1190 = _t1191 } - attrs609 := _t1202 + attrs603 := _t1190 p.consumeLiteral(")") - _t1204 := attrs609 - if attrs609 == nil { - _t1204 = []*pb.Attribute{} + _t1192 := attrs603 + if attrs603 == nil { + _t1192 = []*pb.Attribute{} } - _t1205 := &pb.Break{Name: relation_id607, Body: abstraction608, Attrs: _t1204} - return _t1205 + _t1193 := &pb.Break{Name: relation_id601, Body: abstraction602, Attrs: _t1192} + return _t1193 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1206 := p.parse_monoid() - monoid610 := _t1206 - _t1207 := p.parse_relation_id() - relation_id611 := _t1207 - _t1208 := p.parse_abstraction_with_arity() - abstraction_with_arity612 := _t1208 - var _t1209 []*pb.Attribute + _t1194 := p.parse_monoid() + monoid604 := _t1194 + _t1195 := p.parse_relation_id() + relation_id605 := _t1195 + _t1196 := p.parse_abstraction_with_arity() + abstraction_with_arity606 := _t1196 + var _t1197 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1210 := p.parse_attrs() - _t1209 = _t1210 + _t1198 := p.parse_attrs() + _t1197 = _t1198 } - attrs613 := _t1209 + attrs607 := _t1197 p.consumeLiteral(")") - _t1211 := attrs613 - if attrs613 == nil { - _t1211 = []*pb.Attribute{} + _t1199 := attrs607 + if attrs607 == nil { + _t1199 = []*pb.Attribute{} } - _t1212 := &pb.MonoidDef{Monoid: monoid610, Name: relation_id611, Body: abstraction_with_arity612[0].(*pb.Abstraction), Attrs: _t1211, ValueArity: abstraction_with_arity612[1].(int64)} - return _t1212 + _t1200 := &pb.MonoidDef{Monoid: monoid604, Name: relation_id605, Body: abstraction_with_arity606[0].(*pb.Abstraction), Attrs: _t1199, ValueArity: abstraction_with_arity606[1].(int64)} + return _t1200 } func (p *Parser) parse_monoid() *pb.Monoid { - var _t1213 int64 + var _t1201 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1214 int64 + var _t1202 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1214 = 3 + _t1202 = 3 } else { - var _t1215 int64 + var _t1203 int64 if p.matchLookaheadLiteral("or", 1) { - _t1215 = 0 + _t1203 = 0 } else { - var _t1216 int64 + var _t1204 int64 if p.matchLookaheadLiteral("min", 1) { - _t1216 = 1 + _t1204 = 1 } else { - var _t1217 int64 + var _t1205 int64 if p.matchLookaheadLiteral("max", 1) { - _t1217 = 2 + _t1205 = 2 } else { - _t1217 = -1 + _t1205 = -1 } - _t1216 = _t1217 + _t1204 = _t1205 } - _t1215 = _t1216 + _t1203 = _t1204 } - _t1214 = _t1215 + _t1202 = _t1203 } - _t1213 = _t1214 + _t1201 = _t1202 } else { - _t1213 = -1 - } - prediction614 := _t1213 - var _t1218 *pb.Monoid - if prediction614 == 3 { - _t1219 := p.parse_sum_monoid() - sum_monoid618 := _t1219 - _t1220 := &pb.Monoid{} - _t1220.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid618} - _t1218 = _t1220 + _t1201 = -1 + } + prediction608 := _t1201 + var _t1206 *pb.Monoid + if prediction608 == 3 { + _t1207 := p.parse_sum_monoid() + sum_monoid612 := _t1207 + _t1208 := &pb.Monoid{} + _t1208.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid612} + _t1206 = _t1208 } else { - var _t1221 *pb.Monoid - if prediction614 == 2 { - _t1222 := p.parse_max_monoid() - max_monoid617 := _t1222 - _t1223 := &pb.Monoid{} - _t1223.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid617} - _t1221 = _t1223 + var _t1209 *pb.Monoid + if prediction608 == 2 { + _t1210 := p.parse_max_monoid() + max_monoid611 := _t1210 + _t1211 := &pb.Monoid{} + _t1211.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid611} + _t1209 = _t1211 } else { - var _t1224 *pb.Monoid - if prediction614 == 1 { - _t1225 := p.parse_min_monoid() - min_monoid616 := _t1225 - _t1226 := &pb.Monoid{} - _t1226.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid616} - _t1224 = _t1226 + var _t1212 *pb.Monoid + if prediction608 == 1 { + _t1213 := p.parse_min_monoid() + min_monoid610 := _t1213 + _t1214 := &pb.Monoid{} + _t1214.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid610} + _t1212 = _t1214 } else { - var _t1227 *pb.Monoid - if prediction614 == 0 { - _t1228 := p.parse_or_monoid() - or_monoid615 := _t1228 - _t1229 := &pb.Monoid{} - _t1229.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid615} - _t1227 = _t1229 + var _t1215 *pb.Monoid + if prediction608 == 0 { + _t1216 := p.parse_or_monoid() + or_monoid609 := _t1216 + _t1217 := &pb.Monoid{} + _t1217.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid609} + _t1215 = _t1217 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1224 = _t1227 + _t1212 = _t1215 } - _t1221 = _t1224 + _t1209 = _t1212 } - _t1218 = _t1221 + _t1206 = _t1209 } - return _t1218 + return _t1206 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1230 := &pb.OrMonoid{} - return _t1230 + _t1218 := &pb.OrMonoid{} + return _t1218 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { p.consumeLiteral("(") p.consumeLiteral("min") - _t1231 := p.parse_type() - type619 := _t1231 + _t1219 := p.parse_type() + type613 := _t1219 p.consumeLiteral(")") - _t1232 := &pb.MinMonoid{Type: type619} - return _t1232 + _t1220 := &pb.MinMonoid{Type: type613} + return _t1220 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { p.consumeLiteral("(") p.consumeLiteral("max") - _t1233 := p.parse_type() - type620 := _t1233 + _t1221 := p.parse_type() + type614 := _t1221 p.consumeLiteral(")") - _t1234 := &pb.MaxMonoid{Type: type620} - return _t1234 + _t1222 := &pb.MaxMonoid{Type: type614} + return _t1222 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { p.consumeLiteral("(") p.consumeLiteral("sum") - _t1235 := p.parse_type() - type621 := _t1235 + _t1223 := p.parse_type() + type615 := _t1223 p.consumeLiteral(")") - _t1236 := &pb.SumMonoid{Type: type621} - return _t1236 + _t1224 := &pb.SumMonoid{Type: type615} + return _t1224 } func (p *Parser) parse_monus_def() *pb.MonusDef { p.consumeLiteral("(") p.consumeLiteral("monus") - _t1237 := p.parse_monoid() - monoid622 := _t1237 - _t1238 := p.parse_relation_id() - relation_id623 := _t1238 - _t1239 := p.parse_abstraction_with_arity() - abstraction_with_arity624 := _t1239 - var _t1240 []*pb.Attribute + _t1225 := p.parse_monoid() + monoid616 := _t1225 + _t1226 := p.parse_relation_id() + relation_id617 := _t1226 + _t1227 := p.parse_abstraction_with_arity() + abstraction_with_arity618 := _t1227 + var _t1228 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1241 := p.parse_attrs() - _t1240 = _t1241 + _t1229 := p.parse_attrs() + _t1228 = _t1229 } - attrs625 := _t1240 + attrs619 := _t1228 p.consumeLiteral(")") - _t1242 := attrs625 - if attrs625 == nil { - _t1242 = []*pb.Attribute{} + _t1230 := attrs619 + if attrs619 == nil { + _t1230 = []*pb.Attribute{} } - _t1243 := &pb.MonusDef{Monoid: monoid622, Name: relation_id623, Body: abstraction_with_arity624[0].(*pb.Abstraction), Attrs: _t1242, ValueArity: abstraction_with_arity624[1].(int64)} - return _t1243 + _t1231 := &pb.MonusDef{Monoid: monoid616, Name: relation_id617, Body: abstraction_with_arity618[0].(*pb.Abstraction), Attrs: _t1230, ValueArity: abstraction_with_arity618[1].(int64)} + return _t1231 } func (p *Parser) parse_constraint() *pb.Constraint { p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1244 := p.parse_relation_id() - relation_id626 := _t1244 - _t1245 := p.parse_abstraction() - abstraction627 := _t1245 - _t1246 := p.parse_functional_dependency_keys() - functional_dependency_keys628 := _t1246 - _t1247 := p.parse_functional_dependency_values() - functional_dependency_values629 := _t1247 + _t1232 := p.parse_relation_id() + relation_id620 := _t1232 + _t1233 := p.parse_abstraction() + abstraction621 := _t1233 + _t1234 := p.parse_functional_dependency_keys() + functional_dependency_keys622 := _t1234 + _t1235 := p.parse_functional_dependency_values() + functional_dependency_values623 := _t1235 p.consumeLiteral(")") - _t1248 := &pb.FunctionalDependency{Guard: abstraction627, Keys: functional_dependency_keys628, Values: functional_dependency_values629} - _t1249 := &pb.Constraint{Name: relation_id626} - _t1249.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1248} - return _t1249 + _t1236 := &pb.FunctionalDependency{Guard: abstraction621, Keys: functional_dependency_keys622, Values: functional_dependency_values623} + _t1237 := &pb.Constraint{Name: relation_id620} + _t1237.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1236} + return _t1237 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs630 := []*pb.Var{} - cond631 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond631 { - _t1250 := p.parse_var() - item632 := _t1250 - xs630 = append(xs630, item632) - cond631 = p.matchLookaheadTerminal("SYMBOL", 0) + xs624 := []*pb.Var{} + cond625 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond625 { + _t1238 := p.parse_var() + item626 := _t1238 + xs624 = append(xs624, item626) + cond625 = p.matchLookaheadTerminal("SYMBOL", 0) } - vars633 := xs630 + vars627 := xs624 p.consumeLiteral(")") - return vars633 + return vars627 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs634 := []*pb.Var{} - cond635 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond635 { - _t1251 := p.parse_var() - item636 := _t1251 - xs634 = append(xs634, item636) - cond635 = p.matchLookaheadTerminal("SYMBOL", 0) + xs628 := []*pb.Var{} + cond629 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond629 { + _t1239 := p.parse_var() + item630 := _t1239 + xs628 = append(xs628, item630) + cond629 = p.matchLookaheadTerminal("SYMBOL", 0) } - vars637 := xs634 + vars631 := xs628 p.consumeLiteral(")") - return vars637 + return vars631 } func (p *Parser) parse_data() *pb.Data { - var _t1252 int64 + var _t1240 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1253 int64 - if p.matchLookaheadLiteral("rel_edb", 1) { - _t1253 = 0 + var _t1241 int64 + if p.matchLookaheadLiteral("edb", 1) { + _t1241 = 0 } else { - var _t1254 int64 + var _t1242 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1254 = 2 + _t1242 = 2 } else { - var _t1255 int64 + var _t1243 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1255 = 1 + _t1243 = 1 } else { - _t1255 = -1 + _t1243 = -1 } - _t1254 = _t1255 + _t1242 = _t1243 } - _t1253 = _t1254 + _t1241 = _t1242 } - _t1252 = _t1253 + _t1240 = _t1241 } else { - _t1252 = -1 - } - prediction638 := _t1252 - var _t1256 *pb.Data - if prediction638 == 2 { - _t1257 := p.parse_csv_data() - csv_data641 := _t1257 - _t1258 := &pb.Data{} - _t1258.DataType = &pb.Data_CsvData{CsvData: csv_data641} - _t1256 = _t1258 + _t1240 = -1 + } + prediction632 := _t1240 + var _t1244 *pb.Data + if prediction632 == 2 { + _t1245 := p.parse_csv_data() + csv_data635 := _t1245 + _t1246 := &pb.Data{} + _t1246.DataType = &pb.Data_CsvData{CsvData: csv_data635} + _t1244 = _t1246 } else { - var _t1259 *pb.Data - if prediction638 == 1 { - _t1260 := p.parse_betree_relation() - betree_relation640 := _t1260 - _t1261 := &pb.Data{} - _t1261.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation640} - _t1259 = _t1261 + var _t1247 *pb.Data + if prediction632 == 1 { + _t1248 := p.parse_betree_relation() + betree_relation634 := _t1248 + _t1249 := &pb.Data{} + _t1249.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation634} + _t1247 = _t1249 } else { - var _t1262 *pb.Data - if prediction638 == 0 { - _t1263 := p.parse_rel_edb() - rel_edb639 := _t1263 - _t1264 := &pb.Data{} - _t1264.DataType = &pb.Data_RelEdb{RelEdb: rel_edb639} - _t1262 = _t1264 + var _t1250 *pb.Data + if prediction632 == 0 { + _t1251 := p.parse_edb() + edb633 := _t1251 + _t1252 := &pb.Data{} + _t1252.DataType = &pb.Data_Edb{Edb: edb633} + _t1250 = _t1252 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1259 = _t1262 + _t1247 = _t1250 } - _t1256 = _t1259 + _t1244 = _t1247 } - return _t1256 + return _t1244 } -func (p *Parser) parse_rel_edb() *pb.RelEDB { +func (p *Parser) parse_edb() *pb.EDB { p.consumeLiteral("(") - p.consumeLiteral("rel_edb") - _t1265 := p.parse_relation_id() - relation_id642 := _t1265 - _t1266 := p.parse_rel_edb_path() - rel_edb_path643 := _t1266 - _t1267 := p.parse_rel_edb_types() - rel_edb_types644 := _t1267 + p.consumeLiteral("edb") + _t1253 := p.parse_relation_id() + relation_id636 := _t1253 + _t1254 := p.parse_edb_path() + edb_path637 := _t1254 + _t1255 := p.parse_edb_types() + edb_types638 := _t1255 p.consumeLiteral(")") - _t1268 := &pb.RelEDB{TargetId: relation_id642, Path: rel_edb_path643, Types: rel_edb_types644} - return _t1268 + _t1256 := &pb.EDB{TargetId: relation_id636, Path: edb_path637, Types: edb_types638} + return _t1256 } -func (p *Parser) parse_rel_edb_path() []string { +func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs645 := []string{} - cond646 := p.matchLookaheadTerminal("STRING", 0) - for cond646 { - item647 := p.consumeTerminal("STRING").Value.str - xs645 = append(xs645, item647) - cond646 = p.matchLookaheadTerminal("STRING", 0) - } - strings648 := xs645 + xs639 := []string{} + cond640 := p.matchLookaheadTerminal("STRING", 0) + for cond640 { + item641 := p.consumeTerminal("STRING").Value.str + xs639 = append(xs639, item641) + cond640 = p.matchLookaheadTerminal("STRING", 0) + } + strings642 := xs639 p.consumeLiteral("]") - return strings648 + return strings642 } -func (p *Parser) parse_rel_edb_types() []*pb.Type { +func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs649 := []*pb.Type{} - cond650 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond650 { - _t1269 := p.parse_type() - item651 := _t1269 - xs649 = append(xs649, item651) - cond650 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types652 := xs649 + xs643 := []*pb.Type{} + cond644 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond644 { + _t1257 := p.parse_type() + item645 := _t1257 + xs643 = append(xs643, item645) + cond644 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types646 := xs643 p.consumeLiteral("]") - return types652 + return types646 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1270 := p.parse_relation_id() - relation_id653 := _t1270 - _t1271 := p.parse_betree_info() - betree_info654 := _t1271 + _t1258 := p.parse_relation_id() + relation_id647 := _t1258 + _t1259 := p.parse_betree_info() + betree_info648 := _t1259 p.consumeLiteral(")") - _t1272 := &pb.BeTreeRelation{Name: relation_id653, RelationInfo: betree_info654} - return _t1272 + _t1260 := &pb.BeTreeRelation{Name: relation_id647, RelationInfo: betree_info648} + return _t1260 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1273 := p.parse_betree_info_key_types() - betree_info_key_types655 := _t1273 - _t1274 := p.parse_betree_info_value_types() - betree_info_value_types656 := _t1274 - _t1275 := p.parse_config_dict() - config_dict657 := _t1275 + _t1261 := p.parse_betree_info_key_types() + betree_info_key_types649 := _t1261 + _t1262 := p.parse_betree_info_value_types() + betree_info_value_types650 := _t1262 + _t1263 := p.parse_config_dict() + config_dict651 := _t1263 p.consumeLiteral(")") - _t1276 := p.construct_betree_info(betree_info_key_types655, betree_info_value_types656, config_dict657) - return _t1276 + _t1264 := p.construct_betree_info(betree_info_key_types649, betree_info_value_types650, config_dict651) + return _t1264 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs658 := []*pb.Type{} - cond659 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond659 { - _t1277 := p.parse_type() - item660 := _t1277 - xs658 = append(xs658, item660) - cond659 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + xs652 := []*pb.Type{} + cond653 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond653 { + _t1265 := p.parse_type() + item654 := _t1265 + xs652 = append(xs652, item654) + cond653 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } - types661 := xs658 + types655 := xs652 p.consumeLiteral(")") - return types661 + return types655 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs662 := []*pb.Type{} - cond663 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond663 { - _t1278 := p.parse_type() - item664 := _t1278 - xs662 = append(xs662, item664) - cond663 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + xs656 := []*pb.Type{} + cond657 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond657 { + _t1266 := p.parse_type() + item658 := _t1266 + xs656 = append(xs656, item658) + cond657 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } - types665 := xs662 + types659 := xs656 p.consumeLiteral(")") - return types665 + return types659 } func (p *Parser) parse_csv_data() *pb.CSVData { p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1279 := p.parse_csvlocator() - csvlocator666 := _t1279 - _t1280 := p.parse_csv_config() - csv_config667 := _t1280 - _t1281 := p.parse_csv_columns() - csv_columns668 := _t1281 - _t1282 := p.parse_csv_asof() - csv_asof669 := _t1282 + _t1267 := p.parse_csvlocator() + csvlocator660 := _t1267 + _t1268 := p.parse_csv_config() + csv_config661 := _t1268 + _t1269 := p.parse_gnf_columns() + gnf_columns662 := _t1269 + _t1270 := p.parse_csv_asof() + csv_asof663 := _t1270 p.consumeLiteral(")") - _t1283 := &pb.CSVData{Locator: csvlocator666, Config: csv_config667, Columns: csv_columns668, Asof: csv_asof669} - return _t1283 + _t1271 := &pb.CSVData{Locator: csvlocator660, Config: csv_config661, Columns: gnf_columns662, Asof: csv_asof663} + return _t1271 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1284 []string + var _t1272 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1285 := p.parse_csv_locator_paths() - _t1284 = _t1285 + _t1273 := p.parse_csv_locator_paths() + _t1272 = _t1273 } - csv_locator_paths670 := _t1284 - var _t1286 *string + csv_locator_paths664 := _t1272 + var _t1274 *string if p.matchLookaheadLiteral("(", 0) { - _t1287 := p.parse_csv_locator_inline_data() - _t1286 = ptr(_t1287) + _t1275 := p.parse_csv_locator_inline_data() + _t1274 = ptr(_t1275) } - csv_locator_inline_data671 := _t1286 + csv_locator_inline_data665 := _t1274 p.consumeLiteral(")") - _t1288 := csv_locator_paths670 - if csv_locator_paths670 == nil { - _t1288 = []string{} + _t1276 := csv_locator_paths664 + if csv_locator_paths664 == nil { + _t1276 = []string{} } - _t1289 := &pb.CSVLocator{Paths: _t1288, InlineData: []byte(deref(csv_locator_inline_data671, ""))} - return _t1289 + _t1277 := &pb.CSVLocator{Paths: _t1276, InlineData: []byte(deref(csv_locator_inline_data665, ""))} + return _t1277 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs672 := []string{} - cond673 := p.matchLookaheadTerminal("STRING", 0) - for cond673 { - item674 := p.consumeTerminal("STRING").Value.str - xs672 = append(xs672, item674) - cond673 = p.matchLookaheadTerminal("STRING", 0) + xs666 := []string{} + cond667 := p.matchLookaheadTerminal("STRING", 0) + for cond667 { + item668 := p.consumeTerminal("STRING").Value.str + xs666 = append(xs666, item668) + cond667 = p.matchLookaheadTerminal("STRING", 0) } - strings675 := xs672 + strings669 := xs666 p.consumeLiteral(")") - return strings675 + return strings669 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - string676 := p.consumeTerminal("STRING").Value.str + string670 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string676 + return string670 } func (p *Parser) parse_csv_config() *pb.CSVConfig { p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1290 := p.parse_config_dict() - config_dict677 := _t1290 + _t1278 := p.parse_config_dict() + config_dict671 := _t1278 p.consumeLiteral(")") - _t1291 := p.construct_csv_config(config_dict677) - return _t1291 + _t1279 := p.construct_csv_config(config_dict671) + return _t1279 } -func (p *Parser) parse_csv_columns() []*pb.CSVColumn { +func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs678 := []*pb.CSVColumn{} - cond679 := p.matchLookaheadLiteral("(", 0) - for cond679 { - _t1292 := p.parse_csv_column() - item680 := _t1292 - xs678 = append(xs678, item680) - cond679 = p.matchLookaheadLiteral("(", 0) + xs672 := []*pb.GNFColumn{} + cond673 := p.matchLookaheadLiteral("(", 0) + for cond673 { + _t1280 := p.parse_gnf_column() + item674 := _t1280 + xs672 = append(xs672, item674) + cond673 = p.matchLookaheadLiteral("(", 0) } - csv_columns681 := xs678 + gnf_columns675 := xs672 p.consumeLiteral(")") - return csv_columns681 + return gnf_columns675 } -func (p *Parser) parse_csv_column() *pb.CSVColumn { +func (p *Parser) parse_gnf_column() *pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("column") - _t1293 := p.parse_csv_column_path() - csv_column_path682 := _t1293 - var _t1294 []interface{} - if ((p.matchLookaheadLiteral(":", 0) || p.matchLookaheadLiteral("[", 0)) || p.matchLookaheadTerminal("UINT128", 0)) { - _t1295 := p.parse_csv_column_tail() - _t1294 = _t1295 + _t1281 := p.parse_gnf_column_path() + gnf_column_path676 := _t1281 + var _t1282 *pb.RelationId + if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { + _t1283 := p.parse_relation_id() + _t1282 = _t1283 + } + relation_id677 := _t1282 + p.consumeLiteral("[") + xs678 := []*pb.Type{} + cond679 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond679 { + _t1284 := p.parse_type() + item680 := _t1284 + xs678 = append(xs678, item680) + cond679 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } - csv_column_tail683 := _t1294 + types681 := xs678 + p.consumeLiteral("]") p.consumeLiteral(")") - _t1296 := p.construct_csv_column(csv_column_path682, csv_column_tail683) - return _t1296 + _t1285 := &pb.GNFColumn{ColumnPath: gnf_column_path676, TargetId: relation_id677, Types: types681} + return _t1285 } -func (p *Parser) parse_csv_column_path() []string { - var _t1297 int64 +func (p *Parser) parse_gnf_column_path() []string { + var _t1286 int64 if p.matchLookaheadLiteral("[", 0) { - _t1297 = 1 + _t1286 = 1 } else { - var _t1298 int64 + var _t1287 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1298 = 0 - } else { - _t1298 = -1 - } - _t1297 = _t1298 - } - prediction684 := _t1297 - var _t1299 []string - if prediction684 == 1 { - p.consumeLiteral("[") - xs686 := []string{} - cond687 := p.matchLookaheadTerminal("STRING", 0) - for cond687 { - item688 := p.consumeTerminal("STRING").Value.str - xs686 = append(xs686, item688) - cond687 = p.matchLookaheadTerminal("STRING", 0) - } - strings689 := xs686 - p.consumeLiteral("]") - _t1299 = strings689 - } else { - var _t1300 []string - if prediction684 == 0 { - string685 := p.consumeTerminal("STRING").Value.str - _ = string685 - _t1300 = []string{string685} + _t1287 = 0 } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in csv_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) + _t1287 = -1 } - _t1299 = _t1300 + _t1286 = _t1287 } - return _t1299 -} - -func (p *Parser) parse_csv_column_tail() []interface{} { - var _t1301 int64 - if p.matchLookaheadLiteral("[", 0) { - _t1301 = 1 - } else { - var _t1302 int64 - if p.matchLookaheadLiteral(":", 0) { - _t1302 = 0 - } else { - var _t1303 int64 - if p.matchLookaheadTerminal("UINT128", 0) { - _t1303 = 0 - } else { - _t1303 = -1 - } - _t1302 = _t1303 - } - _t1301 = _t1302 - } - prediction690 := _t1301 - var _t1304 []interface{} - if prediction690 == 1 { + prediction682 := _t1286 + var _t1288 []string + if prediction682 == 1 { p.consumeLiteral("[") - xs696 := []*pb.Type{} - cond697 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond697 { - _t1305 := p.parse_type() - item698 := _t1305 - xs696 = append(xs696, item698) - cond697 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + xs684 := []string{} + cond685 := p.matchLookaheadTerminal("STRING", 0) + for cond685 { + item686 := p.consumeTerminal("STRING").Value.str + xs684 = append(xs684, item686) + cond685 = p.matchLookaheadTerminal("STRING", 0) } - types699 := xs696 + strings687 := xs684 p.consumeLiteral("]") - _t1304 = []interface{}{nil, types699} + _t1288 = strings687 } else { - var _t1306 []interface{} - if prediction690 == 0 { - _t1307 := p.parse_relation_id() - relation_id691 := _t1307 - p.consumeLiteral("[") - xs692 := []*pb.Type{} - cond693 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond693 { - _t1308 := p.parse_type() - item694 := _t1308 - xs692 = append(xs692, item694) - cond693 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types695 := xs692 - p.consumeLiteral("]") - _t1306 = []interface{}{relation_id691, types695} + var _t1289 []string + if prediction682 == 0 { + string683 := p.consumeTerminal("STRING").Value.str + _ = string683 + _t1289 = []string{string683} } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in csv_column_tail", p.lookahead(0).Type, p.lookahead(0).Value)}) + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1304 = _t1306 + _t1288 = _t1289 } - return _t1304 + return _t1288 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string700 := p.consumeTerminal("STRING").Value.str + string688 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string700 + return string688 } func (p *Parser) parse_undefine() *pb.Undefine { p.consumeLiteral("(") p.consumeLiteral("undefine") - _t1309 := p.parse_fragment_id() - fragment_id701 := _t1309 + _t1290 := p.parse_fragment_id() + fragment_id689 := _t1290 p.consumeLiteral(")") - _t1310 := &pb.Undefine{FragmentId: fragment_id701} - return _t1310 + _t1291 := &pb.Undefine{FragmentId: fragment_id689} + return _t1291 } func (p *Parser) parse_context() *pb.Context { p.consumeLiteral("(") p.consumeLiteral("context") - xs702 := []*pb.RelationId{} - cond703 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond703 { - _t1311 := p.parse_relation_id() - item704 := _t1311 - xs702 = append(xs702, item704) - cond703 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + xs690 := []*pb.RelationId{} + cond691 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond691 { + _t1292 := p.parse_relation_id() + item692 := _t1292 + xs690 = append(xs690, item692) + cond691 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) } - relation_ids705 := xs702 + relation_ids693 := xs690 p.consumeLiteral(")") - _t1312 := &pb.Context{Relations: relation_ids705} - return _t1312 + _t1293 := &pb.Context{Relations: relation_ids693} + return _t1293 } func (p *Parser) parse_snapshot() *pb.Snapshot { p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t1313 := p.parse_rel_edb_path() - rel_edb_path706 := _t1313 - _t1314 := p.parse_relation_id() - relation_id707 := _t1314 + _t1294 := p.parse_edb_path() + edb_path694 := _t1294 + _t1295 := p.parse_relation_id() + relation_id695 := _t1295 p.consumeLiteral(")") - _t1315 := &pb.Snapshot{DestinationPath: rel_edb_path706, SourceRelation: relation_id707} - return _t1315 + _t1296 := &pb.Snapshot{DestinationPath: edb_path694, SourceRelation: relation_id695} + return _t1296 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs708 := []*pb.Read{} - cond709 := p.matchLookaheadLiteral("(", 0) - for cond709 { - _t1316 := p.parse_read() - item710 := _t1316 - xs708 = append(xs708, item710) - cond709 = p.matchLookaheadLiteral("(", 0) + xs696 := []*pb.Read{} + cond697 := p.matchLookaheadLiteral("(", 0) + for cond697 { + _t1297 := p.parse_read() + item698 := _t1297 + xs696 = append(xs696, item698) + cond697 = p.matchLookaheadLiteral("(", 0) } - reads711 := xs708 + reads699 := xs696 p.consumeLiteral(")") - return reads711 + return reads699 } func (p *Parser) parse_read() *pb.Read { - var _t1317 int64 + var _t1298 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1318 int64 + var _t1299 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t1318 = 2 + _t1299 = 2 } else { - var _t1319 int64 + var _t1300 int64 if p.matchLookaheadLiteral("output", 1) { - _t1319 = 1 + _t1300 = 1 } else { - var _t1320 int64 + var _t1301 int64 if p.matchLookaheadLiteral("export", 1) { - _t1320 = 4 + _t1301 = 4 } else { - var _t1321 int64 + var _t1302 int64 if p.matchLookaheadLiteral("demand", 1) { - _t1321 = 0 + _t1302 = 0 } else { - var _t1322 int64 + var _t1303 int64 if p.matchLookaheadLiteral("abort", 1) { - _t1322 = 3 + _t1303 = 3 } else { - _t1322 = -1 + _t1303 = -1 } - _t1321 = _t1322 + _t1302 = _t1303 } - _t1320 = _t1321 + _t1301 = _t1302 } - _t1319 = _t1320 + _t1300 = _t1301 } - _t1318 = _t1319 + _t1299 = _t1300 } - _t1317 = _t1318 + _t1298 = _t1299 } else { - _t1317 = -1 - } - prediction712 := _t1317 - var _t1323 *pb.Read - if prediction712 == 4 { - _t1324 := p.parse_export() - export717 := _t1324 - _t1325 := &pb.Read{} - _t1325.ReadType = &pb.Read_Export{Export: export717} - _t1323 = _t1325 + _t1298 = -1 + } + prediction700 := _t1298 + var _t1304 *pb.Read + if prediction700 == 4 { + _t1305 := p.parse_export() + export705 := _t1305 + _t1306 := &pb.Read{} + _t1306.ReadType = &pb.Read_Export{Export: export705} + _t1304 = _t1306 } else { - var _t1326 *pb.Read - if prediction712 == 3 { - _t1327 := p.parse_abort() - abort716 := _t1327 - _t1328 := &pb.Read{} - _t1328.ReadType = &pb.Read_Abort{Abort: abort716} - _t1326 = _t1328 + var _t1307 *pb.Read + if prediction700 == 3 { + _t1308 := p.parse_abort() + abort704 := _t1308 + _t1309 := &pb.Read{} + _t1309.ReadType = &pb.Read_Abort{Abort: abort704} + _t1307 = _t1309 } else { - var _t1329 *pb.Read - if prediction712 == 2 { - _t1330 := p.parse_what_if() - what_if715 := _t1330 - _t1331 := &pb.Read{} - _t1331.ReadType = &pb.Read_WhatIf{WhatIf: what_if715} - _t1329 = _t1331 + var _t1310 *pb.Read + if prediction700 == 2 { + _t1311 := p.parse_what_if() + what_if703 := _t1311 + _t1312 := &pb.Read{} + _t1312.ReadType = &pb.Read_WhatIf{WhatIf: what_if703} + _t1310 = _t1312 } else { - var _t1332 *pb.Read - if prediction712 == 1 { - _t1333 := p.parse_output() - output714 := _t1333 - _t1334 := &pb.Read{} - _t1334.ReadType = &pb.Read_Output{Output: output714} - _t1332 = _t1334 + var _t1313 *pb.Read + if prediction700 == 1 { + _t1314 := p.parse_output() + output702 := _t1314 + _t1315 := &pb.Read{} + _t1315.ReadType = &pb.Read_Output{Output: output702} + _t1313 = _t1315 } else { - var _t1335 *pb.Read - if prediction712 == 0 { - _t1336 := p.parse_demand() - demand713 := _t1336 - _t1337 := &pb.Read{} - _t1337.ReadType = &pb.Read_Demand{Demand: demand713} - _t1335 = _t1337 + var _t1316 *pb.Read + if prediction700 == 0 { + _t1317 := p.parse_demand() + demand701 := _t1317 + _t1318 := &pb.Read{} + _t1318.ReadType = &pb.Read_Demand{Demand: demand701} + _t1316 = _t1318 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1332 = _t1335 + _t1313 = _t1316 } - _t1329 = _t1332 + _t1310 = _t1313 } - _t1326 = _t1329 + _t1307 = _t1310 } - _t1323 = _t1326 + _t1304 = _t1307 } - return _t1323 + return _t1304 } func (p *Parser) parse_demand() *pb.Demand { p.consumeLiteral("(") p.consumeLiteral("demand") - _t1338 := p.parse_relation_id() - relation_id718 := _t1338 + _t1319 := p.parse_relation_id() + relation_id706 := _t1319 p.consumeLiteral(")") - _t1339 := &pb.Demand{RelationId: relation_id718} - return _t1339 + _t1320 := &pb.Demand{RelationId: relation_id706} + return _t1320 } func (p *Parser) parse_output() *pb.Output { p.consumeLiteral("(") p.consumeLiteral("output") - _t1340 := p.parse_name() - name719 := _t1340 - _t1341 := p.parse_relation_id() - relation_id720 := _t1341 + _t1321 := p.parse_name() + name707 := _t1321 + _t1322 := p.parse_relation_id() + relation_id708 := _t1322 p.consumeLiteral(")") - _t1342 := &pb.Output{Name: name719, RelationId: relation_id720} - return _t1342 + _t1323 := &pb.Output{Name: name707, RelationId: relation_id708} + return _t1323 } func (p *Parser) parse_what_if() *pb.WhatIf { p.consumeLiteral("(") p.consumeLiteral("what_if") - _t1343 := p.parse_name() - name721 := _t1343 - _t1344 := p.parse_epoch() - epoch722 := _t1344 + _t1324 := p.parse_name() + name709 := _t1324 + _t1325 := p.parse_epoch() + epoch710 := _t1325 p.consumeLiteral(")") - _t1345 := &pb.WhatIf{Branch: name721, Epoch: epoch722} - return _t1345 + _t1326 := &pb.WhatIf{Branch: name709, Epoch: epoch710} + return _t1326 } func (p *Parser) parse_abort() *pb.Abort { p.consumeLiteral("(") p.consumeLiteral("abort") - var _t1346 *string + var _t1327 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t1347 := p.parse_name() - _t1346 = ptr(_t1347) + _t1328 := p.parse_name() + _t1327 = ptr(_t1328) } - name723 := _t1346 - _t1348 := p.parse_relation_id() - relation_id724 := _t1348 + name711 := _t1327 + _t1329 := p.parse_relation_id() + relation_id712 := _t1329 p.consumeLiteral(")") - _t1349 := &pb.Abort{Name: deref(name723, "abort"), RelationId: relation_id724} - return _t1349 + _t1330 := &pb.Abort{Name: deref(name711, "abort"), RelationId: relation_id712} + return _t1330 } func (p *Parser) parse_export() *pb.Export { p.consumeLiteral("(") p.consumeLiteral("export") - _t1350 := p.parse_export_csv_config() - export_csv_config725 := _t1350 + _t1331 := p.parse_export_csv_config() + export_csv_config713 := _t1331 p.consumeLiteral(")") - _t1351 := &pb.Export{} - _t1351.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config725} - return _t1351 + _t1332 := &pb.Export{} + _t1332.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config713} + return _t1332 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t1352 := p.parse_export_csv_path() - export_csv_path726 := _t1352 - _t1353 := p.parse_export_csv_columns() - export_csv_columns727 := _t1353 - _t1354 := p.parse_config_dict() - config_dict728 := _t1354 + _t1333 := p.parse_export_csv_path() + export_csv_path714 := _t1333 + _t1334 := p.parse_export_csv_columns() + export_csv_columns715 := _t1334 + _t1335 := p.parse_config_dict() + config_dict716 := _t1335 p.consumeLiteral(")") - _t1355 := p.export_csv_config(export_csv_path726, export_csv_columns727, config_dict728) - return _t1355 + _t1336 := p.export_csv_config(export_csv_path714, export_csv_columns715, config_dict716) + return _t1336 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string729 := p.consumeTerminal("STRING").Value.str + string717 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string729 + return string717 } func (p *Parser) parse_export_csv_columns() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs730 := []*pb.ExportCSVColumn{} - cond731 := p.matchLookaheadLiteral("(", 0) - for cond731 { - _t1356 := p.parse_export_csv_column() - item732 := _t1356 - xs730 = append(xs730, item732) - cond731 = p.matchLookaheadLiteral("(", 0) + xs718 := []*pb.ExportCSVColumn{} + cond719 := p.matchLookaheadLiteral("(", 0) + for cond719 { + _t1337 := p.parse_export_csv_column() + item720 := _t1337 + xs718 = append(xs718, item720) + cond719 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns733 := xs730 + export_csv_columns721 := xs718 p.consumeLiteral(")") - return export_csv_columns733 + return export_csv_columns721 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("column") - string734 := p.consumeTerminal("STRING").Value.str - _t1357 := p.parse_relation_id() - relation_id735 := _t1357 + string722 := p.consumeTerminal("STRING").Value.str + _t1338 := p.parse_relation_id() + relation_id723 := _t1338 p.consumeLiteral(")") - _t1358 := &pb.ExportCSVColumn{ColumnName: string734, ColumnData: relation_id735} - return _t1358 + _t1339 := &pb.ExportCSVColumn{ColumnName: string722, ColumnData: relation_id723} + return _t1339 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index ec98bfae..49f7e094 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -311,166 +311,157 @@ func formatBool(b bool) string { // --- Helper functions --- func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1698 := &pb.Value{} - _t1698.Value = &pb.Value_IntValue{IntValue: int64(v)} - return _t1698 + _t1677 := &pb.Value{} + _t1677.Value = &pb.Value_IntValue{IntValue: int64(v)} + return _t1677 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1699 := &pb.Value{} - _t1699.Value = &pb.Value_IntValue{IntValue: v} - return _t1699 + _t1678 := &pb.Value{} + _t1678.Value = &pb.Value_IntValue{IntValue: v} + return _t1678 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1700 := &pb.Value{} - _t1700.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1700 + _t1679 := &pb.Value{} + _t1679.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1679 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1701 := &pb.Value{} - _t1701.Value = &pb.Value_StringValue{StringValue: v} - return _t1701 + _t1680 := &pb.Value{} + _t1680.Value = &pb.Value_StringValue{StringValue: v} + return _t1680 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1702 := &pb.Value{} - _t1702.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1702 + _t1681 := &pb.Value{} + _t1681.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1681 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1703 := &pb.Value{} - _t1703.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1703 + _t1682 := &pb.Value{} + _t1682.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1682 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1704 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1704}) + _t1683 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1683}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1705 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1705}) + _t1684 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1684}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1706 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1706}) + _t1685 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1685}) } } } - _t1707 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1707}) + _t1686 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1686}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1708 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1708}) - _t1709 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1709}) + _t1687 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1687}) + _t1688 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1688}) if msg.GetNewLine() != "" { - _t1710 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1710}) - } - _t1711 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1711}) - _t1712 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1712}) - _t1713 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1713}) + _t1689 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1689}) + } + _t1690 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1690}) + _t1691 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1691}) + _t1692 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1692}) if msg.GetComment() != "" { - _t1714 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1714}) + _t1693 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1693}) } for _, missing_string := range msg.GetMissingStrings() { - _t1715 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1715}) - } - _t1716 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1716}) - _t1717 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1717}) - _t1718 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1718}) + _t1694 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1694}) + } + _t1695 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1695}) + _t1696 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1696}) + _t1697 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1697}) return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1719 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1719}) - _t1720 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1720}) - _t1721 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1721}) - _t1722 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1722}) + _t1698 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1698}) + _t1699 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1699}) + _t1700 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1700}) + _t1701 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1701}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1723 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1723}) + _t1702 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1702}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1724 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1724}) + _t1703 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1703}) } } - _t1725 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1725}) - _t1726 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1726}) + _t1704 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1704}) + _t1705 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1705}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1727 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1727}) + _t1706 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1706}) } if msg.Compression != nil { - _t1728 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1728}) + _t1707 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1707}) } if msg.SyntaxHeaderRow != nil { - _t1729 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1729}) + _t1708 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1708}) } if msg.SyntaxMissingString != nil { - _t1730 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1730}) + _t1709 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1709}) } if msg.SyntaxDelim != nil { - _t1731 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1731}) + _t1710 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1710}) } if msg.SyntaxQuotechar != nil { - _t1732 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1732}) + _t1711 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1711}) } if msg.SyntaxEscapechar != nil { - _t1733 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1733}) + _t1712 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1712}) } return listSort(result) } -func (p *PrettyPrinter) deconstruct_csv_column_tail(col *pb.CSVColumn) []interface{} { - var _t1734 interface{} - if (hasProtoField(col, "target_id") || !(len(col.GetTypes()) == 0)) { - return []interface{}{col.GetTargetId(), col.GetTypes()} - } - _ = _t1734 - return nil -} - func (p *PrettyPrinter) deconstruct_relation_id_string(msg *pb.RelationId) string { name := p.relationIdToString(msg) return *name @@ -478,11 +469,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 _t1735 interface{} + var _t1713 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1735 + _ = _t1713 return nil } @@ -500,48 +491,48 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat654 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat654 != nil { - p.write(*flat654) + flat646 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat646 != nil { + p.write(*flat646) return nil } else { - _t1290 := func(_dollar_dollar *pb.Transaction) []interface{} { - var _t1291 *pb.Configure + _t1274 := func(_dollar_dollar *pb.Transaction) []interface{} { + var _t1275 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1291 = _dollar_dollar.GetConfigure() + _t1275 = _dollar_dollar.GetConfigure() } - var _t1292 *pb.Sync + var _t1276 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1292 = _dollar_dollar.GetSync() + _t1276 = _dollar_dollar.GetSync() } - return []interface{}{_t1291, _t1292, _dollar_dollar.GetEpochs()} + return []interface{}{_t1275, _t1276, _dollar_dollar.GetEpochs()} } - _t1293 := _t1290(msg) - fields645 := _t1293 - unwrapped_fields646 := fields645 + _t1277 := _t1274(msg) + fields637 := _t1277 + unwrapped_fields638 := fields637 p.write("(") p.write("transaction") p.indentSexp() - field647 := unwrapped_fields646[0].(*pb.Configure) - if field647 != nil { + field639 := unwrapped_fields638[0].(*pb.Configure) + if field639 != nil { p.newline() - opt_val648 := field647 - p.pretty_configure(opt_val648) + opt_val640 := field639 + p.pretty_configure(opt_val640) } - field649 := unwrapped_fields646[1].(*pb.Sync) - if field649 != nil { + field641 := unwrapped_fields638[1].(*pb.Sync) + if field641 != nil { p.newline() - opt_val650 := field649 - p.pretty_sync(opt_val650) + opt_val642 := field641 + p.pretty_sync(opt_val642) } - field651 := unwrapped_fields646[2].([]*pb.Epoch) - if !(len(field651) == 0) { + field643 := unwrapped_fields638[2].([]*pb.Epoch) + if !(len(field643) == 0) { p.newline() - for i653, elem652 := range field651 { - if (i653 > 0) { + for i645, elem644 := range field643 { + if (i645 > 0) { p.newline() } - p.pretty_epoch(elem652) + p.pretty_epoch(elem644) } } p.dedent() @@ -551,23 +542,23 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat657 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat657 != nil { - p.write(*flat657) + flat649 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat649 != nil { + p.write(*flat649) return nil } else { - _t1294 := func(_dollar_dollar *pb.Configure) [][]interface{} { - _t1295 := p.deconstruct_configure(_dollar_dollar) - return _t1295 + _t1278 := func(_dollar_dollar *pb.Configure) [][]interface{} { + _t1279 := p.deconstruct_configure(_dollar_dollar) + return _t1279 } - _t1296 := _t1294(msg) - fields655 := _t1296 - unwrapped_fields656 := fields655 + _t1280 := _t1278(msg) + fields647 := _t1280 + unwrapped_fields648 := fields647 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields656) + p.pretty_config_dict(unwrapped_fields648) p.dedent() p.write(")") } @@ -575,21 +566,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat661 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat661 != nil { - p.write(*flat661) + flat653 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat653 != nil { + p.write(*flat653) return nil } else { - fields658 := msg + fields650 := msg p.write("{") p.indent() - if !(len(fields658) == 0) { + if !(len(fields650) == 0) { p.newline() - for i660, elem659 := range fields658 { - if (i660 > 0) { + for i652, elem651 := range fields650 { + if (i652 > 0) { p.newline() } - p.pretty_config_key_value(elem659) + p.pretty_config_key_value(elem651) } } p.dedent() @@ -599,152 +590,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat666 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat666 != nil { - p.write(*flat666) + flat658 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat658 != nil { + p.write(*flat658) return nil } else { - _t1297 := func(_dollar_dollar []interface{}) []interface{} { + _t1281 := func(_dollar_dollar []interface{}) []interface{} { return []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} } - _t1298 := _t1297(msg) - fields662 := _t1298 - unwrapped_fields663 := fields662 + _t1282 := _t1281(msg) + fields654 := _t1282 + unwrapped_fields655 := fields654 p.write(":") - field664 := unwrapped_fields663[0].(string) - p.write(field664) + field656 := unwrapped_fields655[0].(string) + p.write(field656) p.write(" ") - field665 := unwrapped_fields663[1].(*pb.Value) - p.pretty_value(field665) + field657 := unwrapped_fields655[1].(*pb.Value) + p.pretty_value(field657) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat686 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat686 != nil { - p.write(*flat686) + flat678 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat678 != nil { + p.write(*flat678) return nil } else { - _t1299 := func(_dollar_dollar *pb.Value) *pb.DateValue { - var _t1300 *pb.DateValue + _t1283 := func(_dollar_dollar *pb.Value) *pb.DateValue { + var _t1284 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1300 = _dollar_dollar.GetDateValue() + _t1284 = _dollar_dollar.GetDateValue() } - return _t1300 + return _t1284 } - _t1301 := _t1299(msg) - deconstruct_result684 := _t1301 - if deconstruct_result684 != nil { - unwrapped685 := deconstruct_result684 - p.pretty_date(unwrapped685) + _t1285 := _t1283(msg) + deconstruct_result676 := _t1285 + if deconstruct_result676 != nil { + unwrapped677 := deconstruct_result676 + p.pretty_date(unwrapped677) } else { - _t1302 := func(_dollar_dollar *pb.Value) *pb.DateTimeValue { - var _t1303 *pb.DateTimeValue + _t1286 := func(_dollar_dollar *pb.Value) *pb.DateTimeValue { + var _t1287 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1303 = _dollar_dollar.GetDatetimeValue() + _t1287 = _dollar_dollar.GetDatetimeValue() } - return _t1303 + return _t1287 } - _t1304 := _t1302(msg) - deconstruct_result682 := _t1304 - if deconstruct_result682 != nil { - unwrapped683 := deconstruct_result682 - p.pretty_datetime(unwrapped683) + _t1288 := _t1286(msg) + deconstruct_result674 := _t1288 + if deconstruct_result674 != nil { + unwrapped675 := deconstruct_result674 + p.pretty_datetime(unwrapped675) } else { - _t1305 := func(_dollar_dollar *pb.Value) *string { - var _t1306 *string + _t1289 := func(_dollar_dollar *pb.Value) *string { + var _t1290 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1306 = ptr(_dollar_dollar.GetStringValue()) + _t1290 = ptr(_dollar_dollar.GetStringValue()) } - return _t1306 + return _t1290 } - _t1307 := _t1305(msg) - deconstruct_result680 := _t1307 - if deconstruct_result680 != nil { - unwrapped681 := *deconstruct_result680 - p.write(p.formatStringValue(unwrapped681)) + _t1291 := _t1289(msg) + deconstruct_result672 := _t1291 + if deconstruct_result672 != nil { + unwrapped673 := *deconstruct_result672 + p.write(p.formatStringValue(unwrapped673)) } else { - _t1308 := func(_dollar_dollar *pb.Value) *int64 { - var _t1309 *int64 + _t1292 := func(_dollar_dollar *pb.Value) *int64 { + var _t1293 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1309 = ptr(_dollar_dollar.GetIntValue()) + _t1293 = ptr(_dollar_dollar.GetIntValue()) } - return _t1309 + return _t1293 } - _t1310 := _t1308(msg) - deconstruct_result678 := _t1310 - if deconstruct_result678 != nil { - unwrapped679 := *deconstruct_result678 - p.write(fmt.Sprintf("%d", unwrapped679)) + _t1294 := _t1292(msg) + deconstruct_result670 := _t1294 + if deconstruct_result670 != nil { + unwrapped671 := *deconstruct_result670 + p.write(fmt.Sprintf("%d", unwrapped671)) } else { - _t1311 := func(_dollar_dollar *pb.Value) *float64 { - var _t1312 *float64 + _t1295 := func(_dollar_dollar *pb.Value) *float64 { + var _t1296 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1312 = ptr(_dollar_dollar.GetFloatValue()) + _t1296 = ptr(_dollar_dollar.GetFloatValue()) } - return _t1312 + return _t1296 } - _t1313 := _t1311(msg) - deconstruct_result676 := _t1313 - if deconstruct_result676 != nil { - unwrapped677 := *deconstruct_result676 - p.write(formatFloat64(unwrapped677)) + _t1297 := _t1295(msg) + deconstruct_result668 := _t1297 + if deconstruct_result668 != nil { + unwrapped669 := *deconstruct_result668 + p.write(formatFloat64(unwrapped669)) } else { - _t1314 := func(_dollar_dollar *pb.Value) *pb.UInt128Value { - var _t1315 *pb.UInt128Value + _t1298 := func(_dollar_dollar *pb.Value) *pb.UInt128Value { + var _t1299 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1315 = _dollar_dollar.GetUint128Value() + _t1299 = _dollar_dollar.GetUint128Value() } - return _t1315 + return _t1299 } - _t1316 := _t1314(msg) - deconstruct_result674 := _t1316 - if deconstruct_result674 != nil { - unwrapped675 := deconstruct_result674 - p.write(p.formatUint128(unwrapped675)) + _t1300 := _t1298(msg) + deconstruct_result666 := _t1300 + if deconstruct_result666 != nil { + unwrapped667 := deconstruct_result666 + p.write(p.formatUint128(unwrapped667)) } else { - _t1317 := func(_dollar_dollar *pb.Value) *pb.Int128Value { - var _t1318 *pb.Int128Value + _t1301 := func(_dollar_dollar *pb.Value) *pb.Int128Value { + var _t1302 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1318 = _dollar_dollar.GetInt128Value() + _t1302 = _dollar_dollar.GetInt128Value() } - return _t1318 + return _t1302 } - _t1319 := _t1317(msg) - deconstruct_result672 := _t1319 - if deconstruct_result672 != nil { - unwrapped673 := deconstruct_result672 - p.write(p.formatInt128(unwrapped673)) + _t1303 := _t1301(msg) + deconstruct_result664 := _t1303 + if deconstruct_result664 != nil { + unwrapped665 := deconstruct_result664 + p.write(p.formatInt128(unwrapped665)) } else { - _t1320 := func(_dollar_dollar *pb.Value) *pb.DecimalValue { - var _t1321 *pb.DecimalValue + _t1304 := func(_dollar_dollar *pb.Value) *pb.DecimalValue { + var _t1305 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1321 = _dollar_dollar.GetDecimalValue() + _t1305 = _dollar_dollar.GetDecimalValue() } - return _t1321 + return _t1305 } - _t1322 := _t1320(msg) - deconstruct_result670 := _t1322 - if deconstruct_result670 != nil { - unwrapped671 := deconstruct_result670 - p.write(p.formatDecimal(unwrapped671)) + _t1306 := _t1304(msg) + deconstruct_result662 := _t1306 + if deconstruct_result662 != nil { + unwrapped663 := deconstruct_result662 + p.write(p.formatDecimal(unwrapped663)) } else { - _t1323 := func(_dollar_dollar *pb.Value) *bool { - var _t1324 *bool + _t1307 := func(_dollar_dollar *pb.Value) *bool { + var _t1308 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1324 = ptr(_dollar_dollar.GetBooleanValue()) + _t1308 = ptr(_dollar_dollar.GetBooleanValue()) } - return _t1324 + return _t1308 } - _t1325 := _t1323(msg) - deconstruct_result668 := _t1325 - if deconstruct_result668 != nil { - unwrapped669 := *deconstruct_result668 - p.pretty_boolean_value(unwrapped669) + _t1309 := _t1307(msg) + deconstruct_result660 := _t1309 + if deconstruct_result660 != nil { + unwrapped661 := *deconstruct_result660 + p.pretty_boolean_value(unwrapped661) } else { - fields667 := msg - _ = fields667 + fields659 := msg + _ = fields659 p.write("missing") } } @@ -760,29 +751,29 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat692 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat692 != nil { - p.write(*flat692) + flat684 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat684 != nil { + p.write(*flat684) return nil } else { - _t1326 := func(_dollar_dollar *pb.DateValue) []interface{} { + _t1310 := func(_dollar_dollar *pb.DateValue) []interface{} { return []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} } - _t1327 := _t1326(msg) - fields687 := _t1327 - unwrapped_fields688 := fields687 + _t1311 := _t1310(msg) + fields679 := _t1311 + unwrapped_fields680 := fields679 p.write("(") p.write("date") p.indentSexp() p.newline() - field689 := unwrapped_fields688[0].(int64) - p.write(fmt.Sprintf("%d", field689)) + field681 := unwrapped_fields680[0].(int64) + p.write(fmt.Sprintf("%d", field681)) p.newline() - field690 := unwrapped_fields688[1].(int64) - p.write(fmt.Sprintf("%d", field690)) + field682 := unwrapped_fields680[1].(int64) + p.write(fmt.Sprintf("%d", field682)) p.newline() - field691 := unwrapped_fields688[2].(int64) - p.write(fmt.Sprintf("%d", field691)) + field683 := unwrapped_fields680[2].(int64) + p.write(fmt.Sprintf("%d", field683)) p.dedent() p.write(")") } @@ -790,43 +781,43 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat703 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat703 != nil { - p.write(*flat703) + flat695 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat695 != nil { + p.write(*flat695) return nil } else { - _t1328 := func(_dollar_dollar *pb.DateTimeValue) []interface{} { + _t1312 := func(_dollar_dollar *pb.DateTimeValue) []interface{} { return []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()))} } - _t1329 := _t1328(msg) - fields693 := _t1329 - unwrapped_fields694 := fields693 + _t1313 := _t1312(msg) + fields685 := _t1313 + unwrapped_fields686 := fields685 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field695 := unwrapped_fields694[0].(int64) - p.write(fmt.Sprintf("%d", field695)) + field687 := unwrapped_fields686[0].(int64) + p.write(fmt.Sprintf("%d", field687)) p.newline() - field696 := unwrapped_fields694[1].(int64) - p.write(fmt.Sprintf("%d", field696)) + field688 := unwrapped_fields686[1].(int64) + p.write(fmt.Sprintf("%d", field688)) p.newline() - field697 := unwrapped_fields694[2].(int64) - p.write(fmt.Sprintf("%d", field697)) + field689 := unwrapped_fields686[2].(int64) + p.write(fmt.Sprintf("%d", field689)) p.newline() - field698 := unwrapped_fields694[3].(int64) - p.write(fmt.Sprintf("%d", field698)) + field690 := unwrapped_fields686[3].(int64) + p.write(fmt.Sprintf("%d", field690)) p.newline() - field699 := unwrapped_fields694[4].(int64) - p.write(fmt.Sprintf("%d", field699)) + field691 := unwrapped_fields686[4].(int64) + p.write(fmt.Sprintf("%d", field691)) p.newline() - field700 := unwrapped_fields694[5].(int64) - p.write(fmt.Sprintf("%d", field700)) - field701 := unwrapped_fields694[6].(*int64) - if field701 != nil { + field692 := unwrapped_fields686[5].(int64) + p.write(fmt.Sprintf("%d", field692)) + field693 := unwrapped_fields686[6].(*int64) + if field693 != nil { p.newline() - opt_val702 := *field701 - p.write(fmt.Sprintf("%d", opt_val702)) + opt_val694 := *field693 + p.write(fmt.Sprintf("%d", opt_val694)) } p.dedent() p.write(")") @@ -835,32 +826,32 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { - _t1330 := func(_dollar_dollar bool) []interface{} { - var _t1331 []interface{} + _t1314 := func(_dollar_dollar bool) []interface{} { + var _t1315 []interface{} if _dollar_dollar { - _t1331 = []interface{}{} + _t1315 = []interface{}{} } - return _t1331 + return _t1315 } - _t1332 := _t1330(msg) - deconstruct_result706 := _t1332 - if deconstruct_result706 != nil { - unwrapped707 := deconstruct_result706 - _ = unwrapped707 + _t1316 := _t1314(msg) + deconstruct_result698 := _t1316 + if deconstruct_result698 != nil { + unwrapped699 := deconstruct_result698 + _ = unwrapped699 p.write("true") } else { - _t1333 := func(_dollar_dollar bool) []interface{} { - var _t1334 []interface{} + _t1317 := func(_dollar_dollar bool) []interface{} { + var _t1318 []interface{} if !(_dollar_dollar) { - _t1334 = []interface{}{} + _t1318 = []interface{}{} } - return _t1334 + return _t1318 } - _t1335 := _t1333(msg) - deconstruct_result704 := _t1335 - if deconstruct_result704 != nil { - unwrapped705 := deconstruct_result704 - _ = unwrapped705 + _t1319 := _t1317(msg) + deconstruct_result696 := _t1319 + if deconstruct_result696 != nil { + unwrapped697 := deconstruct_result696 + _ = unwrapped697 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -870,27 +861,27 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat712 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat712 != nil { - p.write(*flat712) + flat704 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat704 != nil { + p.write(*flat704) return nil } else { - _t1336 := func(_dollar_dollar *pb.Sync) []*pb.FragmentId { + _t1320 := func(_dollar_dollar *pb.Sync) []*pb.FragmentId { return _dollar_dollar.GetFragments() } - _t1337 := _t1336(msg) - fields708 := _t1337 - unwrapped_fields709 := fields708 + _t1321 := _t1320(msg) + fields700 := _t1321 + unwrapped_fields701 := fields700 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields709) == 0) { + if !(len(unwrapped_fields701) == 0) { p.newline() - for i711, elem710 := range unwrapped_fields709 { - if (i711 > 0) { + for i703, elem702 := range unwrapped_fields701 { + if (i703 > 0) { p.newline() } - p.pretty_fragment_id(elem710) + p.pretty_fragment_id(elem702) } } p.dedent() @@ -900,57 +891,57 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat715 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat715 != nil { - p.write(*flat715) + flat707 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat707 != nil { + p.write(*flat707) return nil } else { - _t1338 := func(_dollar_dollar *pb.FragmentId) string { + _t1322 := func(_dollar_dollar *pb.FragmentId) string { return p.fragmentIdToString(_dollar_dollar) } - _t1339 := _t1338(msg) - fields713 := _t1339 - unwrapped_fields714 := fields713 + _t1323 := _t1322(msg) + fields705 := _t1323 + unwrapped_fields706 := fields705 p.write(":") - p.write(unwrapped_fields714) + p.write(unwrapped_fields706) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat722 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat722 != nil { - p.write(*flat722) + flat714 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat714 != nil { + p.write(*flat714) return nil } else { - _t1340 := func(_dollar_dollar *pb.Epoch) []interface{} { - var _t1341 []*pb.Write + _t1324 := func(_dollar_dollar *pb.Epoch) []interface{} { + var _t1325 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1341 = _dollar_dollar.GetWrites() + _t1325 = _dollar_dollar.GetWrites() } - var _t1342 []*pb.Read + var _t1326 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1342 = _dollar_dollar.GetReads() + _t1326 = _dollar_dollar.GetReads() } - return []interface{}{_t1341, _t1342} + return []interface{}{_t1325, _t1326} } - _t1343 := _t1340(msg) - fields716 := _t1343 - unwrapped_fields717 := fields716 + _t1327 := _t1324(msg) + fields708 := _t1327 + unwrapped_fields709 := fields708 p.write("(") p.write("epoch") p.indentSexp() - field718 := unwrapped_fields717[0].([]*pb.Write) - if field718 != nil { + field710 := unwrapped_fields709[0].([]*pb.Write) + if field710 != nil { p.newline() - opt_val719 := field718 - p.pretty_epoch_writes(opt_val719) + opt_val711 := field710 + p.pretty_epoch_writes(opt_val711) } - field720 := unwrapped_fields717[1].([]*pb.Read) - if field720 != nil { + field712 := unwrapped_fields709[1].([]*pb.Read) + if field712 != nil { p.newline() - opt_val721 := field720 - p.pretty_epoch_reads(opt_val721) + opt_val713 := field712 + p.pretty_epoch_reads(opt_val713) } p.dedent() p.write(")") @@ -959,22 +950,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat726 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat726 != nil { - p.write(*flat726) + flat718 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat718 != nil { + p.write(*flat718) return nil } else { - fields723 := msg + fields715 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields723) == 0) { + if !(len(fields715) == 0) { p.newline() - for i725, elem724 := range fields723 { - if (i725 > 0) { + for i717, elem716 := range fields715 { + if (i717 > 0) { p.newline() } - p.pretty_write(elem724) + p.pretty_write(elem716) } } p.dedent() @@ -984,62 +975,62 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat735 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat735 != nil { - p.write(*flat735) + flat727 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat727 != nil { + p.write(*flat727) return nil } else { - _t1344 := func(_dollar_dollar *pb.Write) *pb.Define { - var _t1345 *pb.Define + _t1328 := func(_dollar_dollar *pb.Write) *pb.Define { + var _t1329 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1345 = _dollar_dollar.GetDefine() + _t1329 = _dollar_dollar.GetDefine() } - return _t1345 + return _t1329 } - _t1346 := _t1344(msg) - deconstruct_result733 := _t1346 - if deconstruct_result733 != nil { - unwrapped734 := deconstruct_result733 - p.pretty_define(unwrapped734) + _t1330 := _t1328(msg) + deconstruct_result725 := _t1330 + if deconstruct_result725 != nil { + unwrapped726 := deconstruct_result725 + p.pretty_define(unwrapped726) } else { - _t1347 := func(_dollar_dollar *pb.Write) *pb.Undefine { - var _t1348 *pb.Undefine + _t1331 := func(_dollar_dollar *pb.Write) *pb.Undefine { + var _t1332 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1348 = _dollar_dollar.GetUndefine() + _t1332 = _dollar_dollar.GetUndefine() } - return _t1348 + return _t1332 } - _t1349 := _t1347(msg) - deconstruct_result731 := _t1349 - if deconstruct_result731 != nil { - unwrapped732 := deconstruct_result731 - p.pretty_undefine(unwrapped732) + _t1333 := _t1331(msg) + deconstruct_result723 := _t1333 + if deconstruct_result723 != nil { + unwrapped724 := deconstruct_result723 + p.pretty_undefine(unwrapped724) } else { - _t1350 := func(_dollar_dollar *pb.Write) *pb.Context { - var _t1351 *pb.Context + _t1334 := func(_dollar_dollar *pb.Write) *pb.Context { + var _t1335 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1351 = _dollar_dollar.GetContext() + _t1335 = _dollar_dollar.GetContext() } - return _t1351 + return _t1335 } - _t1352 := _t1350(msg) - deconstruct_result729 := _t1352 - if deconstruct_result729 != nil { - unwrapped730 := deconstruct_result729 - p.pretty_context(unwrapped730) + _t1336 := _t1334(msg) + deconstruct_result721 := _t1336 + if deconstruct_result721 != nil { + unwrapped722 := deconstruct_result721 + p.pretty_context(unwrapped722) } else { - _t1353 := func(_dollar_dollar *pb.Write) *pb.Snapshot { - var _t1354 *pb.Snapshot + _t1337 := func(_dollar_dollar *pb.Write) *pb.Snapshot { + var _t1338 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1354 = _dollar_dollar.GetSnapshot() + _t1338 = _dollar_dollar.GetSnapshot() } - return _t1354 + return _t1338 } - _t1355 := _t1353(msg) - deconstruct_result727 := _t1355 - if deconstruct_result727 != nil { - unwrapped728 := deconstruct_result727 - p.pretty_snapshot(unwrapped728) + _t1339 := _t1337(msg) + deconstruct_result719 := _t1339 + if deconstruct_result719 != nil { + unwrapped720 := deconstruct_result719 + p.pretty_snapshot(unwrapped720) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1051,22 +1042,22 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat738 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat738 != nil { - p.write(*flat738) + flat730 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat730 != nil { + p.write(*flat730) return nil } else { - _t1356 := func(_dollar_dollar *pb.Define) *pb.Fragment { + _t1340 := func(_dollar_dollar *pb.Define) *pb.Fragment { return _dollar_dollar.GetFragment() } - _t1357 := _t1356(msg) - fields736 := _t1357 - unwrapped_fields737 := fields736 + _t1341 := _t1340(msg) + fields728 := _t1341 + unwrapped_fields729 := fields728 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields737) + p.pretty_fragment(unwrapped_fields729) p.dedent() p.write(")") } @@ -1074,32 +1065,32 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat745 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat745 != nil { - p.write(*flat745) + flat737 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat737 != nil { + p.write(*flat737) return nil } else { - _t1358 := func(_dollar_dollar *pb.Fragment) []interface{} { + _t1342 := func(_dollar_dollar *pb.Fragment) []interface{} { p.startPrettyFragment(_dollar_dollar) return []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} } - _t1359 := _t1358(msg) - fields739 := _t1359 - unwrapped_fields740 := fields739 + _t1343 := _t1342(msg) + fields731 := _t1343 + unwrapped_fields732 := fields731 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field741 := unwrapped_fields740[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field741) - field742 := unwrapped_fields740[1].([]*pb.Declaration) - if !(len(field742) == 0) { + field733 := unwrapped_fields732[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field733) + field734 := unwrapped_fields732[1].([]*pb.Declaration) + if !(len(field734) == 0) { p.newline() - for i744, elem743 := range field742 { - if (i744 > 0) { + for i736, elem735 := range field734 { + if (i736 > 0) { p.newline() } - p.pretty_declaration(elem743) + p.pretty_declaration(elem735) } } p.dedent() @@ -1109,74 +1100,74 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat747 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat747 != nil { - p.write(*flat747) + flat739 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat739 != nil { + p.write(*flat739) return nil } else { - fields746 := msg - p.pretty_fragment_id(fields746) + fields738 := msg + p.pretty_fragment_id(fields738) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat756 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat756 != nil { - p.write(*flat756) + flat748 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat748 != nil { + p.write(*flat748) return nil } else { - _t1360 := func(_dollar_dollar *pb.Declaration) *pb.Def { - var _t1361 *pb.Def + _t1344 := func(_dollar_dollar *pb.Declaration) *pb.Def { + var _t1345 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1361 = _dollar_dollar.GetDef() + _t1345 = _dollar_dollar.GetDef() } - return _t1361 + return _t1345 } - _t1362 := _t1360(msg) - deconstruct_result754 := _t1362 - if deconstruct_result754 != nil { - unwrapped755 := deconstruct_result754 - p.pretty_def(unwrapped755) + _t1346 := _t1344(msg) + deconstruct_result746 := _t1346 + if deconstruct_result746 != nil { + unwrapped747 := deconstruct_result746 + p.pretty_def(unwrapped747) } else { - _t1363 := func(_dollar_dollar *pb.Declaration) *pb.Algorithm { - var _t1364 *pb.Algorithm + _t1347 := func(_dollar_dollar *pb.Declaration) *pb.Algorithm { + var _t1348 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1364 = _dollar_dollar.GetAlgorithm() + _t1348 = _dollar_dollar.GetAlgorithm() } - return _t1364 + return _t1348 } - _t1365 := _t1363(msg) - deconstruct_result752 := _t1365 - if deconstruct_result752 != nil { - unwrapped753 := deconstruct_result752 - p.pretty_algorithm(unwrapped753) + _t1349 := _t1347(msg) + deconstruct_result744 := _t1349 + if deconstruct_result744 != nil { + unwrapped745 := deconstruct_result744 + p.pretty_algorithm(unwrapped745) } else { - _t1366 := func(_dollar_dollar *pb.Declaration) *pb.Constraint { - var _t1367 *pb.Constraint + _t1350 := func(_dollar_dollar *pb.Declaration) *pb.Constraint { + var _t1351 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1367 = _dollar_dollar.GetConstraint() + _t1351 = _dollar_dollar.GetConstraint() } - return _t1367 + return _t1351 } - _t1368 := _t1366(msg) - deconstruct_result750 := _t1368 - if deconstruct_result750 != nil { - unwrapped751 := deconstruct_result750 - p.pretty_constraint(unwrapped751) + _t1352 := _t1350(msg) + deconstruct_result742 := _t1352 + if deconstruct_result742 != nil { + unwrapped743 := deconstruct_result742 + p.pretty_constraint(unwrapped743) } else { - _t1369 := func(_dollar_dollar *pb.Declaration) *pb.Data { - var _t1370 *pb.Data + _t1353 := func(_dollar_dollar *pb.Declaration) *pb.Data { + var _t1354 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1370 = _dollar_dollar.GetData() + _t1354 = _dollar_dollar.GetData() } - return _t1370 + return _t1354 } - _t1371 := _t1369(msg) - deconstruct_result748 := _t1371 - if deconstruct_result748 != nil { - unwrapped749 := deconstruct_result748 - p.pretty_data(unwrapped749) + _t1355 := _t1353(msg) + deconstruct_result740 := _t1355 + if deconstruct_result740 != nil { + unwrapped741 := deconstruct_result740 + p.pretty_data(unwrapped741) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1188,35 +1179,35 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat763 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat763 != nil { - p.write(*flat763) + flat755 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat755 != nil { + p.write(*flat755) return nil } else { - _t1372 := func(_dollar_dollar *pb.Def) []interface{} { - var _t1373 []*pb.Attribute + _t1356 := func(_dollar_dollar *pb.Def) []interface{} { + var _t1357 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1373 = _dollar_dollar.GetAttrs() + _t1357 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1373} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1357} } - _t1374 := _t1372(msg) - fields757 := _t1374 - unwrapped_fields758 := fields757 + _t1358 := _t1356(msg) + fields749 := _t1358 + unwrapped_fields750 := fields749 p.write("(") p.write("def") p.indentSexp() p.newline() - field759 := unwrapped_fields758[0].(*pb.RelationId) - p.pretty_relation_id(field759) + field751 := unwrapped_fields750[0].(*pb.RelationId) + p.pretty_relation_id(field751) p.newline() - field760 := unwrapped_fields758[1].(*pb.Abstraction) - p.pretty_abstraction(field760) - field761 := unwrapped_fields758[2].([]*pb.Attribute) - if field761 != nil { + field752 := unwrapped_fields750[1].(*pb.Abstraction) + p.pretty_abstraction(field752) + field753 := unwrapped_fields750[2].([]*pb.Attribute) + if field753 != nil { p.newline() - opt_val762 := field761 - p.pretty_attrs(opt_val762) + opt_val754 := field753 + p.pretty_attrs(opt_val754) } p.dedent() p.write(")") @@ -1225,35 +1216,35 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat768 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat768 != nil { - p.write(*flat768) + flat760 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat760 != nil { + p.write(*flat760) return nil } else { - _t1375 := func(_dollar_dollar *pb.RelationId) *string { - var _t1376 *string + _t1359 := func(_dollar_dollar *pb.RelationId) *string { + var _t1360 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1377 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1376 = ptr(_t1377) + _t1361 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1360 = ptr(_t1361) } - return _t1376 + return _t1360 } - _t1378 := _t1375(msg) - deconstruct_result766 := _t1378 - if deconstruct_result766 != nil { - unwrapped767 := *deconstruct_result766 + _t1362 := _t1359(msg) + deconstruct_result758 := _t1362 + if deconstruct_result758 != nil { + unwrapped759 := *deconstruct_result758 p.write(":") - p.write(unwrapped767) + p.write(unwrapped759) } else { - _t1379 := func(_dollar_dollar *pb.RelationId) *pb.UInt128Value { - _t1380 := p.deconstruct_relation_id_uint128(_dollar_dollar) - return _t1380 + _t1363 := func(_dollar_dollar *pb.RelationId) *pb.UInt128Value { + _t1364 := p.deconstruct_relation_id_uint128(_dollar_dollar) + return _t1364 } - _t1381 := _t1379(msg) - deconstruct_result764 := _t1381 - if deconstruct_result764 != nil { - unwrapped765 := deconstruct_result764 - p.write(p.formatUint128(unwrapped765)) + _t1365 := _t1363(msg) + deconstruct_result756 := _t1365 + if deconstruct_result756 != nil { + unwrapped757 := deconstruct_result756 + p.write(p.formatUint128(unwrapped757)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1263,25 +1254,25 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat773 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat773 != nil { - p.write(*flat773) + flat765 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat765 != nil { + p.write(*flat765) return nil } else { - _t1382 := func(_dollar_dollar *pb.Abstraction) []interface{} { - _t1383 := p.deconstruct_bindings(_dollar_dollar) - return []interface{}{_t1383, _dollar_dollar.GetValue()} + _t1366 := func(_dollar_dollar *pb.Abstraction) []interface{} { + _t1367 := p.deconstruct_bindings(_dollar_dollar) + return []interface{}{_t1367, _dollar_dollar.GetValue()} } - _t1384 := _t1382(msg) - fields769 := _t1384 - unwrapped_fields770 := fields769 + _t1368 := _t1366(msg) + fields761 := _t1368 + unwrapped_fields762 := fields761 p.write("(") p.indent() - field771 := unwrapped_fields770[0].([]interface{}) - p.pretty_bindings(field771) + field763 := unwrapped_fields762[0].([]interface{}) + p.pretty_bindings(field763) p.newline() - field772 := unwrapped_fields770[1].(*pb.Formula) - p.pretty_formula(field772) + field764 := unwrapped_fields762[1].(*pb.Formula) + p.pretty_formula(field764) p.dedent() p.write(")") } @@ -1289,35 +1280,35 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat781 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat781 != nil { - p.write(*flat781) + flat773 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat773 != nil { + p.write(*flat773) return nil } else { - _t1385 := func(_dollar_dollar []interface{}) []interface{} { - var _t1386 []*pb.Binding + _t1369 := func(_dollar_dollar []interface{}) []interface{} { + var _t1370 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1386 = _dollar_dollar[1].([]*pb.Binding) + _t1370 = _dollar_dollar[1].([]*pb.Binding) } - return []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1386} + return []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1370} } - _t1387 := _t1385(msg) - fields774 := _t1387 - unwrapped_fields775 := fields774 + _t1371 := _t1369(msg) + fields766 := _t1371 + unwrapped_fields767 := fields766 p.write("[") p.indent() - field776 := unwrapped_fields775[0].([]*pb.Binding) - for i778, elem777 := range field776 { - if (i778 > 0) { + field768 := unwrapped_fields767[0].([]*pb.Binding) + for i770, elem769 := range field768 { + if (i770 > 0) { p.newline() } - p.pretty_binding(elem777) + p.pretty_binding(elem769) } - field779 := unwrapped_fields775[1].([]*pb.Binding) - if field779 != nil { + field771 := unwrapped_fields767[1].([]*pb.Binding) + if field771 != nil { p.newline() - opt_val780 := field779 - p.pretty_value_bindings(opt_val780) + opt_val772 := field771 + p.pretty_value_bindings(opt_val772) } p.dedent() p.write("]") @@ -1326,174 +1317,174 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat786 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat786 != nil { - p.write(*flat786) + flat778 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat778 != nil { + p.write(*flat778) return nil } else { - _t1388 := func(_dollar_dollar *pb.Binding) []interface{} { + _t1372 := func(_dollar_dollar *pb.Binding) []interface{} { return []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} } - _t1389 := _t1388(msg) - fields782 := _t1389 - unwrapped_fields783 := fields782 - field784 := unwrapped_fields783[0].(string) - p.write(field784) + _t1373 := _t1372(msg) + fields774 := _t1373 + unwrapped_fields775 := fields774 + field776 := unwrapped_fields775[0].(string) + p.write(field776) p.write("::") - field785 := unwrapped_fields783[1].(*pb.Type) - p.pretty_type(field785) + field777 := unwrapped_fields775[1].(*pb.Type) + p.pretty_type(field777) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat809 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat809 != nil { - p.write(*flat809) + flat801 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat801 != nil { + p.write(*flat801) return nil } else { - _t1390 := func(_dollar_dollar *pb.Type) *pb.UnspecifiedType { - var _t1391 *pb.UnspecifiedType + _t1374 := func(_dollar_dollar *pb.Type) *pb.UnspecifiedType { + var _t1375 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1391 = _dollar_dollar.GetUnspecifiedType() + _t1375 = _dollar_dollar.GetUnspecifiedType() } - return _t1391 + return _t1375 } - _t1392 := _t1390(msg) - deconstruct_result807 := _t1392 - if deconstruct_result807 != nil { - unwrapped808 := deconstruct_result807 - p.pretty_unspecified_type(unwrapped808) + _t1376 := _t1374(msg) + deconstruct_result799 := _t1376 + if deconstruct_result799 != nil { + unwrapped800 := deconstruct_result799 + p.pretty_unspecified_type(unwrapped800) } else { - _t1393 := func(_dollar_dollar *pb.Type) *pb.StringType { - var _t1394 *pb.StringType + _t1377 := func(_dollar_dollar *pb.Type) *pb.StringType { + var _t1378 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1394 = _dollar_dollar.GetStringType() + _t1378 = _dollar_dollar.GetStringType() } - return _t1394 + return _t1378 } - _t1395 := _t1393(msg) - deconstruct_result805 := _t1395 - if deconstruct_result805 != nil { - unwrapped806 := deconstruct_result805 - p.pretty_string_type(unwrapped806) + _t1379 := _t1377(msg) + deconstruct_result797 := _t1379 + if deconstruct_result797 != nil { + unwrapped798 := deconstruct_result797 + p.pretty_string_type(unwrapped798) } else { - _t1396 := func(_dollar_dollar *pb.Type) *pb.IntType { - var _t1397 *pb.IntType + _t1380 := func(_dollar_dollar *pb.Type) *pb.IntType { + var _t1381 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1397 = _dollar_dollar.GetIntType() + _t1381 = _dollar_dollar.GetIntType() } - return _t1397 + return _t1381 } - _t1398 := _t1396(msg) - deconstruct_result803 := _t1398 - if deconstruct_result803 != nil { - unwrapped804 := deconstruct_result803 - p.pretty_int_type(unwrapped804) + _t1382 := _t1380(msg) + deconstruct_result795 := _t1382 + if deconstruct_result795 != nil { + unwrapped796 := deconstruct_result795 + p.pretty_int_type(unwrapped796) } else { - _t1399 := func(_dollar_dollar *pb.Type) *pb.FloatType { - var _t1400 *pb.FloatType + _t1383 := func(_dollar_dollar *pb.Type) *pb.FloatType { + var _t1384 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1400 = _dollar_dollar.GetFloatType() + _t1384 = _dollar_dollar.GetFloatType() } - return _t1400 + return _t1384 } - _t1401 := _t1399(msg) - deconstruct_result801 := _t1401 - if deconstruct_result801 != nil { - unwrapped802 := deconstruct_result801 - p.pretty_float_type(unwrapped802) + _t1385 := _t1383(msg) + deconstruct_result793 := _t1385 + if deconstruct_result793 != nil { + unwrapped794 := deconstruct_result793 + p.pretty_float_type(unwrapped794) } else { - _t1402 := func(_dollar_dollar *pb.Type) *pb.UInt128Type { - var _t1403 *pb.UInt128Type + _t1386 := func(_dollar_dollar *pb.Type) *pb.UInt128Type { + var _t1387 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1403 = _dollar_dollar.GetUint128Type() + _t1387 = _dollar_dollar.GetUint128Type() } - return _t1403 + return _t1387 } - _t1404 := _t1402(msg) - deconstruct_result799 := _t1404 - if deconstruct_result799 != nil { - unwrapped800 := deconstruct_result799 - p.pretty_uint128_type(unwrapped800) + _t1388 := _t1386(msg) + deconstruct_result791 := _t1388 + if deconstruct_result791 != nil { + unwrapped792 := deconstruct_result791 + p.pretty_uint128_type(unwrapped792) } else { - _t1405 := func(_dollar_dollar *pb.Type) *pb.Int128Type { - var _t1406 *pb.Int128Type + _t1389 := func(_dollar_dollar *pb.Type) *pb.Int128Type { + var _t1390 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1406 = _dollar_dollar.GetInt128Type() + _t1390 = _dollar_dollar.GetInt128Type() } - return _t1406 + return _t1390 } - _t1407 := _t1405(msg) - deconstruct_result797 := _t1407 - if deconstruct_result797 != nil { - unwrapped798 := deconstruct_result797 - p.pretty_int128_type(unwrapped798) + _t1391 := _t1389(msg) + deconstruct_result789 := _t1391 + if deconstruct_result789 != nil { + unwrapped790 := deconstruct_result789 + p.pretty_int128_type(unwrapped790) } else { - _t1408 := func(_dollar_dollar *pb.Type) *pb.DateType { - var _t1409 *pb.DateType + _t1392 := func(_dollar_dollar *pb.Type) *pb.DateType { + var _t1393 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1409 = _dollar_dollar.GetDateType() + _t1393 = _dollar_dollar.GetDateType() } - return _t1409 + return _t1393 } - _t1410 := _t1408(msg) - deconstruct_result795 := _t1410 - if deconstruct_result795 != nil { - unwrapped796 := deconstruct_result795 - p.pretty_date_type(unwrapped796) + _t1394 := _t1392(msg) + deconstruct_result787 := _t1394 + if deconstruct_result787 != nil { + unwrapped788 := deconstruct_result787 + p.pretty_date_type(unwrapped788) } else { - _t1411 := func(_dollar_dollar *pb.Type) *pb.DateTimeType { - var _t1412 *pb.DateTimeType + _t1395 := func(_dollar_dollar *pb.Type) *pb.DateTimeType { + var _t1396 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1412 = _dollar_dollar.GetDatetimeType() + _t1396 = _dollar_dollar.GetDatetimeType() } - return _t1412 + return _t1396 } - _t1413 := _t1411(msg) - deconstruct_result793 := _t1413 - if deconstruct_result793 != nil { - unwrapped794 := deconstruct_result793 - p.pretty_datetime_type(unwrapped794) + _t1397 := _t1395(msg) + deconstruct_result785 := _t1397 + if deconstruct_result785 != nil { + unwrapped786 := deconstruct_result785 + p.pretty_datetime_type(unwrapped786) } else { - _t1414 := func(_dollar_dollar *pb.Type) *pb.MissingType { - var _t1415 *pb.MissingType + _t1398 := func(_dollar_dollar *pb.Type) *pb.MissingType { + var _t1399 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1415 = _dollar_dollar.GetMissingType() + _t1399 = _dollar_dollar.GetMissingType() } - return _t1415 + return _t1399 } - _t1416 := _t1414(msg) - deconstruct_result791 := _t1416 - if deconstruct_result791 != nil { - unwrapped792 := deconstruct_result791 - p.pretty_missing_type(unwrapped792) + _t1400 := _t1398(msg) + deconstruct_result783 := _t1400 + if deconstruct_result783 != nil { + unwrapped784 := deconstruct_result783 + p.pretty_missing_type(unwrapped784) } else { - _t1417 := func(_dollar_dollar *pb.Type) *pb.DecimalType { - var _t1418 *pb.DecimalType + _t1401 := func(_dollar_dollar *pb.Type) *pb.DecimalType { + var _t1402 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1418 = _dollar_dollar.GetDecimalType() + _t1402 = _dollar_dollar.GetDecimalType() } - return _t1418 + return _t1402 } - _t1419 := _t1417(msg) - deconstruct_result789 := _t1419 - if deconstruct_result789 != nil { - unwrapped790 := deconstruct_result789 - p.pretty_decimal_type(unwrapped790) + _t1403 := _t1401(msg) + deconstruct_result781 := _t1403 + if deconstruct_result781 != nil { + unwrapped782 := deconstruct_result781 + p.pretty_decimal_type(unwrapped782) } else { - _t1420 := func(_dollar_dollar *pb.Type) *pb.BooleanType { - var _t1421 *pb.BooleanType + _t1404 := func(_dollar_dollar *pb.Type) *pb.BooleanType { + var _t1405 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1421 = _dollar_dollar.GetBooleanType() + _t1405 = _dollar_dollar.GetBooleanType() } - return _t1421 + return _t1405 } - _t1422 := _t1420(msg) - deconstruct_result787 := _t1422 - if deconstruct_result787 != nil { - unwrapped788 := deconstruct_result787 - p.pretty_boolean_type(unwrapped788) + _t1406 := _t1404(msg) + deconstruct_result779 := _t1406 + if deconstruct_result779 != nil { + unwrapped780 := deconstruct_result779 + p.pretty_boolean_type(unwrapped780) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1512,89 +1503,89 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields810 := msg - _ = fields810 + fields802 := msg + _ = fields802 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields811 := msg - _ = fields811 + fields803 := msg + _ = fields803 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields812 := msg - _ = fields812 + fields804 := msg + _ = fields804 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields813 := msg - _ = fields813 + fields805 := msg + _ = fields805 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields814 := msg - _ = fields814 + fields806 := msg + _ = fields806 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields815 := msg - _ = fields815 + fields807 := msg + _ = fields807 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields816 := msg - _ = fields816 + fields808 := msg + _ = fields808 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields817 := msg - _ = fields817 + fields809 := msg + _ = fields809 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields818 := msg - _ = fields818 + fields810 := msg + _ = fields810 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat823 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat823 != nil { - p.write(*flat823) + flat815 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat815 != nil { + p.write(*flat815) return nil } else { - _t1423 := func(_dollar_dollar *pb.DecimalType) []interface{} { + _t1407 := func(_dollar_dollar *pb.DecimalType) []interface{} { return []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} } - _t1424 := _t1423(msg) - fields819 := _t1424 - unwrapped_fields820 := fields819 + _t1408 := _t1407(msg) + fields811 := _t1408 + unwrapped_fields812 := fields811 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field821 := unwrapped_fields820[0].(int64) - p.write(fmt.Sprintf("%d", field821)) + field813 := unwrapped_fields812[0].(int64) + p.write(fmt.Sprintf("%d", field813)) p.newline() - field822 := unwrapped_fields820[1].(int64) - p.write(fmt.Sprintf("%d", field822)) + field814 := unwrapped_fields812[1].(int64) + p.write(fmt.Sprintf("%d", field814)) p.dedent() p.write(")") } @@ -1602,27 +1593,27 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields824 := msg - _ = fields824 + fields816 := msg + _ = fields816 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat828 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat828 != nil { - p.write(*flat828) + flat820 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat820 != nil { + p.write(*flat820) return nil } else { - fields825 := msg + fields817 := msg p.write("|") - if !(len(fields825) == 0) { + if !(len(fields817) == 0) { p.write(" ") - for i827, elem826 := range fields825 { - if (i827 > 0) { + for i819, elem818 := range fields817 { + if (i819 > 0) { p.newline() } - p.pretty_binding(elem826) + p.pretty_binding(elem818) } } } @@ -1630,179 +1621,179 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat855 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat855 != nil { - p.write(*flat855) + flat847 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat847 != nil { + p.write(*flat847) return nil } else { - _t1425 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { - var _t1426 *pb.Conjunction + _t1409 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { + var _t1410 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1426 = _dollar_dollar.GetConjunction() + _t1410 = _dollar_dollar.GetConjunction() } - return _t1426 + return _t1410 } - _t1427 := _t1425(msg) - deconstruct_result853 := _t1427 - if deconstruct_result853 != nil { - unwrapped854 := deconstruct_result853 - p.pretty_true(unwrapped854) + _t1411 := _t1409(msg) + deconstruct_result845 := _t1411 + if deconstruct_result845 != nil { + unwrapped846 := deconstruct_result845 + p.pretty_true(unwrapped846) } else { - _t1428 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { - var _t1429 *pb.Disjunction + _t1412 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { + var _t1413 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1429 = _dollar_dollar.GetDisjunction() + _t1413 = _dollar_dollar.GetDisjunction() } - return _t1429 + return _t1413 } - _t1430 := _t1428(msg) - deconstruct_result851 := _t1430 - if deconstruct_result851 != nil { - unwrapped852 := deconstruct_result851 - p.pretty_false(unwrapped852) + _t1414 := _t1412(msg) + deconstruct_result843 := _t1414 + if deconstruct_result843 != nil { + unwrapped844 := deconstruct_result843 + p.pretty_false(unwrapped844) } else { - _t1431 := func(_dollar_dollar *pb.Formula) *pb.Exists { - var _t1432 *pb.Exists + _t1415 := func(_dollar_dollar *pb.Formula) *pb.Exists { + var _t1416 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1432 = _dollar_dollar.GetExists() + _t1416 = _dollar_dollar.GetExists() } - return _t1432 + return _t1416 } - _t1433 := _t1431(msg) - deconstruct_result849 := _t1433 - if deconstruct_result849 != nil { - unwrapped850 := deconstruct_result849 - p.pretty_exists(unwrapped850) + _t1417 := _t1415(msg) + deconstruct_result841 := _t1417 + if deconstruct_result841 != nil { + unwrapped842 := deconstruct_result841 + p.pretty_exists(unwrapped842) } else { - _t1434 := func(_dollar_dollar *pb.Formula) *pb.Reduce { - var _t1435 *pb.Reduce + _t1418 := func(_dollar_dollar *pb.Formula) *pb.Reduce { + var _t1419 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1435 = _dollar_dollar.GetReduce() + _t1419 = _dollar_dollar.GetReduce() } - return _t1435 + return _t1419 } - _t1436 := _t1434(msg) - deconstruct_result847 := _t1436 - if deconstruct_result847 != nil { - unwrapped848 := deconstruct_result847 - p.pretty_reduce(unwrapped848) + _t1420 := _t1418(msg) + deconstruct_result839 := _t1420 + if deconstruct_result839 != nil { + unwrapped840 := deconstruct_result839 + p.pretty_reduce(unwrapped840) } else { - _t1437 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { - var _t1438 *pb.Conjunction + _t1421 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { + var _t1422 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1438 = _dollar_dollar.GetConjunction() + _t1422 = _dollar_dollar.GetConjunction() } - return _t1438 + return _t1422 } - _t1439 := _t1437(msg) - deconstruct_result845 := _t1439 - if deconstruct_result845 != nil { - unwrapped846 := deconstruct_result845 - p.pretty_conjunction(unwrapped846) + _t1423 := _t1421(msg) + deconstruct_result837 := _t1423 + if deconstruct_result837 != nil { + unwrapped838 := deconstruct_result837 + p.pretty_conjunction(unwrapped838) } else { - _t1440 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { - var _t1441 *pb.Disjunction + _t1424 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { + var _t1425 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1441 = _dollar_dollar.GetDisjunction() + _t1425 = _dollar_dollar.GetDisjunction() } - return _t1441 + return _t1425 } - _t1442 := _t1440(msg) - deconstruct_result843 := _t1442 - if deconstruct_result843 != nil { - unwrapped844 := deconstruct_result843 - p.pretty_disjunction(unwrapped844) + _t1426 := _t1424(msg) + deconstruct_result835 := _t1426 + if deconstruct_result835 != nil { + unwrapped836 := deconstruct_result835 + p.pretty_disjunction(unwrapped836) } else { - _t1443 := func(_dollar_dollar *pb.Formula) *pb.Not { - var _t1444 *pb.Not + _t1427 := func(_dollar_dollar *pb.Formula) *pb.Not { + var _t1428 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1444 = _dollar_dollar.GetNot() + _t1428 = _dollar_dollar.GetNot() } - return _t1444 + return _t1428 } - _t1445 := _t1443(msg) - deconstruct_result841 := _t1445 - if deconstruct_result841 != nil { - unwrapped842 := deconstruct_result841 - p.pretty_not(unwrapped842) + _t1429 := _t1427(msg) + deconstruct_result833 := _t1429 + if deconstruct_result833 != nil { + unwrapped834 := deconstruct_result833 + p.pretty_not(unwrapped834) } else { - _t1446 := func(_dollar_dollar *pb.Formula) *pb.FFI { - var _t1447 *pb.FFI + _t1430 := func(_dollar_dollar *pb.Formula) *pb.FFI { + var _t1431 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1447 = _dollar_dollar.GetFfi() + _t1431 = _dollar_dollar.GetFfi() } - return _t1447 + return _t1431 } - _t1448 := _t1446(msg) - deconstruct_result839 := _t1448 - if deconstruct_result839 != nil { - unwrapped840 := deconstruct_result839 - p.pretty_ffi(unwrapped840) + _t1432 := _t1430(msg) + deconstruct_result831 := _t1432 + if deconstruct_result831 != nil { + unwrapped832 := deconstruct_result831 + p.pretty_ffi(unwrapped832) } else { - _t1449 := func(_dollar_dollar *pb.Formula) *pb.Atom { - var _t1450 *pb.Atom + _t1433 := func(_dollar_dollar *pb.Formula) *pb.Atom { + var _t1434 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1450 = _dollar_dollar.GetAtom() + _t1434 = _dollar_dollar.GetAtom() } - return _t1450 + return _t1434 } - _t1451 := _t1449(msg) - deconstruct_result837 := _t1451 - if deconstruct_result837 != nil { - unwrapped838 := deconstruct_result837 - p.pretty_atom(unwrapped838) + _t1435 := _t1433(msg) + deconstruct_result829 := _t1435 + if deconstruct_result829 != nil { + unwrapped830 := deconstruct_result829 + p.pretty_atom(unwrapped830) } else { - _t1452 := func(_dollar_dollar *pb.Formula) *pb.Pragma { - var _t1453 *pb.Pragma + _t1436 := func(_dollar_dollar *pb.Formula) *pb.Pragma { + var _t1437 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1453 = _dollar_dollar.GetPragma() + _t1437 = _dollar_dollar.GetPragma() } - return _t1453 + return _t1437 } - _t1454 := _t1452(msg) - deconstruct_result835 := _t1454 - if deconstruct_result835 != nil { - unwrapped836 := deconstruct_result835 - p.pretty_pragma(unwrapped836) + _t1438 := _t1436(msg) + deconstruct_result827 := _t1438 + if deconstruct_result827 != nil { + unwrapped828 := deconstruct_result827 + p.pretty_pragma(unwrapped828) } else { - _t1455 := func(_dollar_dollar *pb.Formula) *pb.Primitive { - var _t1456 *pb.Primitive + _t1439 := func(_dollar_dollar *pb.Formula) *pb.Primitive { + var _t1440 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1456 = _dollar_dollar.GetPrimitive() + _t1440 = _dollar_dollar.GetPrimitive() } - return _t1456 + return _t1440 } - _t1457 := _t1455(msg) - deconstruct_result833 := _t1457 - if deconstruct_result833 != nil { - unwrapped834 := deconstruct_result833 - p.pretty_primitive(unwrapped834) + _t1441 := _t1439(msg) + deconstruct_result825 := _t1441 + if deconstruct_result825 != nil { + unwrapped826 := deconstruct_result825 + p.pretty_primitive(unwrapped826) } else { - _t1458 := func(_dollar_dollar *pb.Formula) *pb.RelAtom { - var _t1459 *pb.RelAtom + _t1442 := func(_dollar_dollar *pb.Formula) *pb.RelAtom { + var _t1443 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1459 = _dollar_dollar.GetRelAtom() + _t1443 = _dollar_dollar.GetRelAtom() } - return _t1459 + return _t1443 } - _t1460 := _t1458(msg) - deconstruct_result831 := _t1460 - if deconstruct_result831 != nil { - unwrapped832 := deconstruct_result831 - p.pretty_rel_atom(unwrapped832) + _t1444 := _t1442(msg) + deconstruct_result823 := _t1444 + if deconstruct_result823 != nil { + unwrapped824 := deconstruct_result823 + p.pretty_rel_atom(unwrapped824) } else { - _t1461 := func(_dollar_dollar *pb.Formula) *pb.Cast { - var _t1462 *pb.Cast + _t1445 := func(_dollar_dollar *pb.Formula) *pb.Cast { + var _t1446 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1462 = _dollar_dollar.GetCast() + _t1446 = _dollar_dollar.GetCast() } - return _t1462 + return _t1446 } - _t1463 := _t1461(msg) - deconstruct_result829 := _t1463 - if deconstruct_result829 != nil { - unwrapped830 := deconstruct_result829 - p.pretty_cast(unwrapped830) + _t1447 := _t1445(msg) + deconstruct_result821 := _t1447 + if deconstruct_result821 != nil { + unwrapped822 := deconstruct_result821 + p.pretty_cast(unwrapped822) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1823,8 +1814,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields856 := msg - _ = fields856 + fields848 := msg + _ = fields848 p.write("(") p.write("true") p.write(")") @@ -1832,8 +1823,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields857 := msg - _ = fields857 + fields849 := msg + _ = fields849 p.write("(") p.write("false") p.write(")") @@ -1841,27 +1832,27 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat862 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat862 != nil { - p.write(*flat862) + flat854 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat854 != nil { + p.write(*flat854) return nil } else { - _t1464 := func(_dollar_dollar *pb.Exists) []interface{} { - _t1465 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - return []interface{}{_t1465, _dollar_dollar.GetBody().GetValue()} + _t1448 := func(_dollar_dollar *pb.Exists) []interface{} { + _t1449 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + return []interface{}{_t1449, _dollar_dollar.GetBody().GetValue()} } - _t1466 := _t1464(msg) - fields858 := _t1466 - unwrapped_fields859 := fields858 + _t1450 := _t1448(msg) + fields850 := _t1450 + unwrapped_fields851 := fields850 p.write("(") p.write("exists") p.indentSexp() p.newline() - field860 := unwrapped_fields859[0].([]interface{}) - p.pretty_bindings(field860) + field852 := unwrapped_fields851[0].([]interface{}) + p.pretty_bindings(field852) p.newline() - field861 := unwrapped_fields859[1].(*pb.Formula) - p.pretty_formula(field861) + field853 := unwrapped_fields851[1].(*pb.Formula) + p.pretty_formula(field853) p.dedent() p.write(")") } @@ -1869,29 +1860,29 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat868 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat868 != nil { - p.write(*flat868) + flat860 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat860 != nil { + p.write(*flat860) return nil } else { - _t1467 := func(_dollar_dollar *pb.Reduce) []interface{} { + _t1451 := func(_dollar_dollar *pb.Reduce) []interface{} { return []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} } - _t1468 := _t1467(msg) - fields863 := _t1468 - unwrapped_fields864 := fields863 + _t1452 := _t1451(msg) + fields855 := _t1452 + unwrapped_fields856 := fields855 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field865 := unwrapped_fields864[0].(*pb.Abstraction) - p.pretty_abstraction(field865) + field857 := unwrapped_fields856[0].(*pb.Abstraction) + p.pretty_abstraction(field857) p.newline() - field866 := unwrapped_fields864[1].(*pb.Abstraction) - p.pretty_abstraction(field866) + field858 := unwrapped_fields856[1].(*pb.Abstraction) + p.pretty_abstraction(field858) p.newline() - field867 := unwrapped_fields864[2].([]*pb.Term) - p.pretty_terms(field867) + field859 := unwrapped_fields856[2].([]*pb.Term) + p.pretty_terms(field859) p.dedent() p.write(")") } @@ -1899,22 +1890,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat872 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat872 != nil { - p.write(*flat872) + flat864 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat864 != nil { + p.write(*flat864) return nil } else { - fields869 := msg + fields861 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields869) == 0) { + if !(len(fields861) == 0) { p.newline() - for i871, elem870 := range fields869 { - if (i871 > 0) { + for i863, elem862 := range fields861 { + if (i863 > 0) { p.newline() } - p.pretty_term(elem870) + p.pretty_term(elem862) } } p.dedent() @@ -1924,36 +1915,36 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat877 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat877 != nil { - p.write(*flat877) + flat869 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat869 != nil { + p.write(*flat869) return nil } else { - _t1469 := func(_dollar_dollar *pb.Term) *pb.Var { - var _t1470 *pb.Var + _t1453 := func(_dollar_dollar *pb.Term) *pb.Var { + var _t1454 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1470 = _dollar_dollar.GetVar() + _t1454 = _dollar_dollar.GetVar() } - return _t1470 + return _t1454 } - _t1471 := _t1469(msg) - deconstruct_result875 := _t1471 - if deconstruct_result875 != nil { - unwrapped876 := deconstruct_result875 - p.pretty_var(unwrapped876) + _t1455 := _t1453(msg) + deconstruct_result867 := _t1455 + if deconstruct_result867 != nil { + unwrapped868 := deconstruct_result867 + p.pretty_var(unwrapped868) } else { - _t1472 := func(_dollar_dollar *pb.Term) *pb.Value { - var _t1473 *pb.Value + _t1456 := func(_dollar_dollar *pb.Term) *pb.Value { + var _t1457 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1473 = _dollar_dollar.GetConstant() + _t1457 = _dollar_dollar.GetConstant() } - return _t1473 + return _t1457 } - _t1474 := _t1472(msg) - deconstruct_result873 := _t1474 - if deconstruct_result873 != nil { - unwrapped874 := deconstruct_result873 - p.pretty_constant(unwrapped874) + _t1458 := _t1456(msg) + deconstruct_result865 := _t1458 + if deconstruct_result865 != nil { + unwrapped866 := deconstruct_result865 + p.pretty_constant(unwrapped866) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1963,56 +1954,56 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat880 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat880 != nil { - p.write(*flat880) + flat872 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat872 != nil { + p.write(*flat872) return nil } else { - _t1475 := func(_dollar_dollar *pb.Var) string { + _t1459 := func(_dollar_dollar *pb.Var) string { return _dollar_dollar.GetName() } - _t1476 := _t1475(msg) - fields878 := _t1476 - unwrapped_fields879 := fields878 - p.write(unwrapped_fields879) + _t1460 := _t1459(msg) + fields870 := _t1460 + unwrapped_fields871 := fields870 + p.write(unwrapped_fields871) } return nil } func (p *PrettyPrinter) pretty_constant(msg *pb.Value) interface{} { - flat882 := p.tryFlat(msg, func() { p.pretty_constant(msg) }) - if flat882 != nil { - p.write(*flat882) + flat874 := p.tryFlat(msg, func() { p.pretty_constant(msg) }) + if flat874 != nil { + p.write(*flat874) return nil } else { - fields881 := msg - p.pretty_value(fields881) + fields873 := msg + p.pretty_value(fields873) } return nil } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat887 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat887 != nil { - p.write(*flat887) + flat879 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat879 != nil { + p.write(*flat879) return nil } else { - _t1477 := func(_dollar_dollar *pb.Conjunction) []*pb.Formula { + _t1461 := func(_dollar_dollar *pb.Conjunction) []*pb.Formula { return _dollar_dollar.GetArgs() } - _t1478 := _t1477(msg) - fields883 := _t1478 - unwrapped_fields884 := fields883 + _t1462 := _t1461(msg) + fields875 := _t1462 + unwrapped_fields876 := fields875 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields884) == 0) { + if !(len(unwrapped_fields876) == 0) { p.newline() - for i886, elem885 := range unwrapped_fields884 { - if (i886 > 0) { + for i878, elem877 := range unwrapped_fields876 { + if (i878 > 0) { p.newline() } - p.pretty_formula(elem885) + p.pretty_formula(elem877) } } p.dedent() @@ -2022,27 +2013,27 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat892 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat892 != nil { - p.write(*flat892) + flat884 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat884 != nil { + p.write(*flat884) return nil } else { - _t1479 := func(_dollar_dollar *pb.Disjunction) []*pb.Formula { + _t1463 := func(_dollar_dollar *pb.Disjunction) []*pb.Formula { return _dollar_dollar.GetArgs() } - _t1480 := _t1479(msg) - fields888 := _t1480 - unwrapped_fields889 := fields888 + _t1464 := _t1463(msg) + fields880 := _t1464 + unwrapped_fields881 := fields880 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields889) == 0) { + if !(len(unwrapped_fields881) == 0) { p.newline() - for i891, elem890 := range unwrapped_fields889 { - if (i891 > 0) { + for i883, elem882 := range unwrapped_fields881 { + if (i883 > 0) { p.newline() } - p.pretty_formula(elem890) + p.pretty_formula(elem882) } } p.dedent() @@ -2052,22 +2043,22 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat895 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat895 != nil { - p.write(*flat895) + flat887 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat887 != nil { + p.write(*flat887) return nil } else { - _t1481 := func(_dollar_dollar *pb.Not) *pb.Formula { + _t1465 := func(_dollar_dollar *pb.Not) *pb.Formula { return _dollar_dollar.GetArg() } - _t1482 := _t1481(msg) - fields893 := _t1482 - unwrapped_fields894 := fields893 + _t1466 := _t1465(msg) + fields885 := _t1466 + unwrapped_fields886 := fields885 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields894) + p.pretty_formula(unwrapped_fields886) p.dedent() p.write(")") } @@ -2075,29 +2066,29 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat901 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat901 != nil { - p.write(*flat901) + flat893 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat893 != nil { + p.write(*flat893) return nil } else { - _t1483 := func(_dollar_dollar *pb.FFI) []interface{} { + _t1467 := func(_dollar_dollar *pb.FFI) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} } - _t1484 := _t1483(msg) - fields896 := _t1484 - unwrapped_fields897 := fields896 + _t1468 := _t1467(msg) + fields888 := _t1468 + unwrapped_fields889 := fields888 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field898 := unwrapped_fields897[0].(string) - p.pretty_name(field898) + field890 := unwrapped_fields889[0].(string) + p.pretty_name(field890) p.newline() - field899 := unwrapped_fields897[1].([]*pb.Abstraction) - p.pretty_ffi_args(field899) + field891 := unwrapped_fields889[1].([]*pb.Abstraction) + p.pretty_ffi_args(field891) p.newline() - field900 := unwrapped_fields897[2].([]*pb.Term) - p.pretty_terms(field900) + field892 := unwrapped_fields889[2].([]*pb.Term) + p.pretty_terms(field892) p.dedent() p.write(")") } @@ -2105,35 +2096,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat903 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat903 != nil { - p.write(*flat903) + flat895 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat895 != nil { + p.write(*flat895) return nil } else { - fields902 := msg + fields894 := msg p.write(":") - p.write(fields902) + p.write(fields894) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat907 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat907 != nil { - p.write(*flat907) + flat899 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat899 != nil { + p.write(*flat899) return nil } else { - fields904 := msg + fields896 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields904) == 0) { + if !(len(fields896) == 0) { p.newline() - for i906, elem905 := range fields904 { - if (i906 > 0) { + for i898, elem897 := range fields896 { + if (i898 > 0) { p.newline() } - p.pretty_abstraction(elem905) + p.pretty_abstraction(elem897) } } p.dedent() @@ -2143,31 +2134,31 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat914 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat914 != nil { - p.write(*flat914) + flat906 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat906 != nil { + p.write(*flat906) return nil } else { - _t1485 := func(_dollar_dollar *pb.Atom) []interface{} { + _t1469 := func(_dollar_dollar *pb.Atom) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1486 := _t1485(msg) - fields908 := _t1486 - unwrapped_fields909 := fields908 + _t1470 := _t1469(msg) + fields900 := _t1470 + unwrapped_fields901 := fields900 p.write("(") p.write("atom") p.indentSexp() p.newline() - field910 := unwrapped_fields909[0].(*pb.RelationId) - p.pretty_relation_id(field910) - field911 := unwrapped_fields909[1].([]*pb.Term) - if !(len(field911) == 0) { + field902 := unwrapped_fields901[0].(*pb.RelationId) + p.pretty_relation_id(field902) + field903 := unwrapped_fields901[1].([]*pb.Term) + if !(len(field903) == 0) { p.newline() - for i913, elem912 := range field911 { - if (i913 > 0) { + for i905, elem904 := range field903 { + if (i905 > 0) { p.newline() } - p.pretty_term(elem912) + p.pretty_term(elem904) } } p.dedent() @@ -2177,31 +2168,31 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat921 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat921 != nil { - p.write(*flat921) + flat913 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat913 != nil { + p.write(*flat913) return nil } else { - _t1487 := func(_dollar_dollar *pb.Pragma) []interface{} { + _t1471 := func(_dollar_dollar *pb.Pragma) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1488 := _t1487(msg) - fields915 := _t1488 - unwrapped_fields916 := fields915 + _t1472 := _t1471(msg) + fields907 := _t1472 + unwrapped_fields908 := fields907 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field917 := unwrapped_fields916[0].(string) - p.pretty_name(field917) - field918 := unwrapped_fields916[1].([]*pb.Term) - if !(len(field918) == 0) { + field909 := unwrapped_fields908[0].(string) + p.pretty_name(field909) + field910 := unwrapped_fields908[1].([]*pb.Term) + if !(len(field910) == 0) { p.newline() - for i920, elem919 := range field918 { - if (i920 > 0) { + for i912, elem911 := range field910 { + if (i912 > 0) { p.newline() } - p.pretty_term(elem919) + p.pretty_term(elem911) } } p.dedent() @@ -2211,139 +2202,139 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat937 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat937 != nil { - p.write(*flat937) + flat929 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat929 != nil { + p.write(*flat929) return nil } else { - _t1489 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1490 []interface{} + _t1473 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1474 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1490 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1474 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1490 + return _t1474 } - _t1491 := _t1489(msg) - guard_result936 := _t1491 - if guard_result936 != nil { + _t1475 := _t1473(msg) + guard_result928 := _t1475 + if guard_result928 != nil { p.pretty_eq(msg) } else { - _t1492 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1493 []interface{} + _t1476 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1477 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1493 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1477 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1493 + return _t1477 } - _t1494 := _t1492(msg) - guard_result935 := _t1494 - if guard_result935 != nil { + _t1478 := _t1476(msg) + guard_result927 := _t1478 + if guard_result927 != nil { p.pretty_lt(msg) } else { - _t1495 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1496 []interface{} + _t1479 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1480 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1496 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1480 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1496 + return _t1480 } - _t1497 := _t1495(msg) - guard_result934 := _t1497 - if guard_result934 != nil { + _t1481 := _t1479(msg) + guard_result926 := _t1481 + if guard_result926 != nil { p.pretty_lt_eq(msg) } else { - _t1498 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1499 []interface{} + _t1482 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1483 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1499 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1483 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1499 + return _t1483 } - _t1500 := _t1498(msg) - guard_result933 := _t1500 - if guard_result933 != nil { + _t1484 := _t1482(msg) + guard_result925 := _t1484 + if guard_result925 != nil { p.pretty_gt(msg) } else { - _t1501 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1502 []interface{} + _t1485 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1486 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1502 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1486 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1502 + return _t1486 } - _t1503 := _t1501(msg) - guard_result932 := _t1503 - if guard_result932 != nil { + _t1487 := _t1485(msg) + guard_result924 := _t1487 + if guard_result924 != nil { p.pretty_gt_eq(msg) } else { - _t1504 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1505 []interface{} + _t1488 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1489 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1505 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1489 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1505 + return _t1489 } - _t1506 := _t1504(msg) - guard_result931 := _t1506 - if guard_result931 != nil { + _t1490 := _t1488(msg) + guard_result923 := _t1490 + if guard_result923 != nil { p.pretty_add(msg) } else { - _t1507 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1508 []interface{} + _t1491 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1492 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1508 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1492 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1508 + return _t1492 } - _t1509 := _t1507(msg) - guard_result930 := _t1509 - if guard_result930 != nil { + _t1493 := _t1491(msg) + guard_result922 := _t1493 + if guard_result922 != nil { p.pretty_minus(msg) } else { - _t1510 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1511 []interface{} + _t1494 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1495 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1511 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1495 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1511 + return _t1495 } - _t1512 := _t1510(msg) - guard_result929 := _t1512 - if guard_result929 != nil { + _t1496 := _t1494(msg) + guard_result921 := _t1496 + if guard_result921 != nil { p.pretty_multiply(msg) } else { - _t1513 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1514 []interface{} + _t1497 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1498 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1514 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1498 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1514 + return _t1498 } - _t1515 := _t1513(msg) - guard_result928 := _t1515 - if guard_result928 != nil { + _t1499 := _t1497(msg) + guard_result920 := _t1499 + if guard_result920 != nil { p.pretty_divide(msg) } else { - _t1516 := func(_dollar_dollar *pb.Primitive) []interface{} { + _t1500 := func(_dollar_dollar *pb.Primitive) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1517 := _t1516(msg) - fields922 := _t1517 - unwrapped_fields923 := fields922 + _t1501 := _t1500(msg) + fields914 := _t1501 + unwrapped_fields915 := fields914 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field924 := unwrapped_fields923[0].(string) - p.pretty_name(field924) - field925 := unwrapped_fields923[1].([]*pb.RelTerm) - if !(len(field925) == 0) { + field916 := unwrapped_fields915[0].(string) + p.pretty_name(field916) + field917 := unwrapped_fields915[1].([]*pb.RelTerm) + if !(len(field917) == 0) { p.newline() - for i927, elem926 := range field925 { - if (i927 > 0) { + for i919, elem918 := range field917 { + if (i919 > 0) { p.newline() } - p.pretty_rel_term(elem926) + p.pretty_rel_term(elem918) } } p.dedent() @@ -2362,30 +2353,30 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat942 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat942 != nil { - p.write(*flat942) + flat934 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat934 != nil { + p.write(*flat934) return nil } else { - _t1518 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1519 []interface{} + _t1502 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1503 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1519 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1503 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1519 + return _t1503 } - _t1520 := _t1518(msg) - fields938 := _t1520 - unwrapped_fields939 := fields938 + _t1504 := _t1502(msg) + fields930 := _t1504 + unwrapped_fields931 := fields930 p.write("(") p.write("=") p.indentSexp() p.newline() - field940 := unwrapped_fields939[0].(*pb.Term) - p.pretty_term(field940) + field932 := unwrapped_fields931[0].(*pb.Term) + p.pretty_term(field932) p.newline() - field941 := unwrapped_fields939[1].(*pb.Term) - p.pretty_term(field941) + field933 := unwrapped_fields931[1].(*pb.Term) + p.pretty_term(field933) p.dedent() p.write(")") } @@ -2393,30 +2384,30 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat947 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat947 != nil { - p.write(*flat947) + flat939 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat939 != nil { + p.write(*flat939) return nil } else { - _t1521 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1522 []interface{} + _t1505 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1506 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1522 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1506 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1522 + return _t1506 } - _t1523 := _t1521(msg) - fields943 := _t1523 - unwrapped_fields944 := fields943 + _t1507 := _t1505(msg) + fields935 := _t1507 + unwrapped_fields936 := fields935 p.write("(") p.write("<") p.indentSexp() p.newline() - field945 := unwrapped_fields944[0].(*pb.Term) - p.pretty_term(field945) + field937 := unwrapped_fields936[0].(*pb.Term) + p.pretty_term(field937) p.newline() - field946 := unwrapped_fields944[1].(*pb.Term) - p.pretty_term(field946) + field938 := unwrapped_fields936[1].(*pb.Term) + p.pretty_term(field938) p.dedent() p.write(")") } @@ -2424,30 +2415,30 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat952 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat952 != nil { - p.write(*flat952) + flat944 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat944 != nil { + p.write(*flat944) return nil } else { - _t1524 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1525 []interface{} + _t1508 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1509 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1525 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1509 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1525 + return _t1509 } - _t1526 := _t1524(msg) - fields948 := _t1526 - unwrapped_fields949 := fields948 + _t1510 := _t1508(msg) + fields940 := _t1510 + unwrapped_fields941 := fields940 p.write("(") p.write("<=") p.indentSexp() p.newline() - field950 := unwrapped_fields949[0].(*pb.Term) - p.pretty_term(field950) + field942 := unwrapped_fields941[0].(*pb.Term) + p.pretty_term(field942) p.newline() - field951 := unwrapped_fields949[1].(*pb.Term) - p.pretty_term(field951) + field943 := unwrapped_fields941[1].(*pb.Term) + p.pretty_term(field943) p.dedent() p.write(")") } @@ -2455,30 +2446,30 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat957 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat957 != nil { - p.write(*flat957) + flat949 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat949 != nil { + p.write(*flat949) return nil } else { - _t1527 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1528 []interface{} + _t1511 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1512 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1528 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1512 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1528 + return _t1512 } - _t1529 := _t1527(msg) - fields953 := _t1529 - unwrapped_fields954 := fields953 + _t1513 := _t1511(msg) + fields945 := _t1513 + unwrapped_fields946 := fields945 p.write("(") p.write(">") p.indentSexp() p.newline() - field955 := unwrapped_fields954[0].(*pb.Term) - p.pretty_term(field955) + field947 := unwrapped_fields946[0].(*pb.Term) + p.pretty_term(field947) p.newline() - field956 := unwrapped_fields954[1].(*pb.Term) - p.pretty_term(field956) + field948 := unwrapped_fields946[1].(*pb.Term) + p.pretty_term(field948) p.dedent() p.write(")") } @@ -2486,30 +2477,30 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat962 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat962 != nil { - p.write(*flat962) + flat954 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat954 != nil { + p.write(*flat954) return nil } else { - _t1530 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1531 []interface{} + _t1514 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1515 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1531 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1515 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1531 + return _t1515 } - _t1532 := _t1530(msg) - fields958 := _t1532 - unwrapped_fields959 := fields958 + _t1516 := _t1514(msg) + fields950 := _t1516 + unwrapped_fields951 := fields950 p.write("(") p.write(">=") p.indentSexp() p.newline() - field960 := unwrapped_fields959[0].(*pb.Term) - p.pretty_term(field960) + field952 := unwrapped_fields951[0].(*pb.Term) + p.pretty_term(field952) p.newline() - field961 := unwrapped_fields959[1].(*pb.Term) - p.pretty_term(field961) + field953 := unwrapped_fields951[1].(*pb.Term) + p.pretty_term(field953) p.dedent() p.write(")") } @@ -2517,33 +2508,33 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat968 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat968 != nil { - p.write(*flat968) + flat960 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat960 != nil { + p.write(*flat960) return nil } else { - _t1533 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1534 []interface{} + _t1517 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1518 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1534 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1518 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1534 + return _t1518 } - _t1535 := _t1533(msg) - fields963 := _t1535 - unwrapped_fields964 := fields963 + _t1519 := _t1517(msg) + fields955 := _t1519 + unwrapped_fields956 := fields955 p.write("(") p.write("+") p.indentSexp() p.newline() - field965 := unwrapped_fields964[0].(*pb.Term) - p.pretty_term(field965) + field957 := unwrapped_fields956[0].(*pb.Term) + p.pretty_term(field957) p.newline() - field966 := unwrapped_fields964[1].(*pb.Term) - p.pretty_term(field966) + field958 := unwrapped_fields956[1].(*pb.Term) + p.pretty_term(field958) p.newline() - field967 := unwrapped_fields964[2].(*pb.Term) - p.pretty_term(field967) + field959 := unwrapped_fields956[2].(*pb.Term) + p.pretty_term(field959) p.dedent() p.write(")") } @@ -2551,33 +2542,33 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat974 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat974 != nil { - p.write(*flat974) + flat966 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat966 != nil { + p.write(*flat966) return nil } else { - _t1536 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1537 []interface{} + _t1520 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1521 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1537 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1521 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1537 + return _t1521 } - _t1538 := _t1536(msg) - fields969 := _t1538 - unwrapped_fields970 := fields969 + _t1522 := _t1520(msg) + fields961 := _t1522 + unwrapped_fields962 := fields961 p.write("(") p.write("-") p.indentSexp() p.newline() - field971 := unwrapped_fields970[0].(*pb.Term) - p.pretty_term(field971) + field963 := unwrapped_fields962[0].(*pb.Term) + p.pretty_term(field963) p.newline() - field972 := unwrapped_fields970[1].(*pb.Term) - p.pretty_term(field972) + field964 := unwrapped_fields962[1].(*pb.Term) + p.pretty_term(field964) p.newline() - field973 := unwrapped_fields970[2].(*pb.Term) - p.pretty_term(field973) + field965 := unwrapped_fields962[2].(*pb.Term) + p.pretty_term(field965) p.dedent() p.write(")") } @@ -2585,33 +2576,33 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat980 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat980 != nil { - p.write(*flat980) + flat972 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat972 != nil { + p.write(*flat972) return nil } else { - _t1539 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1540 []interface{} + _t1523 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1524 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1540 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1524 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1540 + return _t1524 } - _t1541 := _t1539(msg) - fields975 := _t1541 - unwrapped_fields976 := fields975 + _t1525 := _t1523(msg) + fields967 := _t1525 + unwrapped_fields968 := fields967 p.write("(") p.write("*") p.indentSexp() p.newline() - field977 := unwrapped_fields976[0].(*pb.Term) - p.pretty_term(field977) + field969 := unwrapped_fields968[0].(*pb.Term) + p.pretty_term(field969) p.newline() - field978 := unwrapped_fields976[1].(*pb.Term) - p.pretty_term(field978) + field970 := unwrapped_fields968[1].(*pb.Term) + p.pretty_term(field970) p.newline() - field979 := unwrapped_fields976[2].(*pb.Term) - p.pretty_term(field979) + field971 := unwrapped_fields968[2].(*pb.Term) + p.pretty_term(field971) p.dedent() p.write(")") } @@ -2619,33 +2610,33 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat986 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat986 != nil { - p.write(*flat986) + flat978 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat978 != nil { + p.write(*flat978) return nil } else { - _t1542 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1543 []interface{} + _t1526 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1527 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1543 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1527 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1543 + return _t1527 } - _t1544 := _t1542(msg) - fields981 := _t1544 - unwrapped_fields982 := fields981 + _t1528 := _t1526(msg) + fields973 := _t1528 + unwrapped_fields974 := fields973 p.write("(") p.write("/") p.indentSexp() p.newline() - field983 := unwrapped_fields982[0].(*pb.Term) - p.pretty_term(field983) + field975 := unwrapped_fields974[0].(*pb.Term) + p.pretty_term(field975) p.newline() - field984 := unwrapped_fields982[1].(*pb.Term) - p.pretty_term(field984) + field976 := unwrapped_fields974[1].(*pb.Term) + p.pretty_term(field976) p.newline() - field985 := unwrapped_fields982[2].(*pb.Term) - p.pretty_term(field985) + field977 := unwrapped_fields974[2].(*pb.Term) + p.pretty_term(field977) p.dedent() p.write(")") } @@ -2653,36 +2644,36 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat991 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat991 != nil { - p.write(*flat991) + flat983 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat983 != nil { + p.write(*flat983) return nil } else { - _t1545 := func(_dollar_dollar *pb.RelTerm) *pb.Value { - var _t1546 *pb.Value + _t1529 := func(_dollar_dollar *pb.RelTerm) *pb.Value { + var _t1530 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1546 = _dollar_dollar.GetSpecializedValue() + _t1530 = _dollar_dollar.GetSpecializedValue() } - return _t1546 + return _t1530 } - _t1547 := _t1545(msg) - deconstruct_result989 := _t1547 - if deconstruct_result989 != nil { - unwrapped990 := deconstruct_result989 - p.pretty_specialized_value(unwrapped990) + _t1531 := _t1529(msg) + deconstruct_result981 := _t1531 + if deconstruct_result981 != nil { + unwrapped982 := deconstruct_result981 + p.pretty_specialized_value(unwrapped982) } else { - _t1548 := func(_dollar_dollar *pb.RelTerm) *pb.Term { - var _t1549 *pb.Term + _t1532 := func(_dollar_dollar *pb.RelTerm) *pb.Term { + var _t1533 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1549 = _dollar_dollar.GetTerm() + _t1533 = _dollar_dollar.GetTerm() } - return _t1549 + return _t1533 } - _t1550 := _t1548(msg) - deconstruct_result987 := _t1550 - if deconstruct_result987 != nil { - unwrapped988 := deconstruct_result987 - p.pretty_term(unwrapped988) + _t1534 := _t1532(msg) + deconstruct_result979 := _t1534 + if deconstruct_result979 != nil { + unwrapped980 := deconstruct_result979 + p.pretty_term(unwrapped980) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2692,44 +2683,44 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat993 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat993 != nil { - p.write(*flat993) + flat985 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat985 != nil { + p.write(*flat985) return nil } else { - fields992 := msg + fields984 := msg p.write("#") - p.pretty_value(fields992) + p.pretty_value(fields984) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1000 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1000 != nil { - p.write(*flat1000) + flat992 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat992 != nil { + p.write(*flat992) return nil } else { - _t1551 := func(_dollar_dollar *pb.RelAtom) []interface{} { + _t1535 := func(_dollar_dollar *pb.RelAtom) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1552 := _t1551(msg) - fields994 := _t1552 - unwrapped_fields995 := fields994 + _t1536 := _t1535(msg) + fields986 := _t1536 + unwrapped_fields987 := fields986 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field996 := unwrapped_fields995[0].(string) - p.pretty_name(field996) - field997 := unwrapped_fields995[1].([]*pb.RelTerm) - if !(len(field997) == 0) { + field988 := unwrapped_fields987[0].(string) + p.pretty_name(field988) + field989 := unwrapped_fields987[1].([]*pb.RelTerm) + if !(len(field989) == 0) { p.newline() - for i999, elem998 := range field997 { - if (i999 > 0) { + for i991, elem990 := range field989 { + if (i991 > 0) { p.newline() } - p.pretty_rel_term(elem998) + p.pretty_rel_term(elem990) } } p.dedent() @@ -2739,26 +2730,26 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1005 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1005 != nil { - p.write(*flat1005) + flat997 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat997 != nil { + p.write(*flat997) return nil } else { - _t1553 := func(_dollar_dollar *pb.Cast) []interface{} { + _t1537 := func(_dollar_dollar *pb.Cast) []interface{} { return []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} } - _t1554 := _t1553(msg) - fields1001 := _t1554 - unwrapped_fields1002 := fields1001 + _t1538 := _t1537(msg) + fields993 := _t1538 + unwrapped_fields994 := fields993 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1003 := unwrapped_fields1002[0].(*pb.Term) - p.pretty_term(field1003) + field995 := unwrapped_fields994[0].(*pb.Term) + p.pretty_term(field995) p.newline() - field1004 := unwrapped_fields1002[1].(*pb.Term) - p.pretty_term(field1004) + field996 := unwrapped_fields994[1].(*pb.Term) + p.pretty_term(field996) p.dedent() p.write(")") } @@ -2766,22 +2757,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1009 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1009 != nil { - p.write(*flat1009) + flat1001 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1001 != nil { + p.write(*flat1001) return nil } else { - fields1006 := msg + fields998 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1006) == 0) { + if !(len(fields998) == 0) { p.newline() - for i1008, elem1007 := range fields1006 { - if (i1008 > 0) { + for i1000, elem999 := range fields998 { + if (i1000 > 0) { p.newline() } - p.pretty_attribute(elem1007) + p.pretty_attribute(elem999) } } p.dedent() @@ -2791,31 +2782,31 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1016 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1016 != nil { - p.write(*flat1016) + flat1008 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1008 != nil { + p.write(*flat1008) return nil } else { - _t1555 := func(_dollar_dollar *pb.Attribute) []interface{} { + _t1539 := func(_dollar_dollar *pb.Attribute) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} } - _t1556 := _t1555(msg) - fields1010 := _t1556 - unwrapped_fields1011 := fields1010 + _t1540 := _t1539(msg) + fields1002 := _t1540 + unwrapped_fields1003 := fields1002 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1012 := unwrapped_fields1011[0].(string) - p.pretty_name(field1012) - field1013 := unwrapped_fields1011[1].([]*pb.Value) - if !(len(field1013) == 0) { + field1004 := unwrapped_fields1003[0].(string) + p.pretty_name(field1004) + field1005 := unwrapped_fields1003[1].([]*pb.Value) + if !(len(field1005) == 0) { p.newline() - for i1015, elem1014 := range field1013 { - if (i1015 > 0) { + for i1007, elem1006 := range field1005 { + if (i1007 > 0) { p.newline() } - p.pretty_value(elem1014) + p.pretty_value(elem1006) } } p.dedent() @@ -2825,33 +2816,33 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1023 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1023 != nil { - p.write(*flat1023) + flat1015 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1015 != nil { + p.write(*flat1015) return nil } else { - _t1557 := func(_dollar_dollar *pb.Algorithm) []interface{} { + _t1541 := func(_dollar_dollar *pb.Algorithm) []interface{} { return []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()} } - _t1558 := _t1557(msg) - fields1017 := _t1558 - unwrapped_fields1018 := fields1017 + _t1542 := _t1541(msg) + fields1009 := _t1542 + unwrapped_fields1010 := fields1009 p.write("(") p.write("algorithm") p.indentSexp() - field1019 := unwrapped_fields1018[0].([]*pb.RelationId) - if !(len(field1019) == 0) { + field1011 := unwrapped_fields1010[0].([]*pb.RelationId) + if !(len(field1011) == 0) { p.newline() - for i1021, elem1020 := range field1019 { - if (i1021 > 0) { + for i1013, elem1012 := range field1011 { + if (i1013 > 0) { p.newline() } - p.pretty_relation_id(elem1020) + p.pretty_relation_id(elem1012) } } p.newline() - field1022 := unwrapped_fields1018[1].(*pb.Script) - p.pretty_script(field1022) + field1014 := unwrapped_fields1010[1].(*pb.Script) + p.pretty_script(field1014) p.dedent() p.write(")") } @@ -2859,27 +2850,27 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1028 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1028 != nil { - p.write(*flat1028) + flat1020 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1020 != nil { + p.write(*flat1020) return nil } else { - _t1559 := func(_dollar_dollar *pb.Script) []*pb.Construct { + _t1543 := func(_dollar_dollar *pb.Script) []*pb.Construct { return _dollar_dollar.GetConstructs() } - _t1560 := _t1559(msg) - fields1024 := _t1560 - unwrapped_fields1025 := fields1024 + _t1544 := _t1543(msg) + fields1016 := _t1544 + unwrapped_fields1017 := fields1016 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1025) == 0) { + if !(len(unwrapped_fields1017) == 0) { p.newline() - for i1027, elem1026 := range unwrapped_fields1025 { - if (i1027 > 0) { + for i1019, elem1018 := range unwrapped_fields1017 { + if (i1019 > 0) { p.newline() } - p.pretty_construct(elem1026) + p.pretty_construct(elem1018) } } p.dedent() @@ -2889,36 +2880,36 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1033 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1033 != nil { - p.write(*flat1033) + flat1025 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1025 != nil { + p.write(*flat1025) return nil } else { - _t1561 := func(_dollar_dollar *pb.Construct) *pb.Loop { - var _t1562 *pb.Loop + _t1545 := func(_dollar_dollar *pb.Construct) *pb.Loop { + var _t1546 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1562 = _dollar_dollar.GetLoop() + _t1546 = _dollar_dollar.GetLoop() } - return _t1562 + return _t1546 } - _t1563 := _t1561(msg) - deconstruct_result1031 := _t1563 - if deconstruct_result1031 != nil { - unwrapped1032 := deconstruct_result1031 - p.pretty_loop(unwrapped1032) + _t1547 := _t1545(msg) + deconstruct_result1023 := _t1547 + if deconstruct_result1023 != nil { + unwrapped1024 := deconstruct_result1023 + p.pretty_loop(unwrapped1024) } else { - _t1564 := func(_dollar_dollar *pb.Construct) *pb.Instruction { - var _t1565 *pb.Instruction + _t1548 := func(_dollar_dollar *pb.Construct) *pb.Instruction { + var _t1549 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1565 = _dollar_dollar.GetInstruction() + _t1549 = _dollar_dollar.GetInstruction() } - return _t1565 + return _t1549 } - _t1566 := _t1564(msg) - deconstruct_result1029 := _t1566 - if deconstruct_result1029 != nil { - unwrapped1030 := deconstruct_result1029 - p.pretty_instruction(unwrapped1030) + _t1550 := _t1548(msg) + deconstruct_result1021 := _t1550 + if deconstruct_result1021 != nil { + unwrapped1022 := deconstruct_result1021 + p.pretty_instruction(unwrapped1022) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -2928,26 +2919,26 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1038 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1038 != nil { - p.write(*flat1038) + flat1030 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1030 != nil { + p.write(*flat1030) return nil } else { - _t1567 := func(_dollar_dollar *pb.Loop) []interface{} { + _t1551 := func(_dollar_dollar *pb.Loop) []interface{} { return []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()} } - _t1568 := _t1567(msg) - fields1034 := _t1568 - unwrapped_fields1035 := fields1034 + _t1552 := _t1551(msg) + fields1026 := _t1552 + unwrapped_fields1027 := fields1026 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1036 := unwrapped_fields1035[0].([]*pb.Instruction) - p.pretty_init(field1036) + field1028 := unwrapped_fields1027[0].([]*pb.Instruction) + p.pretty_init(field1028) p.newline() - field1037 := unwrapped_fields1035[1].(*pb.Script) - p.pretty_script(field1037) + field1029 := unwrapped_fields1027[1].(*pb.Script) + p.pretty_script(field1029) p.dedent() p.write(")") } @@ -2955,22 +2946,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1042 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1042 != nil { - p.write(*flat1042) + flat1034 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1034 != nil { + p.write(*flat1034) return nil } else { - fields1039 := msg + fields1031 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1039) == 0) { + if !(len(fields1031) == 0) { p.newline() - for i1041, elem1040 := range fields1039 { - if (i1041 > 0) { + for i1033, elem1032 := range fields1031 { + if (i1033 > 0) { p.newline() } - p.pretty_instruction(elem1040) + p.pretty_instruction(elem1032) } } p.dedent() @@ -2980,75 +2971,75 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1053 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1053 != nil { - p.write(*flat1053) + flat1045 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1045 != nil { + p.write(*flat1045) return nil } else { - _t1569 := func(_dollar_dollar *pb.Instruction) *pb.Assign { - var _t1570 *pb.Assign + _t1553 := func(_dollar_dollar *pb.Instruction) *pb.Assign { + var _t1554 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1570 = _dollar_dollar.GetAssign() + _t1554 = _dollar_dollar.GetAssign() } - return _t1570 + return _t1554 } - _t1571 := _t1569(msg) - deconstruct_result1051 := _t1571 - if deconstruct_result1051 != nil { - unwrapped1052 := deconstruct_result1051 - p.pretty_assign(unwrapped1052) + _t1555 := _t1553(msg) + deconstruct_result1043 := _t1555 + if deconstruct_result1043 != nil { + unwrapped1044 := deconstruct_result1043 + p.pretty_assign(unwrapped1044) } else { - _t1572 := func(_dollar_dollar *pb.Instruction) *pb.Upsert { - var _t1573 *pb.Upsert + _t1556 := func(_dollar_dollar *pb.Instruction) *pb.Upsert { + var _t1557 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1573 = _dollar_dollar.GetUpsert() + _t1557 = _dollar_dollar.GetUpsert() } - return _t1573 + return _t1557 } - _t1574 := _t1572(msg) - deconstruct_result1049 := _t1574 - if deconstruct_result1049 != nil { - unwrapped1050 := deconstruct_result1049 - p.pretty_upsert(unwrapped1050) + _t1558 := _t1556(msg) + deconstruct_result1041 := _t1558 + if deconstruct_result1041 != nil { + unwrapped1042 := deconstruct_result1041 + p.pretty_upsert(unwrapped1042) } else { - _t1575 := func(_dollar_dollar *pb.Instruction) *pb.Break { - var _t1576 *pb.Break + _t1559 := func(_dollar_dollar *pb.Instruction) *pb.Break { + var _t1560 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1576 = _dollar_dollar.GetBreak() + _t1560 = _dollar_dollar.GetBreak() } - return _t1576 + return _t1560 } - _t1577 := _t1575(msg) - deconstruct_result1047 := _t1577 - if deconstruct_result1047 != nil { - unwrapped1048 := deconstruct_result1047 - p.pretty_break(unwrapped1048) + _t1561 := _t1559(msg) + deconstruct_result1039 := _t1561 + if deconstruct_result1039 != nil { + unwrapped1040 := deconstruct_result1039 + p.pretty_break(unwrapped1040) } else { - _t1578 := func(_dollar_dollar *pb.Instruction) *pb.MonoidDef { - var _t1579 *pb.MonoidDef + _t1562 := func(_dollar_dollar *pb.Instruction) *pb.MonoidDef { + var _t1563 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1579 = _dollar_dollar.GetMonoidDef() + _t1563 = _dollar_dollar.GetMonoidDef() } - return _t1579 + return _t1563 } - _t1580 := _t1578(msg) - deconstruct_result1045 := _t1580 - if deconstruct_result1045 != nil { - unwrapped1046 := deconstruct_result1045 - p.pretty_monoid_def(unwrapped1046) + _t1564 := _t1562(msg) + deconstruct_result1037 := _t1564 + if deconstruct_result1037 != nil { + unwrapped1038 := deconstruct_result1037 + p.pretty_monoid_def(unwrapped1038) } else { - _t1581 := func(_dollar_dollar *pb.Instruction) *pb.MonusDef { - var _t1582 *pb.MonusDef + _t1565 := func(_dollar_dollar *pb.Instruction) *pb.MonusDef { + var _t1566 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1582 = _dollar_dollar.GetMonusDef() + _t1566 = _dollar_dollar.GetMonusDef() } - return _t1582 + return _t1566 } - _t1583 := _t1581(msg) - deconstruct_result1043 := _t1583 - if deconstruct_result1043 != nil { - unwrapped1044 := deconstruct_result1043 - p.pretty_monus_def(unwrapped1044) + _t1567 := _t1565(msg) + deconstruct_result1035 := _t1567 + if deconstruct_result1035 != nil { + unwrapped1036 := deconstruct_result1035 + p.pretty_monus_def(unwrapped1036) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3061,35 +3052,35 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1060 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1060 != nil { - p.write(*flat1060) + flat1052 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1052 != nil { + p.write(*flat1052) return nil } else { - _t1584 := func(_dollar_dollar *pb.Assign) []interface{} { - var _t1585 []*pb.Attribute + _t1568 := func(_dollar_dollar *pb.Assign) []interface{} { + var _t1569 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1585 = _dollar_dollar.GetAttrs() + _t1569 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1585} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1569} } - _t1586 := _t1584(msg) - fields1054 := _t1586 - unwrapped_fields1055 := fields1054 + _t1570 := _t1568(msg) + fields1046 := _t1570 + unwrapped_fields1047 := fields1046 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1056 := unwrapped_fields1055[0].(*pb.RelationId) - p.pretty_relation_id(field1056) + field1048 := unwrapped_fields1047[0].(*pb.RelationId) + p.pretty_relation_id(field1048) p.newline() - field1057 := unwrapped_fields1055[1].(*pb.Abstraction) - p.pretty_abstraction(field1057) - field1058 := unwrapped_fields1055[2].([]*pb.Attribute) - if field1058 != nil { + field1049 := unwrapped_fields1047[1].(*pb.Abstraction) + p.pretty_abstraction(field1049) + field1050 := unwrapped_fields1047[2].([]*pb.Attribute) + if field1050 != nil { p.newline() - opt_val1059 := field1058 - p.pretty_attrs(opt_val1059) + opt_val1051 := field1050 + p.pretty_attrs(opt_val1051) } p.dedent() p.write(")") @@ -3098,35 +3089,35 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1067 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1067 != nil { - p.write(*flat1067) + flat1059 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1059 != nil { + p.write(*flat1059) return nil } else { - _t1587 := func(_dollar_dollar *pb.Upsert) []interface{} { - var _t1588 []*pb.Attribute + _t1571 := func(_dollar_dollar *pb.Upsert) []interface{} { + var _t1572 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1588 = _dollar_dollar.GetAttrs() + _t1572 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1588} + return []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1572} } - _t1589 := _t1587(msg) - fields1061 := _t1589 - unwrapped_fields1062 := fields1061 + _t1573 := _t1571(msg) + fields1053 := _t1573 + unwrapped_fields1054 := fields1053 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1063 := unwrapped_fields1062[0].(*pb.RelationId) - p.pretty_relation_id(field1063) + field1055 := unwrapped_fields1054[0].(*pb.RelationId) + p.pretty_relation_id(field1055) p.newline() - field1064 := unwrapped_fields1062[1].([]interface{}) - p.pretty_abstraction_with_arity(field1064) - field1065 := unwrapped_fields1062[2].([]*pb.Attribute) - if field1065 != nil { + field1056 := unwrapped_fields1054[1].([]interface{}) + p.pretty_abstraction_with_arity(field1056) + field1057 := unwrapped_fields1054[2].([]*pb.Attribute) + if field1057 != nil { p.newline() - opt_val1066 := field1065 - p.pretty_attrs(opt_val1066) + opt_val1058 := field1057 + p.pretty_attrs(opt_val1058) } p.dedent() p.write(")") @@ -3135,25 +3126,25 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1072 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1072 != nil { - p.write(*flat1072) + flat1064 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1064 != nil { + p.write(*flat1064) return nil } else { - _t1590 := func(_dollar_dollar []interface{}) []interface{} { - _t1591 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - return []interface{}{_t1591, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + _t1574 := func(_dollar_dollar []interface{}) []interface{} { + _t1575 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + return []interface{}{_t1575, _dollar_dollar[0].(*pb.Abstraction).GetValue()} } - _t1592 := _t1590(msg) - fields1068 := _t1592 - unwrapped_fields1069 := fields1068 + _t1576 := _t1574(msg) + fields1060 := _t1576 + unwrapped_fields1061 := fields1060 p.write("(") p.indent() - field1070 := unwrapped_fields1069[0].([]interface{}) - p.pretty_bindings(field1070) + field1062 := unwrapped_fields1061[0].([]interface{}) + p.pretty_bindings(field1062) p.newline() - field1071 := unwrapped_fields1069[1].(*pb.Formula) - p.pretty_formula(field1071) + field1063 := unwrapped_fields1061[1].(*pb.Formula) + p.pretty_formula(field1063) p.dedent() p.write(")") } @@ -3161,35 +3152,35 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1079 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1079 != nil { - p.write(*flat1079) + flat1071 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1071 != nil { + p.write(*flat1071) return nil } else { - _t1593 := func(_dollar_dollar *pb.Break) []interface{} { - var _t1594 []*pb.Attribute + _t1577 := func(_dollar_dollar *pb.Break) []interface{} { + var _t1578 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1594 = _dollar_dollar.GetAttrs() + _t1578 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1594} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1578} } - _t1595 := _t1593(msg) - fields1073 := _t1595 - unwrapped_fields1074 := fields1073 + _t1579 := _t1577(msg) + fields1065 := _t1579 + unwrapped_fields1066 := fields1065 p.write("(") p.write("break") p.indentSexp() p.newline() - field1075 := unwrapped_fields1074[0].(*pb.RelationId) - p.pretty_relation_id(field1075) + field1067 := unwrapped_fields1066[0].(*pb.RelationId) + p.pretty_relation_id(field1067) p.newline() - field1076 := unwrapped_fields1074[1].(*pb.Abstraction) - p.pretty_abstraction(field1076) - field1077 := unwrapped_fields1074[2].([]*pb.Attribute) - if field1077 != nil { + field1068 := unwrapped_fields1066[1].(*pb.Abstraction) + p.pretty_abstraction(field1068) + field1069 := unwrapped_fields1066[2].([]*pb.Attribute) + if field1069 != nil { p.newline() - opt_val1078 := field1077 - p.pretty_attrs(opt_val1078) + opt_val1070 := field1069 + p.pretty_attrs(opt_val1070) } p.dedent() p.write(")") @@ -3198,38 +3189,38 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1087 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1087 != nil { - p.write(*flat1087) + flat1079 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1079 != nil { + p.write(*flat1079) return nil } else { - _t1596 := func(_dollar_dollar *pb.MonoidDef) []interface{} { - var _t1597 []*pb.Attribute + _t1580 := func(_dollar_dollar *pb.MonoidDef) []interface{} { + var _t1581 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1597 = _dollar_dollar.GetAttrs() + _t1581 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1597} + return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1581} } - _t1598 := _t1596(msg) - fields1080 := _t1598 - unwrapped_fields1081 := fields1080 + _t1582 := _t1580(msg) + fields1072 := _t1582 + unwrapped_fields1073 := fields1072 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1082 := unwrapped_fields1081[0].(*pb.Monoid) - p.pretty_monoid(field1082) + field1074 := unwrapped_fields1073[0].(*pb.Monoid) + p.pretty_monoid(field1074) p.newline() - field1083 := unwrapped_fields1081[1].(*pb.RelationId) - p.pretty_relation_id(field1083) + field1075 := unwrapped_fields1073[1].(*pb.RelationId) + p.pretty_relation_id(field1075) p.newline() - field1084 := unwrapped_fields1081[2].([]interface{}) - p.pretty_abstraction_with_arity(field1084) - field1085 := unwrapped_fields1081[3].([]*pb.Attribute) - if field1085 != nil { + field1076 := unwrapped_fields1073[2].([]interface{}) + p.pretty_abstraction_with_arity(field1076) + field1077 := unwrapped_fields1073[3].([]*pb.Attribute) + if field1077 != nil { p.newline() - opt_val1086 := field1085 - p.pretty_attrs(opt_val1086) + opt_val1078 := field1077 + p.pretty_attrs(opt_val1078) } p.dedent() p.write(")") @@ -3238,62 +3229,62 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1096 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1096 != nil { - p.write(*flat1096) + flat1088 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1088 != nil { + p.write(*flat1088) return nil } else { - _t1599 := func(_dollar_dollar *pb.Monoid) *pb.OrMonoid { - var _t1600 *pb.OrMonoid + _t1583 := func(_dollar_dollar *pb.Monoid) *pb.OrMonoid { + var _t1584 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1600 = _dollar_dollar.GetOrMonoid() + _t1584 = _dollar_dollar.GetOrMonoid() } - return _t1600 + return _t1584 } - _t1601 := _t1599(msg) - deconstruct_result1094 := _t1601 - if deconstruct_result1094 != nil { - unwrapped1095 := deconstruct_result1094 - p.pretty_or_monoid(unwrapped1095) + _t1585 := _t1583(msg) + deconstruct_result1086 := _t1585 + if deconstruct_result1086 != nil { + unwrapped1087 := deconstruct_result1086 + p.pretty_or_monoid(unwrapped1087) } else { - _t1602 := func(_dollar_dollar *pb.Monoid) *pb.MinMonoid { - var _t1603 *pb.MinMonoid + _t1586 := func(_dollar_dollar *pb.Monoid) *pb.MinMonoid { + var _t1587 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1603 = _dollar_dollar.GetMinMonoid() + _t1587 = _dollar_dollar.GetMinMonoid() } - return _t1603 + return _t1587 } - _t1604 := _t1602(msg) - deconstruct_result1092 := _t1604 - if deconstruct_result1092 != nil { - unwrapped1093 := deconstruct_result1092 - p.pretty_min_monoid(unwrapped1093) + _t1588 := _t1586(msg) + deconstruct_result1084 := _t1588 + if deconstruct_result1084 != nil { + unwrapped1085 := deconstruct_result1084 + p.pretty_min_monoid(unwrapped1085) } else { - _t1605 := func(_dollar_dollar *pb.Monoid) *pb.MaxMonoid { - var _t1606 *pb.MaxMonoid + _t1589 := func(_dollar_dollar *pb.Monoid) *pb.MaxMonoid { + var _t1590 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1606 = _dollar_dollar.GetMaxMonoid() + _t1590 = _dollar_dollar.GetMaxMonoid() } - return _t1606 + return _t1590 } - _t1607 := _t1605(msg) - deconstruct_result1090 := _t1607 - if deconstruct_result1090 != nil { - unwrapped1091 := deconstruct_result1090 - p.pretty_max_monoid(unwrapped1091) + _t1591 := _t1589(msg) + deconstruct_result1082 := _t1591 + if deconstruct_result1082 != nil { + unwrapped1083 := deconstruct_result1082 + p.pretty_max_monoid(unwrapped1083) } else { - _t1608 := func(_dollar_dollar *pb.Monoid) *pb.SumMonoid { - var _t1609 *pb.SumMonoid + _t1592 := func(_dollar_dollar *pb.Monoid) *pb.SumMonoid { + var _t1593 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1609 = _dollar_dollar.GetSumMonoid() + _t1593 = _dollar_dollar.GetSumMonoid() } - return _t1609 + return _t1593 } - _t1610 := _t1608(msg) - deconstruct_result1088 := _t1610 - if deconstruct_result1088 != nil { - unwrapped1089 := deconstruct_result1088 - p.pretty_sum_monoid(unwrapped1089) + _t1594 := _t1592(msg) + deconstruct_result1080 := _t1594 + if deconstruct_result1080 != nil { + unwrapped1081 := deconstruct_result1080 + p.pretty_sum_monoid(unwrapped1081) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3305,8 +3296,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1097 := msg - _ = fields1097 + fields1089 := msg + _ = fields1089 p.write("(") p.write("or") p.write(")") @@ -3314,22 +3305,22 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1100 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1100 != nil { - p.write(*flat1100) + flat1092 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1092 != nil { + p.write(*flat1092) return nil } else { - _t1611 := func(_dollar_dollar *pb.MinMonoid) *pb.Type { + _t1595 := func(_dollar_dollar *pb.MinMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1612 := _t1611(msg) - fields1098 := _t1612 - unwrapped_fields1099 := fields1098 + _t1596 := _t1595(msg) + fields1090 := _t1596 + unwrapped_fields1091 := fields1090 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1099) + p.pretty_type(unwrapped_fields1091) p.dedent() p.write(")") } @@ -3337,22 +3328,22 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1103 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1103 != nil { - p.write(*flat1103) + flat1095 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1095 != nil { + p.write(*flat1095) return nil } else { - _t1613 := func(_dollar_dollar *pb.MaxMonoid) *pb.Type { + _t1597 := func(_dollar_dollar *pb.MaxMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1614 := _t1613(msg) - fields1101 := _t1614 - unwrapped_fields1102 := fields1101 + _t1598 := _t1597(msg) + fields1093 := _t1598 + unwrapped_fields1094 := fields1093 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1102) + p.pretty_type(unwrapped_fields1094) p.dedent() p.write(")") } @@ -3360,22 +3351,22 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1106 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1106 != nil { - p.write(*flat1106) + flat1098 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1098 != nil { + p.write(*flat1098) return nil } else { - _t1615 := func(_dollar_dollar *pb.SumMonoid) *pb.Type { + _t1599 := func(_dollar_dollar *pb.SumMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1616 := _t1615(msg) - fields1104 := _t1616 - unwrapped_fields1105 := fields1104 + _t1600 := _t1599(msg) + fields1096 := _t1600 + unwrapped_fields1097 := fields1096 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1105) + p.pretty_type(unwrapped_fields1097) p.dedent() p.write(")") } @@ -3383,38 +3374,38 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1114 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1114 != nil { - p.write(*flat1114) + flat1106 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1106 != nil { + p.write(*flat1106) return nil } else { - _t1617 := func(_dollar_dollar *pb.MonusDef) []interface{} { - var _t1618 []*pb.Attribute + _t1601 := func(_dollar_dollar *pb.MonusDef) []interface{} { + var _t1602 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1618 = _dollar_dollar.GetAttrs() + _t1602 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1618} + return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1602} } - _t1619 := _t1617(msg) - fields1107 := _t1619 - unwrapped_fields1108 := fields1107 + _t1603 := _t1601(msg) + fields1099 := _t1603 + unwrapped_fields1100 := fields1099 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1109 := unwrapped_fields1108[0].(*pb.Monoid) - p.pretty_monoid(field1109) + field1101 := unwrapped_fields1100[0].(*pb.Monoid) + p.pretty_monoid(field1101) p.newline() - field1110 := unwrapped_fields1108[1].(*pb.RelationId) - p.pretty_relation_id(field1110) + field1102 := unwrapped_fields1100[1].(*pb.RelationId) + p.pretty_relation_id(field1102) p.newline() - field1111 := unwrapped_fields1108[2].([]interface{}) - p.pretty_abstraction_with_arity(field1111) - field1112 := unwrapped_fields1108[3].([]*pb.Attribute) - if field1112 != nil { + field1103 := unwrapped_fields1100[2].([]interface{}) + p.pretty_abstraction_with_arity(field1103) + field1104 := unwrapped_fields1100[3].([]*pb.Attribute) + if field1104 != nil { p.newline() - opt_val1113 := field1112 - p.pretty_attrs(opt_val1113) + opt_val1105 := field1104 + p.pretty_attrs(opt_val1105) } p.dedent() p.write(")") @@ -3423,32 +3414,32 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1121 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1121 != nil { - p.write(*flat1121) + flat1113 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1113 != nil { + p.write(*flat1113) return nil } else { - _t1620 := func(_dollar_dollar *pb.Constraint) []interface{} { + _t1604 := func(_dollar_dollar *pb.Constraint) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} } - _t1621 := _t1620(msg) - fields1115 := _t1621 - unwrapped_fields1116 := fields1115 + _t1605 := _t1604(msg) + fields1107 := _t1605 + unwrapped_fields1108 := fields1107 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1117 := unwrapped_fields1116[0].(*pb.RelationId) - p.pretty_relation_id(field1117) + field1109 := unwrapped_fields1108[0].(*pb.RelationId) + p.pretty_relation_id(field1109) p.newline() - field1118 := unwrapped_fields1116[1].(*pb.Abstraction) - p.pretty_abstraction(field1118) + field1110 := unwrapped_fields1108[1].(*pb.Abstraction) + p.pretty_abstraction(field1110) p.newline() - field1119 := unwrapped_fields1116[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1119) + field1111 := unwrapped_fields1108[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1111) p.newline() - field1120 := unwrapped_fields1116[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1120) + field1112 := unwrapped_fields1108[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1112) p.dedent() p.write(")") } @@ -3456,22 +3447,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1125 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1125 != nil { - p.write(*flat1125) + flat1117 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1117 != nil { + p.write(*flat1117) return nil } else { - fields1122 := msg + fields1114 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1122) == 0) { + if !(len(fields1114) == 0) { p.newline() - for i1124, elem1123 := range fields1122 { - if (i1124 > 0) { + for i1116, elem1115 := range fields1114 { + if (i1116 > 0) { p.newline() } - p.pretty_var(elem1123) + p.pretty_var(elem1115) } } p.dedent() @@ -3481,22 +3472,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1129 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1129 != nil { - p.write(*flat1129) + flat1121 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1121 != nil { + p.write(*flat1121) return nil } else { - fields1126 := msg + fields1118 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1126) == 0) { + if !(len(fields1118) == 0) { p.newline() - for i1128, elem1127 := range fields1126 { - if (i1128 > 0) { + for i1120, elem1119 := range fields1118 { + if (i1120 > 0) { p.newline() } - p.pretty_var(elem1127) + p.pretty_var(elem1119) } } p.dedent() @@ -3506,49 +3497,49 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1136 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1136 != nil { - p.write(*flat1136) + flat1128 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1128 != nil { + p.write(*flat1128) return nil } else { - _t1622 := func(_dollar_dollar *pb.Data) *pb.RelEDB { - var _t1623 *pb.RelEDB - if hasProtoField(_dollar_dollar, "rel_edb") { - _t1623 = _dollar_dollar.GetRelEdb() + _t1606 := func(_dollar_dollar *pb.Data) *pb.EDB { + var _t1607 *pb.EDB + if hasProtoField(_dollar_dollar, "edb") { + _t1607 = _dollar_dollar.GetEdb() } - return _t1623 + return _t1607 } - _t1624 := _t1622(msg) - deconstruct_result1134 := _t1624 - if deconstruct_result1134 != nil { - unwrapped1135 := deconstruct_result1134 - p.pretty_rel_edb(unwrapped1135) + _t1608 := _t1606(msg) + deconstruct_result1126 := _t1608 + if deconstruct_result1126 != nil { + unwrapped1127 := deconstruct_result1126 + p.pretty_edb(unwrapped1127) } else { - _t1625 := func(_dollar_dollar *pb.Data) *pb.BeTreeRelation { - var _t1626 *pb.BeTreeRelation + _t1609 := func(_dollar_dollar *pb.Data) *pb.BeTreeRelation { + var _t1610 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1626 = _dollar_dollar.GetBetreeRelation() + _t1610 = _dollar_dollar.GetBetreeRelation() } - return _t1626 + return _t1610 } - _t1627 := _t1625(msg) - deconstruct_result1132 := _t1627 - if deconstruct_result1132 != nil { - unwrapped1133 := deconstruct_result1132 - p.pretty_betree_relation(unwrapped1133) + _t1611 := _t1609(msg) + deconstruct_result1124 := _t1611 + if deconstruct_result1124 != nil { + unwrapped1125 := deconstruct_result1124 + p.pretty_betree_relation(unwrapped1125) } else { - _t1628 := func(_dollar_dollar *pb.Data) *pb.CSVData { - var _t1629 *pb.CSVData + _t1612 := func(_dollar_dollar *pb.Data) *pb.CSVData { + var _t1613 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1629 = _dollar_dollar.GetCsvData() + _t1613 = _dollar_dollar.GetCsvData() } - return _t1629 + return _t1613 } - _t1630 := _t1628(msg) - deconstruct_result1130 := _t1630 - if deconstruct_result1130 != nil { - unwrapped1131 := deconstruct_result1130 - p.pretty_csv_data(unwrapped1131) + _t1614 := _t1612(msg) + deconstruct_result1122 := _t1614 + if deconstruct_result1122 != nil { + unwrapped1123 := deconstruct_result1122 + p.pretty_csv_data(unwrapped1123) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3558,50 +3549,50 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { return nil } -func (p *PrettyPrinter) pretty_rel_edb(msg *pb.RelEDB) interface{} { - flat1142 := p.tryFlat(msg, func() { p.pretty_rel_edb(msg) }) - if flat1142 != nil { - p.write(*flat1142) +func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { + flat1134 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1134 != nil { + p.write(*flat1134) return nil } else { - _t1631 := func(_dollar_dollar *pb.RelEDB) []interface{} { + _t1615 := func(_dollar_dollar *pb.EDB) []interface{} { return []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} } - _t1632 := _t1631(msg) - fields1137 := _t1632 - unwrapped_fields1138 := fields1137 + _t1616 := _t1615(msg) + fields1129 := _t1616 + unwrapped_fields1130 := fields1129 p.write("(") - p.write("rel_edb") + p.write("edb") p.indentSexp() p.newline() - field1139 := unwrapped_fields1138[0].(*pb.RelationId) - p.pretty_relation_id(field1139) + field1131 := unwrapped_fields1130[0].(*pb.RelationId) + p.pretty_relation_id(field1131) p.newline() - field1140 := unwrapped_fields1138[1].([]string) - p.pretty_rel_edb_path(field1140) + field1132 := unwrapped_fields1130[1].([]string) + p.pretty_edb_path(field1132) p.newline() - field1141 := unwrapped_fields1138[2].([]*pb.Type) - p.pretty_rel_edb_types(field1141) + field1133 := unwrapped_fields1130[2].([]*pb.Type) + p.pretty_edb_types(field1133) p.dedent() p.write(")") } return nil } -func (p *PrettyPrinter) pretty_rel_edb_path(msg []string) interface{} { - flat1146 := p.tryFlat(msg, func() { p.pretty_rel_edb_path(msg) }) - if flat1146 != nil { - p.write(*flat1146) +func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { + flat1138 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1138 != nil { + p.write(*flat1138) return nil } else { - fields1143 := msg + fields1135 := msg p.write("[") p.indent() - for i1145, elem1144 := range fields1143 { - if (i1145 > 0) { + for i1137, elem1136 := range fields1135 { + if (i1137 > 0) { p.newline() } - p.write(p.formatStringValue(elem1144)) + p.write(p.formatStringValue(elem1136)) } p.dedent() p.write("]") @@ -3609,20 +3600,20 @@ func (p *PrettyPrinter) pretty_rel_edb_path(msg []string) interface{} { return nil } -func (p *PrettyPrinter) pretty_rel_edb_types(msg []*pb.Type) interface{} { - flat1150 := p.tryFlat(msg, func() { p.pretty_rel_edb_types(msg) }) - if flat1150 != nil { - p.write(*flat1150) +func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { + flat1142 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1142 != nil { + p.write(*flat1142) return nil } else { - fields1147 := msg + fields1139 := msg p.write("[") p.indent() - for i1149, elem1148 := range fields1147 { - if (i1149 > 0) { + for i1141, elem1140 := range fields1139 { + if (i1141 > 0) { p.newline() } - p.pretty_type(elem1148) + p.pretty_type(elem1140) } p.dedent() p.write("]") @@ -3631,26 +3622,26 @@ func (p *PrettyPrinter) pretty_rel_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1155 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1155 != nil { - p.write(*flat1155) + flat1147 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1147 != nil { + p.write(*flat1147) return nil } else { - _t1633 := func(_dollar_dollar *pb.BeTreeRelation) []interface{} { + _t1617 := func(_dollar_dollar *pb.BeTreeRelation) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} } - _t1634 := _t1633(msg) - fields1151 := _t1634 - unwrapped_fields1152 := fields1151 + _t1618 := _t1617(msg) + fields1143 := _t1618 + unwrapped_fields1144 := fields1143 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1153 := unwrapped_fields1152[0].(*pb.RelationId) - p.pretty_relation_id(field1153) + field1145 := unwrapped_fields1144[0].(*pb.RelationId) + p.pretty_relation_id(field1145) p.newline() - field1154 := unwrapped_fields1152[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1154) + field1146 := unwrapped_fields1144[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1146) p.dedent() p.write(")") } @@ -3658,30 +3649,30 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1161 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1161 != nil { - p.write(*flat1161) + flat1153 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1153 != nil { + p.write(*flat1153) return nil } else { - _t1635 := func(_dollar_dollar *pb.BeTreeInfo) []interface{} { - _t1636 := p.deconstruct_betree_info_config(_dollar_dollar) - return []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1636} + _t1619 := func(_dollar_dollar *pb.BeTreeInfo) []interface{} { + _t1620 := p.deconstruct_betree_info_config(_dollar_dollar) + return []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1620} } - _t1637 := _t1635(msg) - fields1156 := _t1637 - unwrapped_fields1157 := fields1156 + _t1621 := _t1619(msg) + fields1148 := _t1621 + unwrapped_fields1149 := fields1148 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1158 := unwrapped_fields1157[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1158) + field1150 := unwrapped_fields1149[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1150) p.newline() - field1159 := unwrapped_fields1157[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1159) + field1151 := unwrapped_fields1149[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1151) p.newline() - field1160 := unwrapped_fields1157[2].([][]interface{}) - p.pretty_config_dict(field1160) + field1152 := unwrapped_fields1149[2].([][]interface{}) + p.pretty_config_dict(field1152) p.dedent() p.write(")") } @@ -3689,22 +3680,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1165 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1165 != nil { - p.write(*flat1165) + flat1157 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1157 != nil { + p.write(*flat1157) return nil } else { - fields1162 := msg + fields1154 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1162) == 0) { + if !(len(fields1154) == 0) { p.newline() - for i1164, elem1163 := range fields1162 { - if (i1164 > 0) { + for i1156, elem1155 := range fields1154 { + if (i1156 > 0) { p.newline() } - p.pretty_type(elem1163) + p.pretty_type(elem1155) } } p.dedent() @@ -3714,22 +3705,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{} { - flat1169 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1169 != nil { - p.write(*flat1169) + flat1161 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1161 != nil { + p.write(*flat1161) return nil } else { - fields1166 := msg + fields1158 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1166) == 0) { + if !(len(fields1158) == 0) { p.newline() - for i1168, elem1167 := range fields1166 { - if (i1168 > 0) { + for i1160, elem1159 := range fields1158 { + if (i1160 > 0) { p.newline() } - p.pretty_type(elem1167) + p.pretty_type(elem1159) } } p.dedent() @@ -3739,32 +3730,32 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1176 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1176 != nil { - p.write(*flat1176) + flat1168 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1168 != nil { + p.write(*flat1168) return nil } else { - _t1638 := func(_dollar_dollar *pb.CSVData) []interface{} { + _t1622 := func(_dollar_dollar *pb.CSVData) []interface{} { return []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} } - _t1639 := _t1638(msg) - fields1170 := _t1639 - unwrapped_fields1171 := fields1170 + _t1623 := _t1622(msg) + fields1162 := _t1623 + unwrapped_fields1163 := fields1162 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1172 := unwrapped_fields1171[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1172) + field1164 := unwrapped_fields1163[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1164) p.newline() - field1173 := unwrapped_fields1171[1].(*pb.CSVConfig) - p.pretty_csv_config(field1173) + field1165 := unwrapped_fields1163[1].(*pb.CSVConfig) + p.pretty_csv_config(field1165) p.newline() - field1174 := unwrapped_fields1171[2].([]*pb.CSVColumn) - p.pretty_csv_columns(field1174) + field1166 := unwrapped_fields1163[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1166) p.newline() - field1175 := unwrapped_fields1171[3].(string) - p.pretty_csv_asof(field1175) + field1167 := unwrapped_fields1163[3].(string) + p.pretty_csv_asof(field1167) p.dedent() p.write(")") } @@ -3772,39 +3763,39 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1183 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1183 != nil { - p.write(*flat1183) + flat1175 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1175 != nil { + p.write(*flat1175) return nil } else { - _t1640 := func(_dollar_dollar *pb.CSVLocator) []interface{} { - var _t1641 []string + _t1624 := func(_dollar_dollar *pb.CSVLocator) []interface{} { + var _t1625 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1641 = _dollar_dollar.GetPaths() + _t1625 = _dollar_dollar.GetPaths() } - var _t1642 *string + var _t1626 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1642 = ptr(string(_dollar_dollar.GetInlineData())) + _t1626 = ptr(string(_dollar_dollar.GetInlineData())) } - return []interface{}{_t1641, _t1642} + return []interface{}{_t1625, _t1626} } - _t1643 := _t1640(msg) - fields1177 := _t1643 - unwrapped_fields1178 := fields1177 + _t1627 := _t1624(msg) + fields1169 := _t1627 + unwrapped_fields1170 := fields1169 p.write("(") p.write("csv_locator") p.indentSexp() - field1179 := unwrapped_fields1178[0].([]string) - if field1179 != nil { + field1171 := unwrapped_fields1170[0].([]string) + if field1171 != nil { p.newline() - opt_val1180 := field1179 - p.pretty_csv_locator_paths(opt_val1180) + opt_val1172 := field1171 + p.pretty_csv_locator_paths(opt_val1172) } - field1181 := unwrapped_fields1178[1].(*string) - if field1181 != nil { + field1173 := unwrapped_fields1170[1].(*string) + if field1173 != nil { p.newline() - opt_val1182 := *field1181 - p.pretty_csv_locator_inline_data(opt_val1182) + opt_val1174 := *field1173 + p.pretty_csv_locator_inline_data(opt_val1174) } p.dedent() p.write(")") @@ -3813,22 +3804,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1187 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1187 != nil { - p.write(*flat1187) + flat1179 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1179 != nil { + p.write(*flat1179) return nil } else { - fields1184 := msg + fields1176 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1184) == 0) { + if !(len(fields1176) == 0) { p.newline() - for i1186, elem1185 := range fields1184 { - if (i1186 > 0) { + for i1178, elem1177 := range fields1176 { + if (i1178 > 0) { p.newline() } - p.write(p.formatStringValue(elem1185)) + p.write(p.formatStringValue(elem1177)) } } p.dedent() @@ -3838,17 +3829,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1189 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1189 != nil { - p.write(*flat1189) + flat1181 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1181 != nil { + p.write(*flat1181) return nil } else { - fields1188 := msg + fields1180 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1188)) + p.write(p.formatStringValue(fields1180)) p.dedent() p.write(")") } @@ -3856,46 +3847,46 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1192 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1192 != nil { - p.write(*flat1192) + flat1184 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1184 != nil { + p.write(*flat1184) return nil } else { - _t1644 := func(_dollar_dollar *pb.CSVConfig) [][]interface{} { - _t1645 := p.deconstruct_csv_config(_dollar_dollar) - return _t1645 + _t1628 := func(_dollar_dollar *pb.CSVConfig) [][]interface{} { + _t1629 := p.deconstruct_csv_config(_dollar_dollar) + return _t1629 } - _t1646 := _t1644(msg) - fields1190 := _t1646 - unwrapped_fields1191 := fields1190 + _t1630 := _t1628(msg) + fields1182 := _t1630 + unwrapped_fields1183 := fields1182 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields1191) + p.pretty_config_dict(unwrapped_fields1183) p.dedent() p.write(")") } return nil } -func (p *PrettyPrinter) pretty_csv_columns(msg []*pb.CSVColumn) interface{} { - flat1196 := p.tryFlat(msg, func() { p.pretty_csv_columns(msg) }) - if flat1196 != nil { - p.write(*flat1196) +func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { + flat1188 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1188 != nil { + p.write(*flat1188) return nil } else { - fields1193 := msg + fields1185 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1193) == 0) { + if !(len(fields1185) == 0) { p.newline() - for i1195, elem1194 := range fields1193 { - if (i1195 > 0) { + for i1187, elem1186 := range fields1185 { + if (i1187 > 0) { p.newline() } - p.pretty_csv_column(elem1194) + p.pretty_gnf_column(elem1186) } } p.dedent() @@ -3904,148 +3895,110 @@ func (p *PrettyPrinter) pretty_csv_columns(msg []*pb.CSVColumn) interface{} { return nil } -func (p *PrettyPrinter) pretty_csv_column(msg *pb.CSVColumn) interface{} { - flat1202 := p.tryFlat(msg, func() { p.pretty_csv_column(msg) }) - if flat1202 != nil { - p.write(*flat1202) +func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { + flat1197 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1197 != nil { + p.write(*flat1197) return nil } else { - _t1647 := func(_dollar_dollar *pb.CSVColumn) []interface{} { - _t1648 := p.deconstruct_csv_column_tail(_dollar_dollar) - return []interface{}{_dollar_dollar.GetColumnPath(), _t1648} + _t1631 := func(_dollar_dollar *pb.GNFColumn) []interface{} { + var _t1632 *pb.RelationId + if hasProtoField(_dollar_dollar, "target_id") { + _t1632 = _dollar_dollar.GetTargetId() + } + return []interface{}{_dollar_dollar.GetColumnPath(), _t1632, _dollar_dollar.GetTypes()} } - _t1649 := _t1647(msg) - fields1197 := _t1649 - unwrapped_fields1198 := fields1197 + _t1633 := _t1631(msg) + fields1189 := _t1633 + unwrapped_fields1190 := fields1189 p.write("(") p.write("column") p.indentSexp() p.newline() - field1199 := unwrapped_fields1198[0].([]string) - p.pretty_csv_column_path(field1199) - field1200 := unwrapped_fields1198[1].([]interface{}) - if field1200 != nil { + field1191 := unwrapped_fields1190[0].([]string) + p.pretty_gnf_column_path(field1191) + field1192 := unwrapped_fields1190[1].(*pb.RelationId) + if field1192 != nil { p.newline() - opt_val1201 := field1200 - p.pretty_csv_column_tail(opt_val1201) + opt_val1193 := field1192 + p.pretty_relation_id(opt_val1193) } + p.newline() + p.write("[") + field1194 := unwrapped_fields1190[2].([]*pb.Type) + for i1196, elem1195 := range field1194 { + if (i1196 > 0) { + p.newline() + } + p.pretty_type(elem1195) + } + p.write("]") p.dedent() p.write(")") } return nil } -func (p *PrettyPrinter) pretty_csv_column_path(msg []string) interface{} { - flat1209 := p.tryFlat(msg, func() { p.pretty_csv_column_path(msg) }) - if flat1209 != nil { - p.write(*flat1209) +func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { + flat1204 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1204 != nil { + p.write(*flat1204) return nil } else { - _t1650 := func(_dollar_dollar []string) *string { - var _t1651 *string + _t1634 := func(_dollar_dollar []string) *string { + var _t1635 *string if int64(len(_dollar_dollar)) == 1 { - _t1651 = ptr(_dollar_dollar[0]) + _t1635 = ptr(_dollar_dollar[0]) } - return _t1651 + return _t1635 } - _t1652 := _t1650(msg) - deconstruct_result1207 := _t1652 - if deconstruct_result1207 != nil { - unwrapped1208 := *deconstruct_result1207 - p.write(p.formatStringValue(unwrapped1208)) + _t1636 := _t1634(msg) + deconstruct_result1202 := _t1636 + if deconstruct_result1202 != nil { + unwrapped1203 := *deconstruct_result1202 + p.write(p.formatStringValue(unwrapped1203)) } else { - _t1653 := func(_dollar_dollar []string) []string { - var _t1654 []string + _t1637 := func(_dollar_dollar []string) []string { + var _t1638 []string if int64(len(_dollar_dollar)) != 1 { - _t1654 = _dollar_dollar + _t1638 = _dollar_dollar } - return _t1654 + return _t1638 } - _t1655 := _t1653(msg) - deconstruct_result1203 := _t1655 - if deconstruct_result1203 != nil { - unwrapped1204 := deconstruct_result1203 + _t1639 := _t1637(msg) + deconstruct_result1198 := _t1639 + if deconstruct_result1198 != nil { + unwrapped1199 := deconstruct_result1198 p.write("[") p.indent() - for i1206, elem1205 := range unwrapped1204 { - if (i1206 > 0) { + for i1201, elem1200 := range unwrapped1199 { + if (i1201 > 0) { p.newline() } - p.write(p.formatStringValue(elem1205)) + p.write(p.formatStringValue(elem1200)) } p.dedent() p.write("]") } else { - panic(ParseError{msg: "No matching rule for csv_column_path"}) + panic(ParseError{msg: "No matching rule for gnf_column_path"}) } } } return nil } -func (p *PrettyPrinter) pretty_csv_column_tail(msg []interface{}) interface{} { - flat1220 := p.tryFlat(msg, func() { p.pretty_csv_column_tail(msg) }) - if flat1220 != nil { - p.write(*flat1220) - return nil - } else { - _t1656 := func(_dollar_dollar []interface{}) []interface{} { - var _t1657 []interface{} - if _dollar_dollar[0].(*pb.RelationId) != nil { - _t1657 = []interface{}{_dollar_dollar[0].(*pb.RelationId), _dollar_dollar[1].([]*pb.Type)} - } - return _t1657 - } - _t1658 := _t1656(msg) - deconstruct_result1214 := _t1658 - if deconstruct_result1214 != nil { - unwrapped1215 := deconstruct_result1214 - field1216 := unwrapped1215[0].(*pb.RelationId) - p.pretty_relation_id(field1216) - p.write(" ") - p.write("[") - field1217 := unwrapped1215[1].([]*pb.Type) - for i1219, elem1218 := range field1217 { - if (i1219 > 0) { - p.newline() - } - p.pretty_type(elem1218) - } - p.write("]") - } else { - _t1659 := func(_dollar_dollar []interface{}) []*pb.Type { - return _dollar_dollar[1].([]*pb.Type) - } - _t1660 := _t1659(msg) - fields1210 := _t1660 - unwrapped_fields1211 := fields1210 - p.write("[") - p.indent() - for i1213, elem1212 := range unwrapped_fields1211 { - if (i1213 > 0) { - p.newline() - } - p.pretty_type(elem1212) - } - p.dedent() - p.write("]") - } - } - return nil -} - func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1222 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1222 != nil { - p.write(*flat1222) + flat1206 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1206 != nil { + p.write(*flat1206) return nil } else { - fields1221 := msg + fields1205 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1221)) + p.write(p.formatStringValue(fields1205)) p.dedent() p.write(")") } @@ -4053,22 +4006,22 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1225 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1225 != nil { - p.write(*flat1225) + flat1209 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1209 != nil { + p.write(*flat1209) return nil } else { - _t1661 := func(_dollar_dollar *pb.Undefine) *pb.FragmentId { + _t1640 := func(_dollar_dollar *pb.Undefine) *pb.FragmentId { return _dollar_dollar.GetFragmentId() } - _t1662 := _t1661(msg) - fields1223 := _t1662 - unwrapped_fields1224 := fields1223 + _t1641 := _t1640(msg) + fields1207 := _t1641 + unwrapped_fields1208 := fields1207 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1224) + p.pretty_fragment_id(unwrapped_fields1208) p.dedent() p.write(")") } @@ -4076,27 +4029,27 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1230 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1230 != nil { - p.write(*flat1230) + flat1214 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1214 != nil { + p.write(*flat1214) return nil } else { - _t1663 := func(_dollar_dollar *pb.Context) []*pb.RelationId { + _t1642 := func(_dollar_dollar *pb.Context) []*pb.RelationId { return _dollar_dollar.GetRelations() } - _t1664 := _t1663(msg) - fields1226 := _t1664 - unwrapped_fields1227 := fields1226 + _t1643 := _t1642(msg) + fields1210 := _t1643 + unwrapped_fields1211 := fields1210 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1227) == 0) { + if !(len(unwrapped_fields1211) == 0) { p.newline() - for i1229, elem1228 := range unwrapped_fields1227 { - if (i1229 > 0) { + for i1213, elem1212 := range unwrapped_fields1211 { + if (i1213 > 0) { p.newline() } - p.pretty_relation_id(elem1228) + p.pretty_relation_id(elem1212) } } p.dedent() @@ -4106,26 +4059,26 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1235 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1235 != nil { - p.write(*flat1235) + flat1219 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1219 != nil { + p.write(*flat1219) return nil } else { - _t1665 := func(_dollar_dollar *pb.Snapshot) []interface{} { + _t1644 := func(_dollar_dollar *pb.Snapshot) []interface{} { return []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} } - _t1666 := _t1665(msg) - fields1231 := _t1666 - unwrapped_fields1232 := fields1231 + _t1645 := _t1644(msg) + fields1215 := _t1645 + unwrapped_fields1216 := fields1215 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1233 := unwrapped_fields1232[0].([]string) - p.pretty_rel_edb_path(field1233) + field1217 := unwrapped_fields1216[0].([]string) + p.pretty_edb_path(field1217) p.newline() - field1234 := unwrapped_fields1232[1].(*pb.RelationId) - p.pretty_relation_id(field1234) + field1218 := unwrapped_fields1216[1].(*pb.RelationId) + p.pretty_relation_id(field1218) p.dedent() p.write(")") } @@ -4133,22 +4086,22 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1239 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1239 != nil { - p.write(*flat1239) + flat1223 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1223 != nil { + p.write(*flat1223) return nil } else { - fields1236 := msg + fields1220 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1236) == 0) { + if !(len(fields1220) == 0) { p.newline() - for i1238, elem1237 := range fields1236 { - if (i1238 > 0) { + for i1222, elem1221 := range fields1220 { + if (i1222 > 0) { p.newline() } - p.pretty_read(elem1237) + p.pretty_read(elem1221) } } p.dedent() @@ -4158,75 +4111,75 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1250 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1250 != nil { - p.write(*flat1250) + flat1234 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1234 != nil { + p.write(*flat1234) return nil } else { - _t1667 := func(_dollar_dollar *pb.Read) *pb.Demand { - var _t1668 *pb.Demand + _t1646 := func(_dollar_dollar *pb.Read) *pb.Demand { + var _t1647 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1668 = _dollar_dollar.GetDemand() + _t1647 = _dollar_dollar.GetDemand() } - return _t1668 + return _t1647 } - _t1669 := _t1667(msg) - deconstruct_result1248 := _t1669 - if deconstruct_result1248 != nil { - unwrapped1249 := deconstruct_result1248 - p.pretty_demand(unwrapped1249) + _t1648 := _t1646(msg) + deconstruct_result1232 := _t1648 + if deconstruct_result1232 != nil { + unwrapped1233 := deconstruct_result1232 + p.pretty_demand(unwrapped1233) } else { - _t1670 := func(_dollar_dollar *pb.Read) *pb.Output { - var _t1671 *pb.Output + _t1649 := func(_dollar_dollar *pb.Read) *pb.Output { + var _t1650 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1671 = _dollar_dollar.GetOutput() + _t1650 = _dollar_dollar.GetOutput() } - return _t1671 + return _t1650 } - _t1672 := _t1670(msg) - deconstruct_result1246 := _t1672 - if deconstruct_result1246 != nil { - unwrapped1247 := deconstruct_result1246 - p.pretty_output(unwrapped1247) + _t1651 := _t1649(msg) + deconstruct_result1230 := _t1651 + if deconstruct_result1230 != nil { + unwrapped1231 := deconstruct_result1230 + p.pretty_output(unwrapped1231) } else { - _t1673 := func(_dollar_dollar *pb.Read) *pb.WhatIf { - var _t1674 *pb.WhatIf + _t1652 := func(_dollar_dollar *pb.Read) *pb.WhatIf { + var _t1653 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1674 = _dollar_dollar.GetWhatIf() + _t1653 = _dollar_dollar.GetWhatIf() } - return _t1674 + return _t1653 } - _t1675 := _t1673(msg) - deconstruct_result1244 := _t1675 - if deconstruct_result1244 != nil { - unwrapped1245 := deconstruct_result1244 - p.pretty_what_if(unwrapped1245) + _t1654 := _t1652(msg) + deconstruct_result1228 := _t1654 + if deconstruct_result1228 != nil { + unwrapped1229 := deconstruct_result1228 + p.pretty_what_if(unwrapped1229) } else { - _t1676 := func(_dollar_dollar *pb.Read) *pb.Abort { - var _t1677 *pb.Abort + _t1655 := func(_dollar_dollar *pb.Read) *pb.Abort { + var _t1656 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1677 = _dollar_dollar.GetAbort() + _t1656 = _dollar_dollar.GetAbort() } - return _t1677 + return _t1656 } - _t1678 := _t1676(msg) - deconstruct_result1242 := _t1678 - if deconstruct_result1242 != nil { - unwrapped1243 := deconstruct_result1242 - p.pretty_abort(unwrapped1243) + _t1657 := _t1655(msg) + deconstruct_result1226 := _t1657 + if deconstruct_result1226 != nil { + unwrapped1227 := deconstruct_result1226 + p.pretty_abort(unwrapped1227) } else { - _t1679 := func(_dollar_dollar *pb.Read) *pb.Export { - var _t1680 *pb.Export + _t1658 := func(_dollar_dollar *pb.Read) *pb.Export { + var _t1659 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1680 = _dollar_dollar.GetExport() + _t1659 = _dollar_dollar.GetExport() } - return _t1680 + return _t1659 } - _t1681 := _t1679(msg) - deconstruct_result1240 := _t1681 - if deconstruct_result1240 != nil { - unwrapped1241 := deconstruct_result1240 - p.pretty_export(unwrapped1241) + _t1660 := _t1658(msg) + deconstruct_result1224 := _t1660 + if deconstruct_result1224 != nil { + unwrapped1225 := deconstruct_result1224 + p.pretty_export(unwrapped1225) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4239,22 +4192,22 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1253 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1253 != nil { - p.write(*flat1253) + flat1237 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1237 != nil { + p.write(*flat1237) return nil } else { - _t1682 := func(_dollar_dollar *pb.Demand) *pb.RelationId { + _t1661 := func(_dollar_dollar *pb.Demand) *pb.RelationId { return _dollar_dollar.GetRelationId() } - _t1683 := _t1682(msg) - fields1251 := _t1683 - unwrapped_fields1252 := fields1251 + _t1662 := _t1661(msg) + fields1235 := _t1662 + unwrapped_fields1236 := fields1235 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1252) + p.pretty_relation_id(unwrapped_fields1236) p.dedent() p.write(")") } @@ -4262,26 +4215,26 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1258 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1258 != nil { - p.write(*flat1258) + flat1242 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1242 != nil { + p.write(*flat1242) return nil } else { - _t1684 := func(_dollar_dollar *pb.Output) []interface{} { + _t1663 := func(_dollar_dollar *pb.Output) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} } - _t1685 := _t1684(msg) - fields1254 := _t1685 - unwrapped_fields1255 := fields1254 + _t1664 := _t1663(msg) + fields1238 := _t1664 + unwrapped_fields1239 := fields1238 p.write("(") p.write("output") p.indentSexp() p.newline() - field1256 := unwrapped_fields1255[0].(string) - p.pretty_name(field1256) + field1240 := unwrapped_fields1239[0].(string) + p.pretty_name(field1240) p.newline() - field1257 := unwrapped_fields1255[1].(*pb.RelationId) - p.pretty_relation_id(field1257) + field1241 := unwrapped_fields1239[1].(*pb.RelationId) + p.pretty_relation_id(field1241) p.dedent() p.write(")") } @@ -4289,26 +4242,26 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1263 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1263 != nil { - p.write(*flat1263) + flat1247 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1247 != nil { + p.write(*flat1247) return nil } else { - _t1686 := func(_dollar_dollar *pb.WhatIf) []interface{} { + _t1665 := func(_dollar_dollar *pb.WhatIf) []interface{} { return []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} } - _t1687 := _t1686(msg) - fields1259 := _t1687 - unwrapped_fields1260 := fields1259 + _t1666 := _t1665(msg) + fields1243 := _t1666 + unwrapped_fields1244 := fields1243 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1261 := unwrapped_fields1260[0].(string) - p.pretty_name(field1261) + field1245 := unwrapped_fields1244[0].(string) + p.pretty_name(field1245) p.newline() - field1262 := unwrapped_fields1260[1].(*pb.Epoch) - p.pretty_epoch(field1262) + field1246 := unwrapped_fields1244[1].(*pb.Epoch) + p.pretty_epoch(field1246) p.dedent() p.write(")") } @@ -4316,33 +4269,33 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1269 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1269 != nil { - p.write(*flat1269) + flat1253 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1253 != nil { + p.write(*flat1253) return nil } else { - _t1688 := func(_dollar_dollar *pb.Abort) []interface{} { - var _t1689 *string + _t1667 := func(_dollar_dollar *pb.Abort) []interface{} { + var _t1668 *string if _dollar_dollar.GetName() != "abort" { - _t1689 = ptr(_dollar_dollar.GetName()) + _t1668 = ptr(_dollar_dollar.GetName()) } - return []interface{}{_t1689, _dollar_dollar.GetRelationId()} + return []interface{}{_t1668, _dollar_dollar.GetRelationId()} } - _t1690 := _t1688(msg) - fields1264 := _t1690 - unwrapped_fields1265 := fields1264 + _t1669 := _t1667(msg) + fields1248 := _t1669 + unwrapped_fields1249 := fields1248 p.write("(") p.write("abort") p.indentSexp() - field1266 := unwrapped_fields1265[0].(*string) - if field1266 != nil { + field1250 := unwrapped_fields1249[0].(*string) + if field1250 != nil { p.newline() - opt_val1267 := *field1266 - p.pretty_name(opt_val1267) + opt_val1251 := *field1250 + p.pretty_name(opt_val1251) } p.newline() - field1268 := unwrapped_fields1265[1].(*pb.RelationId) - p.pretty_relation_id(field1268) + field1252 := unwrapped_fields1249[1].(*pb.RelationId) + p.pretty_relation_id(field1252) p.dedent() p.write(")") } @@ -4350,22 +4303,22 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1272 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1272 != nil { - p.write(*flat1272) + flat1256 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1256 != nil { + p.write(*flat1256) return nil } else { - _t1691 := func(_dollar_dollar *pb.Export) *pb.ExportCSVConfig { + _t1670 := func(_dollar_dollar *pb.Export) *pb.ExportCSVConfig { return _dollar_dollar.GetCsvConfig() } - _t1692 := _t1691(msg) - fields1270 := _t1692 - unwrapped_fields1271 := fields1270 + _t1671 := _t1670(msg) + fields1254 := _t1671 + unwrapped_fields1255 := fields1254 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped_fields1271) + p.pretty_export_csv_config(unwrapped_fields1255) p.dedent() p.write(")") } @@ -4373,30 +4326,30 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1278 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1278 != nil { - p.write(*flat1278) + flat1262 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1262 != nil { + p.write(*flat1262) return nil } else { - _t1693 := func(_dollar_dollar *pb.ExportCSVConfig) []interface{} { - _t1694 := p.deconstruct_export_csv_config(_dollar_dollar) - return []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1694} + _t1672 := func(_dollar_dollar *pb.ExportCSVConfig) []interface{} { + _t1673 := p.deconstruct_export_csv_config(_dollar_dollar) + return []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1673} } - _t1695 := _t1693(msg) - fields1273 := _t1695 - unwrapped_fields1274 := fields1273 + _t1674 := _t1672(msg) + fields1257 := _t1674 + unwrapped_fields1258 := fields1257 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1275 := unwrapped_fields1274[0].(string) - p.pretty_export_csv_path(field1275) + field1259 := unwrapped_fields1258[0].(string) + p.pretty_export_csv_path(field1259) p.newline() - field1276 := unwrapped_fields1274[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns(field1276) + field1260 := unwrapped_fields1258[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns(field1260) p.newline() - field1277 := unwrapped_fields1274[2].([][]interface{}) - p.pretty_config_dict(field1277) + field1261 := unwrapped_fields1258[2].([][]interface{}) + p.pretty_config_dict(field1261) p.dedent() p.write(")") } @@ -4404,17 +4357,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1280 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1280 != nil { - p.write(*flat1280) + flat1264 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1264 != nil { + p.write(*flat1264) return nil } else { - fields1279 := msg + fields1263 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1279)) + p.write(p.formatStringValue(fields1263)) p.dedent() p.write(")") } @@ -4422,22 +4375,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) interface{} { - flat1284 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) }) - if flat1284 != nil { - p.write(*flat1284) + flat1268 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) }) + if flat1268 != nil { + p.write(*flat1268) return nil } else { - fields1281 := msg + fields1265 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1281) == 0) { + if !(len(fields1265) == 0) { p.newline() - for i1283, elem1282 := range fields1281 { - if (i1283 > 0) { + for i1267, elem1266 := range fields1265 { + if (i1267 > 0) { p.newline() } - p.pretty_export_csv_column(elem1282) + p.pretty_export_csv_column(elem1266) } } p.dedent() @@ -4447,26 +4400,26 @@ func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) int } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1289 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1289 != nil { - p.write(*flat1289) + flat1273 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1273 != nil { + p.write(*flat1273) return nil } else { - _t1696 := func(_dollar_dollar *pb.ExportCSVColumn) []interface{} { + _t1675 := func(_dollar_dollar *pb.ExportCSVColumn) []interface{} { return []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} } - _t1697 := _t1696(msg) - fields1285 := _t1697 - unwrapped_fields1286 := fields1285 + _t1676 := _t1675(msg) + fields1269 := _t1676 + unwrapped_fields1270 := fields1269 p.write("(") p.write("column") p.indentSexp() p.newline() - field1287 := unwrapped_fields1286[0].(string) - p.write(p.formatStringValue(field1287)) + field1271 := unwrapped_fields1270[0].(string) + p.write(p.formatStringValue(field1271)) p.newline() - field1288 := unwrapped_fields1286[1].(*pb.RelationId) - p.pretty_relation_id(field1288) + field1272 := unwrapped_fields1270[1].(*pb.RelationId) + p.pretty_relation_id(field1272) p.dedent() p.write(")") } @@ -4482,8 +4435,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1736 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1736) + _t1714 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1714) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") @@ -4770,12 +4723,12 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) { p.pretty_functional_dependency_keys(m) case *pb.Data: p.pretty_data(m) - case *pb.RelEDB: - p.pretty_rel_edb(m) + case *pb.EDB: + p.pretty_edb(m) case []string: - p.pretty_rel_edb_path(m) + p.pretty_edb_path(m) case []*pb.Type: - p.pretty_rel_edb_types(m) + p.pretty_edb_types(m) case *pb.BeTreeRelation: p.pretty_betree_relation(m) case *pb.BeTreeInfo: @@ -4786,10 +4739,10 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) { p.pretty_csvlocator(m) case *pb.CSVConfig: p.pretty_csv_config(m) - case []*pb.CSVColumn: - p.pretty_csv_columns(m) - case *pb.CSVColumn: - p.pretty_csv_column(m) + case []*pb.GNFColumn: + p.pretty_gnf_columns(m) + case *pb.GNFColumn: + p.pretty_gnf_column(m) case *pb.Undefine: p.pretty_undefine(m) case *pb.Context: diff --git a/sdks/go/test/extra_print_test.go b/sdks/go/test/extra_print_test.go index c16eb560..6e09253b 100644 --- a/sdks/go/test/extra_print_test.go +++ b/sdks/go/test/extra_print_test.go @@ -234,18 +234,18 @@ func TestInstructionAssign(t *testing.T) { } } -func TestDataRelEDB(t *testing.T) { +func TestDataEDB(t *testing.T) { msg := &pb.Data{ - DataType: &pb.Data_RelEdb{ - RelEdb: &pb.RelEDB{ + DataType: &pb.Data_Edb{ + Edb: &pb.EDB{ TargetId: &pb.RelationId{IdLow: 1, IdHigh: 0}, Path: []string{"base", "rel"}, }, }, } got := lqp.MsgToStr(msg) - if len(got) < 8 || got[:8] != "(rel_edb" { - t.Errorf("Data rel_edb: got %q", got) + if len(got) < 4 || got[:4] != "(edb" { + t.Errorf("Data edb: got %q", got) } } diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl index 8f12a6ee..7fc8c0ae 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl @@ -26,8 +26,8 @@ const LQPSyntax = Union{ Export,Epoch,Read,Transaction,WhatIf,Constraint,FunctionalDependency, DateTimeValue,DateValue,DecimalValue, BeTreeInfo,BeTreeRelation, - CSVLocator,CSVConfig,CSVColumn,CSVData, - RelEDB,Data, + CSVLocator,CSVConfig,GNFColumn,CSVData, + EDB,Data, } using ProtoBuf: ProtoBuf diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 9283123f..8a6b7e44 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -487,20 +487,20 @@ function Base.isequal(a::BeTreeLocator, b::BeTreeLocator) _isequal_oneof(a.location, b.location) && isequal(a.element_count, b.element_count) && isequal(a.tree_height, b.tree_height) end -# RelEDB -Base.:(==)(a::RelEDB, b::RelEDB) = a.target_id == b.target_id && a.path == b.path && a.types == b.types -Base.hash(a::RelEDB, h::UInt) = hash(a.types, hash(a.path, hash(a.target_id, h))) -Base.isequal(a::RelEDB, b::RelEDB) = isequal(a.target_id, b.target_id) && isequal(a.path, b.path) && isequal(a.types, b.types) +# EDB +Base.:(==)(a::EDB, b::EDB) = a.target_id == b.target_id && a.path == b.path && a.types == b.types +Base.hash(a::EDB, h::UInt) = hash(a.types, hash(a.path, hash(a.target_id, h))) +Base.isequal(a::EDB, b::EDB) = isequal(a.target_id, b.target_id) && isequal(a.path, b.path) && isequal(a.types, b.types) # BeTreeInfo Base.:(==)(a::BeTreeInfo, b::BeTreeInfo) = a.key_types == b.key_types && a.value_types == b.value_types && a.storage_config == b.storage_config && a.relation_locator == b.relation_locator Base.hash(a::BeTreeInfo, h::UInt) = hash(a.relation_locator, hash(a.storage_config, hash(a.value_types, hash(a.key_types, h)))) Base.isequal(a::BeTreeInfo, b::BeTreeInfo) = isequal(a.key_types, b.key_types) && isequal(a.value_types, b.value_types) && isequal(a.storage_config, b.storage_config) && isequal(a.relation_locator, b.relation_locator) -# CSVColumn -Base.:(==)(a::CSVColumn, b::CSVColumn) = a.column_path == b.column_path && a.target_id == b.target_id && a.types == b.types -Base.hash(a::CSVColumn, h::UInt) = hash(a.types, hash(a.target_id, hash(a.column_path, h))) -Base.isequal(a::CSVColumn, b::CSVColumn) = isequal(a.column_path, b.column_path) && isequal(a.target_id, b.target_id) && isequal(a.types, b.types) +# GNFColumn +Base.:(==)(a::GNFColumn, b::GNFColumn) = a.column_path == b.column_path && a.target_id == b.target_id && a.types == b.types +Base.hash(a::GNFColumn, h::UInt) = hash(a.types, hash(a.target_id, hash(a.column_path, h))) +Base.isequal(a::GNFColumn, b::GNFColumn) = isequal(a.column_path, b.column_path) && isequal(a.target_id, b.target_id) && isequal(a.types, b.types) # BeTreeRelation Base.:(==)(a::BeTreeRelation, b::BeTreeRelation) = a.name == b.name && a.relation_info == b.relation_info diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl index b94867b5..ad67823f 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/fragments_pb.jl @@ -1,4 +1,4 @@ -# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-24T19:44:16.194 +# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-25T01:59:42.006 # original file: /Users/niko/Projects/logical-query-protocol/proto/relationalai/lqp/v1/fragments.proto (proto3 syntax) import ProtoBuf as PB 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 fecfa050..c5cf4ed4 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 @@ -1,4 +1,4 @@ -# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-24T19:44:15.762 +# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-25T01:59:41.552 # original file: /Users/niko/Projects/logical-query-protocol/proto/relationalai/lqp/v1/logic.proto (proto3 syntax) import ProtoBuf as PB @@ -8,12 +8,12 @@ using ProtoBuf.EnumX: @enumx export DateTimeType, RelationId, Var, FloatType, UInt128Type, BeTreeConfig, DateTimeValue export DateValue, OrMonoid, CSVLocator, Int128Type, DecimalType, UnspecifiedType, DateType export MissingType, MissingValue, CSVConfig, IntType, StringType, Int128Value, UInt128Value -export BooleanType, DecimalValue, BeTreeLocator, var"#Type", Value, RelEDB, MinMonoid -export SumMonoid, MaxMonoid, BeTreeInfo, Binding, CSVColumn, Attribute, Term, Monoid -export BeTreeRelation, CSVData, Cast, Pragma, Atom, RelTerm, Data, Primitive, RelAtom -export Abstraction, Algorithm, Assign, Break, Conjunction, Constraint, Def, Disjunction -export Exists, FFI, FunctionalDependency, MonoidDef, MonusDef, Not, Reduce, Script, Upsert -export Construct, Loop, Declaration, Instruction, Formula +export BooleanType, DecimalValue, BeTreeLocator, var"#Type", Value, GNFColumn, MinMonoid +export SumMonoid, MaxMonoid, BeTreeInfo, Binding, EDB, Attribute, Term, CSVData, Monoid +export BeTreeRelation, Cast, Pragma, Atom, RelTerm, Data, Primitive, RelAtom, Abstraction +export Algorithm, Assign, Break, Conjunction, Constraint, Def, Disjunction, Exists, FFI +export FunctionalDependency, MonoidDef, MonusDef, Not, Reduce, Script, Upsert, Construct +export Loop, Declaration, Instruction, Formula abstract type var"##Abstract#Abstraction" end abstract type var"##Abstract#Not" end abstract type var"##Abstract#Break" end @@ -1027,45 +1027,45 @@ function PB._encoded_size(x::Value) return encoded_size end -struct RelEDB +struct GNFColumn + column_path::Vector{String} target_id::Union{Nothing,RelationId} - path::Vector{String} types::Vector{var"#Type"} end -RelEDB(;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}()) = RelEDB(target_id, path, types) -PB.default_values(::Type{RelEDB}) = (;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}()) -PB.field_numbers(::Type{RelEDB}) = (;target_id = 1, path = 2, types = 3) +GNFColumn(;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) = GNFColumn(column_path, target_id, types) +PB.default_values(::Type{GNFColumn}) = (;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) +PB.field_numbers(::Type{GNFColumn}) = (;column_path = 1, target_id = 2, types = 3) -function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:RelEDB}) +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:GNFColumn}) + column_path = PB.BufferedVector{String}() target_id = Ref{Union{Nothing,RelationId}}(nothing) - path = PB.BufferedVector{String}() types = PB.BufferedVector{var"#Type"}() while !PB.message_done(d) field_number, wire_type = PB.decode_tag(d) if field_number == 1 - PB.decode!(d, target_id) + PB.decode!(d, column_path) elseif field_number == 2 - PB.decode!(d, path) + PB.decode!(d, target_id) elseif field_number == 3 PB.decode!(d, types) else Base.skip(d, wire_type) end end - return RelEDB(target_id[], path[], types[]) + return GNFColumn(column_path[], target_id[], types[]) end -function PB.encode(e::PB.AbstractProtoEncoder, x::RelEDB) +function PB.encode(e::PB.AbstractProtoEncoder, x::GNFColumn) initpos = position(e.io) - !isnothing(x.target_id) && PB.encode(e, 1, x.target_id) - !isempty(x.path) && PB.encode(e, 2, x.path) + !isempty(x.column_path) && PB.encode(e, 1, x.column_path) + !isnothing(x.target_id) && PB.encode(e, 2, x.target_id) !isempty(x.types) && PB.encode(e, 3, x.types) return position(e.io) - initpos end -function PB._encoded_size(x::RelEDB) +function PB._encoded_size(x::GNFColumn) encoded_size = 0 - !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 1)) - !isempty(x.path) && (encoded_size += PB._encoded_size(x.path, 2)) + !isempty(x.column_path) && (encoded_size += PB._encoded_size(x.column_path, 1)) + !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 2)) !isempty(x.types) && (encoded_size += PB._encoded_size(x.types, 3)) return encoded_size end @@ -1250,45 +1250,45 @@ function PB._encoded_size(x::Binding) return encoded_size end -struct CSVColumn - column_path::Vector{String} +struct EDB target_id::Union{Nothing,RelationId} + path::Vector{String} types::Vector{var"#Type"} end -CSVColumn(;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) = CSVColumn(column_path, target_id, types) -PB.default_values(::Type{CSVColumn}) = (;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) -PB.field_numbers(::Type{CSVColumn}) = (;column_path = 1, target_id = 2, types = 3) +EDB(;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}()) = EDB(target_id, path, types) +PB.default_values(::Type{EDB}) = (;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}()) +PB.field_numbers(::Type{EDB}) = (;target_id = 1, path = 2, types = 3) -function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVColumn}) - column_path = PB.BufferedVector{String}() +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:EDB}) target_id = Ref{Union{Nothing,RelationId}}(nothing) + path = PB.BufferedVector{String}() types = PB.BufferedVector{var"#Type"}() while !PB.message_done(d) field_number, wire_type = PB.decode_tag(d) if field_number == 1 - PB.decode!(d, column_path) - elseif field_number == 2 PB.decode!(d, target_id) + elseif field_number == 2 + PB.decode!(d, path) elseif field_number == 3 PB.decode!(d, types) else Base.skip(d, wire_type) end end - return CSVColumn(column_path[], target_id[], types[]) + return EDB(target_id[], path[], types[]) end -function PB.encode(e::PB.AbstractProtoEncoder, x::CSVColumn) +function PB.encode(e::PB.AbstractProtoEncoder, x::EDB) initpos = position(e.io) - !isempty(x.column_path) && PB.encode(e, 1, x.column_path) - !isnothing(x.target_id) && PB.encode(e, 2, x.target_id) + !isnothing(x.target_id) && PB.encode(e, 1, x.target_id) + !isempty(x.path) && PB.encode(e, 2, x.path) !isempty(x.types) && PB.encode(e, 3, x.types) return position(e.io) - initpos end -function PB._encoded_size(x::CSVColumn) +function PB._encoded_size(x::EDB) encoded_size = 0 - !isempty(x.column_path) && (encoded_size += PB._encoded_size(x.column_path, 1)) - !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 2)) + !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 1)) + !isempty(x.path) && (encoded_size += PB._encoded_size(x.path, 2)) !isempty(x.types) && (encoded_size += PB._encoded_size(x.types, 3)) return encoded_size end @@ -1376,6 +1376,55 @@ function PB._encoded_size(x::Term) return encoded_size end +struct CSVData + locator::Union{Nothing,CSVLocator} + config::Union{Nothing,CSVConfig} + columns::Vector{GNFColumn} + asof::String +end +CSVData(;locator = nothing, config = nothing, columns = Vector{GNFColumn}(), asof = "") = CSVData(locator, config, columns, asof) +PB.default_values(::Type{CSVData}) = (;locator = nothing, config = nothing, columns = Vector{GNFColumn}(), asof = "") +PB.field_numbers(::Type{CSVData}) = (;locator = 1, config = 2, columns = 3, asof = 4) + +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVData}) + locator = Ref{Union{Nothing,CSVLocator}}(nothing) + config = Ref{Union{Nothing,CSVConfig}}(nothing) + columns = PB.BufferedVector{GNFColumn}() + asof = "" + while !PB.message_done(d) + field_number, wire_type = PB.decode_tag(d) + if field_number == 1 + PB.decode!(d, locator) + elseif field_number == 2 + PB.decode!(d, config) + elseif field_number == 3 + PB.decode!(d, columns) + elseif field_number == 4 + asof = PB.decode(d, String) + else + Base.skip(d, wire_type) + end + end + return CSVData(locator[], config[], columns[], asof) +end + +function PB.encode(e::PB.AbstractProtoEncoder, x::CSVData) + initpos = position(e.io) + !isnothing(x.locator) && PB.encode(e, 1, x.locator) + !isnothing(x.config) && PB.encode(e, 2, x.config) + !isempty(x.columns) && PB.encode(e, 3, x.columns) + !isempty(x.asof) && PB.encode(e, 4, x.asof) + return position(e.io) - initpos +end +function PB._encoded_size(x::CSVData) + encoded_size = 0 + !isnothing(x.locator) && (encoded_size += PB._encoded_size(x.locator, 1)) + !isnothing(x.config) && (encoded_size += PB._encoded_size(x.config, 2)) + !isempty(x.columns) && (encoded_size += PB._encoded_size(x.columns, 3)) + !isempty(x.asof) && (encoded_size += PB._encoded_size(x.asof, 4)) + return encoded_size +end + struct Monoid value::Union{Nothing,OneOf{<:Union{OrMonoid,MinMonoid,MaxMonoid,SumMonoid}}} end @@ -1471,55 +1520,6 @@ function PB._encoded_size(x::BeTreeRelation) return encoded_size end -struct CSVData - locator::Union{Nothing,CSVLocator} - config::Union{Nothing,CSVConfig} - columns::Vector{CSVColumn} - asof::String -end -CSVData(;locator = nothing, config = nothing, columns = Vector{CSVColumn}(), asof = "") = CSVData(locator, config, columns, asof) -PB.default_values(::Type{CSVData}) = (;locator = nothing, config = nothing, columns = Vector{CSVColumn}(), asof = "") -PB.field_numbers(::Type{CSVData}) = (;locator = 1, config = 2, columns = 3, asof = 4) - -function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVData}) - locator = Ref{Union{Nothing,CSVLocator}}(nothing) - config = Ref{Union{Nothing,CSVConfig}}(nothing) - columns = PB.BufferedVector{CSVColumn}() - asof = "" - while !PB.message_done(d) - field_number, wire_type = PB.decode_tag(d) - if field_number == 1 - PB.decode!(d, locator) - elseif field_number == 2 - PB.decode!(d, config) - elseif field_number == 3 - PB.decode!(d, columns) - elseif field_number == 4 - asof = PB.decode(d, String) - else - Base.skip(d, wire_type) - end - end - return CSVData(locator[], config[], columns[], asof) -end - -function PB.encode(e::PB.AbstractProtoEncoder, x::CSVData) - initpos = position(e.io) - !isnothing(x.locator) && PB.encode(e, 1, x.locator) - !isnothing(x.config) && PB.encode(e, 2, x.config) - !isempty(x.columns) && PB.encode(e, 3, x.columns) - !isempty(x.asof) && PB.encode(e, 4, x.asof) - return position(e.io) - initpos -end -function PB._encoded_size(x::CSVData) - encoded_size = 0 - !isnothing(x.locator) && (encoded_size += PB._encoded_size(x.locator, 1)) - !isnothing(x.config) && (encoded_size += PB._encoded_size(x.config, 2)) - !isempty(x.columns) && (encoded_size += PB._encoded_size(x.columns, 3)) - !isempty(x.asof) && (encoded_size += PB._encoded_size(x.asof, 4)) - return encoded_size -end - struct Cast input::Union{Nothing,Term} result::Union{Nothing,Term} @@ -1678,21 +1678,21 @@ function PB._encoded_size(x::RelTerm) end struct Data - data_type::Union{Nothing,OneOf{<:Union{RelEDB,BeTreeRelation,CSVData}}} + data_type::Union{Nothing,OneOf{<:Union{EDB,BeTreeRelation,CSVData}}} end Data(;data_type = nothing) = Data(data_type) PB.oneof_field_types(::Type{Data}) = (; - data_type = (;rel_edb=RelEDB, betree_relation=BeTreeRelation, csv_data=CSVData), + data_type = (;edb=EDB, betree_relation=BeTreeRelation, csv_data=CSVData), ) -PB.default_values(::Type{Data}) = (;rel_edb = nothing, betree_relation = nothing, csv_data = nothing) -PB.field_numbers(::Type{Data}) = (;rel_edb = 1, betree_relation = 2, csv_data = 3) +PB.default_values(::Type{Data}) = (;edb = nothing, betree_relation = nothing, csv_data = nothing) +PB.field_numbers(::Type{Data}) = (;edb = 1, betree_relation = 2, csv_data = 3) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Data}) data_type = nothing while !PB.message_done(d) field_number, wire_type = PB.decode_tag(d) if field_number == 1 - data_type = OneOf(:rel_edb, PB.decode(d, Ref{RelEDB})) + data_type = OneOf(:edb, PB.decode(d, Ref{EDB})) elseif field_number == 2 data_type = OneOf(:betree_relation, PB.decode(d, Ref{BeTreeRelation})) elseif field_number == 3 @@ -1707,8 +1707,8 @@ end function PB.encode(e::PB.AbstractProtoEncoder, x::Data) initpos = position(e.io) if isnothing(x.data_type); - elseif x.data_type.name === :rel_edb - PB.encode(e, 1, x.data_type[]::RelEDB) + elseif x.data_type.name === :edb + PB.encode(e, 1, x.data_type[]::EDB) elseif x.data_type.name === :betree_relation PB.encode(e, 2, x.data_type[]::BeTreeRelation) elseif x.data_type.name === :csv_data @@ -1719,8 +1719,8 @@ end function PB._encoded_size(x::Data) encoded_size = 0 if isnothing(x.data_type); - elseif x.data_type.name === :rel_edb - encoded_size += PB._encoded_size(x.data_type[]::RelEDB, 1) + elseif x.data_type.name === :edb + encoded_size += PB._encoded_size(x.data_type[]::EDB, 1) elseif x.data_type.name === :betree_relation encoded_size += PB._encoded_size(x.data_type[]::BeTreeRelation, 2) elseif x.data_type.name === :csv_data diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl index 7b9af9af..9dd5b075 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl @@ -1,4 +1,4 @@ -# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-24T19:44:16.195 +# Autogenerated using ProtoBuf.jl v1.2.0 on 2026-02-25T01:59:42.006 # original file: /Users/niko/Projects/logical-query-protocol/proto/relationalai/lqp/v1/transactions.proto (proto3 syntax) import ProtoBuf as PB diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index c6a51019..22ee7471 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -305,7 +305,7 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return Int32(_get_oneof_field(value, :int_value)) else - _t1348 = nothing + _t1329 = nothing end return Int32(default) end @@ -314,7 +314,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 - _t1349 = nothing + _t1330 = nothing end return default end @@ -323,7 +323,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 - _t1350 = nothing + _t1331 = nothing end return default end @@ -332,7 +332,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 - _t1351 = nothing + _t1332 = nothing end return default end @@ -341,7 +341,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 - _t1352 = nothing + _t1333 = nothing end return default end @@ -350,7 +350,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 - _t1353 = nothing + _t1334 = nothing end return nothing end @@ -359,7 +359,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 - _t1354 = nothing + _t1335 = nothing end return nothing end @@ -368,7 +368,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 - _t1355 = nothing + _t1336 = nothing end return nothing end @@ -377,70 +377,70 @@ 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 - _t1356 = nothing + _t1337 = nothing end return nothing end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.CSVConfig config = Dict(config_dict) - _t1357 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t1357 - _t1358 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t1358 - _t1359 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t1359 - _t1360 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t1360 - _t1361 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t1361 - _t1362 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t1362 - _t1363 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t1363 - _t1364 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t1364 - _t1365 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t1365 - _t1366 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t1366 - _t1367 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") - compression = _t1367 - _t1368 = 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) - return _t1368 + _t1338 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t1338 + _t1339 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t1339 + _t1340 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t1340 + _t1341 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t1341 + _t1342 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t1342 + _t1343 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t1343 + _t1344 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t1344 + _t1345 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t1345 + _t1346 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t1346 + _t1347 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t1347 + _t1348 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") + compression = _t1348 + _t1349 = 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) + return _t1349 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) - _t1369 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t1369 - _t1370 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t1370 - _t1371 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t1371 - _t1372 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t1372 - _t1373 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t1373 - _t1374 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t1374 - _t1375 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t1375 - _t1376 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t1376 - _t1377 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t1377 - _t1378 = 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 = _t1378 - _t1379 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t1379 + _t1350 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t1350 + _t1351 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t1351 + _t1352 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t1352 + _t1353 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t1353 + _t1354 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t1354 + _t1355 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t1355 + _t1356 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t1356 + _t1357 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t1357 + _t1358 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t1358 + _t1359 = 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 = _t1359 + _t1360 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t1360 end function default_configure(parser::ParserState)::Proto.Configure - _t1380 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t1380 - _t1381 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t1381 + _t1361 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t1361 + _t1362 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t1362 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -462,44 +462,32 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t1382 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t1382 - _t1383 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t1383 - _t1384 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t1384 + _t1363 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t1363 + _t1364 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t1364 + _t1365 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t1365 end function export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t1385 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t1385 - _t1386 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t1386 - _t1387 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t1387 - _t1388 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t1388 - _t1389 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t1389 - _t1390 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t1390 - _t1391 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t1391 - _t1392 = 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 _t1392 -end - -function construct_csv_column(parser::ParserState, path::Vector{String}, tail::Union{Nothing, Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}})::Proto.CSVColumn - if !isnothing(tail) - t = tail - _t1394 = Proto.CSVColumn(column_path=path, target_id=t[1], types=t[2]) - return _t1394 - else - _t1393 = nothing - end - _t1395 = Proto.CSVColumn(column_path=path, target_id=nothing, types=Proto.var"#Type"[]) - return _t1395 + _t1366 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t1366 + _t1367 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t1367 + _t1368 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t1368 + _t1369 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t1369 + _t1370 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t1370 + _t1371 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t1371 + _t1372 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t1372 + _t1373 = 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 _t1373 end # --- Parse functions --- @@ -508,2784 +496,2741 @@ function parse_transaction(parser::ParserState)::Proto.Transaction consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t737 = parse_configure(parser) - _t736 = _t737 + _t725 = parse_configure(parser) + _t724 = _t725 else - _t736 = nothing + _t724 = nothing end - configure368 = _t736 + configure362 = _t724 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t739 = parse_sync(parser) - _t738 = _t739 + _t727 = parse_sync(parser) + _t726 = _t727 else - _t738 = nothing + _t726 = nothing end - sync369 = _t738 - xs370 = Proto.Epoch[] - cond371 = match_lookahead_literal(parser, "(", 0) - while cond371 - _t740 = parse_epoch(parser) - item372 = _t740 - push!(xs370, item372) - cond371 = match_lookahead_literal(parser, "(", 0) + sync363 = _t726 + xs364 = Proto.Epoch[] + cond365 = match_lookahead_literal(parser, "(", 0) + while cond365 + _t728 = parse_epoch(parser) + item366 = _t728 + push!(xs364, item366) + cond365 = match_lookahead_literal(parser, "(", 0) end - epochs373 = xs370 + epochs367 = xs364 consume_literal!(parser, ")") - _t741 = default_configure(parser) - _t742 = Proto.Transaction(epochs=epochs373, configure=(!isnothing(configure368) ? configure368 : _t741), sync=sync369) - return _t742 + _t729 = default_configure(parser) + _t730 = Proto.Transaction(epochs=epochs367, configure=(!isnothing(configure362) ? configure362 : _t729), sync=sync363) + return _t730 end function parse_configure(parser::ParserState)::Proto.Configure consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t743 = parse_config_dict(parser) - config_dict374 = _t743 + _t731 = parse_config_dict(parser) + config_dict368 = _t731 consume_literal!(parser, ")") - _t744 = construct_configure(parser, config_dict374) - return _t744 + _t732 = construct_configure(parser, config_dict368) + return _t732 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs375 = Tuple{String, Proto.Value}[] - cond376 = match_lookahead_literal(parser, ":", 0) - while cond376 - _t745 = parse_config_key_value(parser) - item377 = _t745 - push!(xs375, item377) - cond376 = match_lookahead_literal(parser, ":", 0) - end - config_key_values378 = xs375 + xs369 = Tuple{String, Proto.Value}[] + cond370 = match_lookahead_literal(parser, ":", 0) + while cond370 + _t733 = parse_config_key_value(parser) + item371 = _t733 + push!(xs369, item371) + cond370 = match_lookahead_literal(parser, ":", 0) + end + config_key_values372 = xs369 consume_literal!(parser, "}") - return config_key_values378 + return config_key_values372 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol379 = consume_terminal!(parser, "SYMBOL") - _t746 = parse_value(parser) - value380 = _t746 - return (symbol379, value380,) + symbol373 = consume_terminal!(parser, "SYMBOL") + _t734 = parse_value(parser) + value374 = _t734 + return (symbol373, value374,) end function parse_value(parser::ParserState)::Proto.Value if match_lookahead_literal(parser, "true", 0) - _t747 = 9 + _t735 = 9 else if match_lookahead_literal(parser, "missing", 0) - _t748 = 8 + _t736 = 8 else if match_lookahead_literal(parser, "false", 0) - _t749 = 9 + _t737 = 9 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t751 = 1 + _t739 = 1 else if match_lookahead_literal(parser, "date", 1) - _t752 = 0 + _t740 = 0 else - _t752 = -1 + _t740 = -1 end - _t751 = _t752 + _t739 = _t740 end - _t750 = _t751 + _t738 = _t739 else if match_lookahead_terminal(parser, "UINT128", 0) - _t753 = 5 + _t741 = 5 else if match_lookahead_terminal(parser, "STRING", 0) - _t754 = 2 + _t742 = 2 else if match_lookahead_terminal(parser, "INT128", 0) - _t755 = 6 + _t743 = 6 else if match_lookahead_terminal(parser, "INT", 0) - _t756 = 3 + _t744 = 3 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t757 = 4 + _t745 = 4 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t758 = 7 + _t746 = 7 else - _t758 = -1 + _t746 = -1 end - _t757 = _t758 + _t745 = _t746 end - _t756 = _t757 + _t744 = _t745 end - _t755 = _t756 + _t743 = _t744 end - _t754 = _t755 + _t742 = _t743 end - _t753 = _t754 + _t741 = _t742 end - _t750 = _t753 + _t738 = _t741 end - _t749 = _t750 + _t737 = _t738 end - _t748 = _t749 + _t736 = _t737 end - _t747 = _t748 - end - prediction381 = _t747 - if prediction381 == 9 - _t760 = parse_boolean_value(parser) - boolean_value390 = _t760 - _t761 = Proto.Value(value=OneOf(:boolean_value, boolean_value390)) - _t759 = _t761 + _t735 = _t736 + end + prediction375 = _t735 + if prediction375 == 9 + _t748 = parse_boolean_value(parser) + boolean_value384 = _t748 + _t749 = Proto.Value(value=OneOf(:boolean_value, boolean_value384)) + _t747 = _t749 else - if prediction381 == 8 + if prediction375 == 8 consume_literal!(parser, "missing") - _t763 = Proto.MissingValue() - _t764 = Proto.Value(value=OneOf(:missing_value, _t763)) - _t762 = _t764 + _t751 = Proto.MissingValue() + _t752 = Proto.Value(value=OneOf(:missing_value, _t751)) + _t750 = _t752 else - if prediction381 == 7 - decimal389 = consume_terminal!(parser, "DECIMAL") - _t766 = Proto.Value(value=OneOf(:decimal_value, decimal389)) - _t765 = _t766 + if prediction375 == 7 + decimal383 = consume_terminal!(parser, "DECIMAL") + _t754 = Proto.Value(value=OneOf(:decimal_value, decimal383)) + _t753 = _t754 else - if prediction381 == 6 - int128388 = consume_terminal!(parser, "INT128") - _t768 = Proto.Value(value=OneOf(:int128_value, int128388)) - _t767 = _t768 + if prediction375 == 6 + int128382 = consume_terminal!(parser, "INT128") + _t756 = Proto.Value(value=OneOf(:int128_value, int128382)) + _t755 = _t756 else - if prediction381 == 5 - uint128387 = consume_terminal!(parser, "UINT128") - _t770 = Proto.Value(value=OneOf(:uint128_value, uint128387)) - _t769 = _t770 + if prediction375 == 5 + uint128381 = consume_terminal!(parser, "UINT128") + _t758 = Proto.Value(value=OneOf(:uint128_value, uint128381)) + _t757 = _t758 else - if prediction381 == 4 - float386 = consume_terminal!(parser, "FLOAT") - _t772 = Proto.Value(value=OneOf(:float_value, float386)) - _t771 = _t772 + if prediction375 == 4 + float380 = consume_terminal!(parser, "FLOAT") + _t760 = Proto.Value(value=OneOf(:float_value, float380)) + _t759 = _t760 else - if prediction381 == 3 - int385 = consume_terminal!(parser, "INT") - _t774 = Proto.Value(value=OneOf(:int_value, int385)) - _t773 = _t774 + if prediction375 == 3 + int379 = consume_terminal!(parser, "INT") + _t762 = Proto.Value(value=OneOf(:int_value, int379)) + _t761 = _t762 else - if prediction381 == 2 - string384 = consume_terminal!(parser, "STRING") - _t776 = Proto.Value(value=OneOf(:string_value, string384)) - _t775 = _t776 + if prediction375 == 2 + string378 = consume_terminal!(parser, "STRING") + _t764 = Proto.Value(value=OneOf(:string_value, string378)) + _t763 = _t764 else - if prediction381 == 1 - _t778 = parse_datetime(parser) - datetime383 = _t778 - _t779 = Proto.Value(value=OneOf(:datetime_value, datetime383)) - _t777 = _t779 + if prediction375 == 1 + _t766 = parse_datetime(parser) + datetime377 = _t766 + _t767 = Proto.Value(value=OneOf(:datetime_value, datetime377)) + _t765 = _t767 else - if prediction381 == 0 - _t781 = parse_date(parser) - date382 = _t781 - _t782 = Proto.Value(value=OneOf(:date_value, date382)) - _t780 = _t782 + if prediction375 == 0 + _t769 = parse_date(parser) + date376 = _t769 + _t770 = Proto.Value(value=OneOf(:date_value, date376)) + _t768 = _t770 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t777 = _t780 + _t765 = _t768 end - _t775 = _t777 + _t763 = _t765 end - _t773 = _t775 + _t761 = _t763 end - _t771 = _t773 + _t759 = _t761 end - _t769 = _t771 + _t757 = _t759 end - _t767 = _t769 + _t755 = _t757 end - _t765 = _t767 + _t753 = _t755 end - _t762 = _t765 + _t750 = _t753 end - _t759 = _t762 + _t747 = _t750 end - return _t759 + return _t747 end function parse_date(parser::ParserState)::Proto.DateValue consume_literal!(parser, "(") consume_literal!(parser, "date") - int391 = consume_terminal!(parser, "INT") - int_3392 = consume_terminal!(parser, "INT") - int_4393 = consume_terminal!(parser, "INT") + int385 = consume_terminal!(parser, "INT") + int_3386 = consume_terminal!(parser, "INT") + int_4387 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t783 = Proto.DateValue(year=Int32(int391), month=Int32(int_3392), day=Int32(int_4393)) - return _t783 + _t771 = Proto.DateValue(year=Int32(int385), month=Int32(int_3386), day=Int32(int_4387)) + return _t771 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int394 = consume_terminal!(parser, "INT") - int_3395 = consume_terminal!(parser, "INT") - int_4396 = consume_terminal!(parser, "INT") - int_5397 = consume_terminal!(parser, "INT") - int_6398 = consume_terminal!(parser, "INT") - int_7399 = consume_terminal!(parser, "INT") + int388 = consume_terminal!(parser, "INT") + int_3389 = consume_terminal!(parser, "INT") + int_4390 = consume_terminal!(parser, "INT") + int_5391 = consume_terminal!(parser, "INT") + int_6392 = consume_terminal!(parser, "INT") + int_7393 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t784 = consume_terminal!(parser, "INT") + _t772 = consume_terminal!(parser, "INT") else - _t784 = nothing + _t772 = nothing end - int_8400 = _t784 + int_8394 = _t772 consume_literal!(parser, ")") - _t785 = Proto.DateTimeValue(year=Int32(int394), month=Int32(int_3395), day=Int32(int_4396), hour=Int32(int_5397), minute=Int32(int_6398), second=Int32(int_7399), microsecond=Int32((!isnothing(int_8400) ? int_8400 : 0))) - return _t785 + _t773 = Proto.DateTimeValue(year=Int32(int388), month=Int32(int_3389), day=Int32(int_4390), hour=Int32(int_5391), minute=Int32(int_6392), second=Int32(int_7393), microsecond=Int32((!isnothing(int_8394) ? int_8394 : 0))) + return _t773 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t786 = 0 + _t774 = 0 else if match_lookahead_literal(parser, "false", 0) - _t787 = 1 + _t775 = 1 else - _t787 = -1 + _t775 = -1 end - _t786 = _t787 + _t774 = _t775 end - prediction401 = _t786 - if prediction401 == 1 + prediction395 = _t774 + if prediction395 == 1 consume_literal!(parser, "false") - _t788 = false + _t776 = false else - if prediction401 == 0 + if prediction395 == 0 consume_literal!(parser, "true") - _t789 = true + _t777 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t788 = _t789 + _t776 = _t777 end - return _t788 + return _t776 end function parse_sync(parser::ParserState)::Proto.Sync consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs402 = Proto.FragmentId[] - cond403 = match_lookahead_literal(parser, ":", 0) - while cond403 - _t790 = parse_fragment_id(parser) - item404 = _t790 - push!(xs402, item404) - cond403 = match_lookahead_literal(parser, ":", 0) + xs396 = Proto.FragmentId[] + cond397 = match_lookahead_literal(parser, ":", 0) + while cond397 + _t778 = parse_fragment_id(parser) + item398 = _t778 + push!(xs396, item398) + cond397 = match_lookahead_literal(parser, ":", 0) end - fragment_ids405 = xs402 + fragment_ids399 = xs396 consume_literal!(parser, ")") - _t791 = Proto.Sync(fragments=fragment_ids405) - return _t791 + _t779 = Proto.Sync(fragments=fragment_ids399) + return _t779 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId consume_literal!(parser, ":") - symbol406 = consume_terminal!(parser, "SYMBOL") - return Proto.FragmentId(Vector{UInt8}(symbol406)) + symbol400 = consume_terminal!(parser, "SYMBOL") + return Proto.FragmentId(Vector{UInt8}(symbol400)) end function parse_epoch(parser::ParserState)::Proto.Epoch consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t793 = parse_epoch_writes(parser) - _t792 = _t793 + _t781 = parse_epoch_writes(parser) + _t780 = _t781 else - _t792 = nothing + _t780 = nothing end - epoch_writes407 = _t792 + epoch_writes401 = _t780 if match_lookahead_literal(parser, "(", 0) - _t795 = parse_epoch_reads(parser) - _t794 = _t795 + _t783 = parse_epoch_reads(parser) + _t782 = _t783 else - _t794 = nothing + _t782 = nothing end - epoch_reads408 = _t794 + epoch_reads402 = _t782 consume_literal!(parser, ")") - _t796 = Proto.Epoch(writes=(!isnothing(epoch_writes407) ? epoch_writes407 : Proto.Write[]), reads=(!isnothing(epoch_reads408) ? epoch_reads408 : Proto.Read[])) - return _t796 + _t784 = Proto.Epoch(writes=(!isnothing(epoch_writes401) ? epoch_writes401 : Proto.Write[]), reads=(!isnothing(epoch_reads402) ? epoch_reads402 : Proto.Read[])) + return _t784 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs409 = Proto.Write[] - cond410 = match_lookahead_literal(parser, "(", 0) - while cond410 - _t797 = parse_write(parser) - item411 = _t797 - push!(xs409, item411) - cond410 = match_lookahead_literal(parser, "(", 0) + xs403 = Proto.Write[] + cond404 = match_lookahead_literal(parser, "(", 0) + while cond404 + _t785 = parse_write(parser) + item405 = _t785 + push!(xs403, item405) + cond404 = match_lookahead_literal(parser, "(", 0) end - writes412 = xs409 + writes406 = xs403 consume_literal!(parser, ")") - return writes412 + return writes406 end function parse_write(parser::ParserState)::Proto.Write if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t799 = 1 + _t787 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t800 = 3 + _t788 = 3 else if match_lookahead_literal(parser, "define", 1) - _t801 = 0 + _t789 = 0 else if match_lookahead_literal(parser, "context", 1) - _t802 = 2 + _t790 = 2 else - _t802 = -1 + _t790 = -1 end - _t801 = _t802 + _t789 = _t790 end - _t800 = _t801 + _t788 = _t789 end - _t799 = _t800 + _t787 = _t788 end - _t798 = _t799 + _t786 = _t787 else - _t798 = -1 - end - prediction413 = _t798 - if prediction413 == 3 - _t804 = parse_snapshot(parser) - snapshot417 = _t804 - _t805 = Proto.Write(write_type=OneOf(:snapshot, snapshot417)) - _t803 = _t805 + _t786 = -1 + end + prediction407 = _t786 + if prediction407 == 3 + _t792 = parse_snapshot(parser) + snapshot411 = _t792 + _t793 = Proto.Write(write_type=OneOf(:snapshot, snapshot411)) + _t791 = _t793 else - if prediction413 == 2 - _t807 = parse_context(parser) - context416 = _t807 - _t808 = Proto.Write(write_type=OneOf(:context, context416)) - _t806 = _t808 + if prediction407 == 2 + _t795 = parse_context(parser) + context410 = _t795 + _t796 = Proto.Write(write_type=OneOf(:context, context410)) + _t794 = _t796 else - if prediction413 == 1 - _t810 = parse_undefine(parser) - undefine415 = _t810 - _t811 = Proto.Write(write_type=OneOf(:undefine, undefine415)) - _t809 = _t811 + if prediction407 == 1 + _t798 = parse_undefine(parser) + undefine409 = _t798 + _t799 = Proto.Write(write_type=OneOf(:undefine, undefine409)) + _t797 = _t799 else - if prediction413 == 0 - _t813 = parse_define(parser) - define414 = _t813 - _t814 = Proto.Write(write_type=OneOf(:define, define414)) - _t812 = _t814 + if prediction407 == 0 + _t801 = parse_define(parser) + define408 = _t801 + _t802 = Proto.Write(write_type=OneOf(:define, define408)) + _t800 = _t802 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t809 = _t812 + _t797 = _t800 end - _t806 = _t809 + _t794 = _t797 end - _t803 = _t806 + _t791 = _t794 end - return _t803 + return _t791 end function parse_define(parser::ParserState)::Proto.Define consume_literal!(parser, "(") consume_literal!(parser, "define") - _t815 = parse_fragment(parser) - fragment418 = _t815 + _t803 = parse_fragment(parser) + fragment412 = _t803 consume_literal!(parser, ")") - _t816 = Proto.Define(fragment=fragment418) - return _t816 + _t804 = Proto.Define(fragment=fragment412) + return _t804 end function parse_fragment(parser::ParserState)::Proto.Fragment consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t817 = parse_new_fragment_id(parser) - new_fragment_id419 = _t817 - xs420 = Proto.Declaration[] - cond421 = match_lookahead_literal(parser, "(", 0) - while cond421 - _t818 = parse_declaration(parser) - item422 = _t818 - push!(xs420, item422) - cond421 = match_lookahead_literal(parser, "(", 0) + _t805 = parse_new_fragment_id(parser) + new_fragment_id413 = _t805 + xs414 = Proto.Declaration[] + cond415 = match_lookahead_literal(parser, "(", 0) + while cond415 + _t806 = parse_declaration(parser) + item416 = _t806 + push!(xs414, item416) + cond415 = match_lookahead_literal(parser, "(", 0) end - declarations423 = xs420 + declarations417 = xs414 consume_literal!(parser, ")") - return construct_fragment(parser, new_fragment_id419, declarations423) + return construct_fragment(parser, new_fragment_id413, declarations417) end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - _t819 = parse_fragment_id(parser) - fragment_id424 = _t819 - start_fragment!(parser, fragment_id424) - return fragment_id424 + _t807 = parse_fragment_id(parser) + fragment_id418 = _t807 + start_fragment!(parser, fragment_id418) + return fragment_id418 end function parse_declaration(parser::ParserState)::Proto.Declaration if match_lookahead_literal(parser, "(", 0) - if match_lookahead_literal(parser, "rel_edb", 1) - _t821 = 3 + if match_lookahead_literal(parser, "functional_dependency", 1) + _t809 = 2 else - if match_lookahead_literal(parser, "functional_dependency", 1) - _t822 = 2 + if match_lookahead_literal(parser, "edb", 1) + _t810 = 3 else if match_lookahead_literal(parser, "def", 1) - _t823 = 0 + _t811 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t824 = 3 + _t812 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t825 = 3 + _t813 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t826 = 1 + _t814 = 1 else - _t826 = -1 + _t814 = -1 end - _t825 = _t826 + _t813 = _t814 end - _t824 = _t825 + _t812 = _t813 end - _t823 = _t824 + _t811 = _t812 end - _t822 = _t823 + _t810 = _t811 end - _t821 = _t822 + _t809 = _t810 end - _t820 = _t821 + _t808 = _t809 else - _t820 = -1 - end - prediction425 = _t820 - if prediction425 == 3 - _t828 = parse_data(parser) - data429 = _t828 - _t829 = Proto.Declaration(declaration_type=OneOf(:data, data429)) - _t827 = _t829 + _t808 = -1 + end + prediction419 = _t808 + if prediction419 == 3 + _t816 = parse_data(parser) + data423 = _t816 + _t817 = Proto.Declaration(declaration_type=OneOf(:data, data423)) + _t815 = _t817 else - if prediction425 == 2 - _t831 = parse_constraint(parser) - constraint428 = _t831 - _t832 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint428)) - _t830 = _t832 + if prediction419 == 2 + _t819 = parse_constraint(parser) + constraint422 = _t819 + _t820 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint422)) + _t818 = _t820 else - if prediction425 == 1 - _t834 = parse_algorithm(parser) - algorithm427 = _t834 - _t835 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm427)) - _t833 = _t835 + if prediction419 == 1 + _t822 = parse_algorithm(parser) + algorithm421 = _t822 + _t823 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm421)) + _t821 = _t823 else - if prediction425 == 0 - _t837 = parse_def(parser) - def426 = _t837 - _t838 = Proto.Declaration(declaration_type=OneOf(:def, def426)) - _t836 = _t838 + if prediction419 == 0 + _t825 = parse_def(parser) + def420 = _t825 + _t826 = Proto.Declaration(declaration_type=OneOf(:def, def420)) + _t824 = _t826 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t833 = _t836 + _t821 = _t824 end - _t830 = _t833 + _t818 = _t821 end - _t827 = _t830 + _t815 = _t818 end - return _t827 + return _t815 end function parse_def(parser::ParserState)::Proto.Def consume_literal!(parser, "(") consume_literal!(parser, "def") - _t839 = parse_relation_id(parser) - relation_id430 = _t839 - _t840 = parse_abstraction(parser) - abstraction431 = _t840 + _t827 = parse_relation_id(parser) + relation_id424 = _t827 + _t828 = parse_abstraction(parser) + abstraction425 = _t828 if match_lookahead_literal(parser, "(", 0) - _t842 = parse_attrs(parser) - _t841 = _t842 + _t830 = parse_attrs(parser) + _t829 = _t830 else - _t841 = nothing + _t829 = nothing end - attrs432 = _t841 + attrs426 = _t829 consume_literal!(parser, ")") - _t843 = Proto.Def(name=relation_id430, body=abstraction431, attrs=(!isnothing(attrs432) ? attrs432 : Proto.Attribute[])) - return _t843 + _t831 = Proto.Def(name=relation_id424, body=abstraction425, attrs=(!isnothing(attrs426) ? attrs426 : Proto.Attribute[])) + return _t831 end function parse_relation_id(parser::ParserState)::Proto.RelationId if match_lookahead_literal(parser, ":", 0) - _t844 = 0 + _t832 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t845 = 1 + _t833 = 1 else - _t845 = -1 + _t833 = -1 end - _t844 = _t845 + _t832 = _t833 end - prediction433 = _t844 - if prediction433 == 1 - uint128435 = consume_terminal!(parser, "UINT128") - _t846 = Proto.RelationId(uint128435.low, uint128435.high) + prediction427 = _t832 + if prediction427 == 1 + uint128429 = consume_terminal!(parser, "UINT128") + _t834 = Proto.RelationId(uint128429.low, uint128429.high) else - if prediction433 == 0 + if prediction427 == 0 consume_literal!(parser, ":") - symbol434 = consume_terminal!(parser, "SYMBOL") - _t847 = relation_id_from_string(parser, symbol434) + symbol428 = consume_terminal!(parser, "SYMBOL") + _t835 = relation_id_from_string(parser, symbol428) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t846 = _t847 + _t834 = _t835 end - return _t846 + return _t834 end function parse_abstraction(parser::ParserState)::Proto.Abstraction consume_literal!(parser, "(") - _t848 = parse_bindings(parser) - bindings436 = _t848 - _t849 = parse_formula(parser) - formula437 = _t849 + _t836 = parse_bindings(parser) + bindings430 = _t836 + _t837 = parse_formula(parser) + formula431 = _t837 consume_literal!(parser, ")") - _t850 = Proto.Abstraction(vars=vcat(bindings436[1], !isnothing(bindings436[2]) ? bindings436[2] : []), value=formula437) - return _t850 + _t838 = Proto.Abstraction(vars=vcat(bindings430[1], !isnothing(bindings430[2]) ? bindings430[2] : []), value=formula431) + return _t838 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs438 = Proto.Binding[] - cond439 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond439 - _t851 = parse_binding(parser) - item440 = _t851 - push!(xs438, item440) - cond439 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings441 = xs438 + xs432 = Proto.Binding[] + cond433 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond433 + _t839 = parse_binding(parser) + item434 = _t839 + push!(xs432, item434) + cond433 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings435 = xs432 if match_lookahead_literal(parser, "|", 0) - _t853 = parse_value_bindings(parser) - _t852 = _t853 + _t841 = parse_value_bindings(parser) + _t840 = _t841 else - _t852 = nothing + _t840 = nothing end - value_bindings442 = _t852 + value_bindings436 = _t840 consume_literal!(parser, "]") - return (bindings441, (!isnothing(value_bindings442) ? value_bindings442 : Proto.Binding[]),) + return (bindings435, (!isnothing(value_bindings436) ? value_bindings436 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - symbol443 = consume_terminal!(parser, "SYMBOL") + symbol437 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t854 = parse_type(parser) - type444 = _t854 - _t855 = Proto.Var(name=symbol443) - _t856 = Proto.Binding(var=_t855, var"#type"=type444) - return _t856 + _t842 = parse_type(parser) + type438 = _t842 + _t843 = Proto.Var(name=symbol437) + _t844 = Proto.Binding(var=_t843, var"#type"=type438) + return _t844 end function parse_type(parser::ParserState)::Proto.var"#Type" if match_lookahead_literal(parser, "UNKNOWN", 0) - _t857 = 0 + _t845 = 0 else if match_lookahead_literal(parser, "UINT128", 0) - _t858 = 4 + _t846 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t859 = 1 + _t847 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t860 = 8 + _t848 = 8 else if match_lookahead_literal(parser, "INT128", 0) - _t861 = 5 + _t849 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t862 = 2 + _t850 = 2 else if match_lookahead_literal(parser, "FLOAT", 0) - _t863 = 3 + _t851 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t864 = 7 + _t852 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t865 = 6 + _t853 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t866 = 10 + _t854 = 10 else if match_lookahead_literal(parser, "(", 0) - _t867 = 9 + _t855 = 9 else - _t867 = -1 + _t855 = -1 end - _t866 = _t867 + _t854 = _t855 end - _t865 = _t866 + _t853 = _t854 end - _t864 = _t865 + _t852 = _t853 end - _t863 = _t864 + _t851 = _t852 end - _t862 = _t863 + _t850 = _t851 end - _t861 = _t862 + _t849 = _t850 end - _t860 = _t861 + _t848 = _t849 end - _t859 = _t860 + _t847 = _t848 end - _t858 = _t859 + _t846 = _t847 end - _t857 = _t858 - end - prediction445 = _t857 - if prediction445 == 10 - _t869 = parse_boolean_type(parser) - boolean_type456 = _t869 - _t870 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type456)) - _t868 = _t870 + _t845 = _t846 + end + prediction439 = _t845 + if prediction439 == 10 + _t857 = parse_boolean_type(parser) + boolean_type450 = _t857 + _t858 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type450)) + _t856 = _t858 else - if prediction445 == 9 - _t872 = parse_decimal_type(parser) - decimal_type455 = _t872 - _t873 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type455)) - _t871 = _t873 + if prediction439 == 9 + _t860 = parse_decimal_type(parser) + decimal_type449 = _t860 + _t861 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type449)) + _t859 = _t861 else - if prediction445 == 8 - _t875 = parse_missing_type(parser) - missing_type454 = _t875 - _t876 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type454)) - _t874 = _t876 + if prediction439 == 8 + _t863 = parse_missing_type(parser) + missing_type448 = _t863 + _t864 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type448)) + _t862 = _t864 else - if prediction445 == 7 - _t878 = parse_datetime_type(parser) - datetime_type453 = _t878 - _t879 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type453)) - _t877 = _t879 + if prediction439 == 7 + _t866 = parse_datetime_type(parser) + datetime_type447 = _t866 + _t867 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type447)) + _t865 = _t867 else - if prediction445 == 6 - _t881 = parse_date_type(parser) - date_type452 = _t881 - _t882 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type452)) - _t880 = _t882 + if prediction439 == 6 + _t869 = parse_date_type(parser) + date_type446 = _t869 + _t870 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type446)) + _t868 = _t870 else - if prediction445 == 5 - _t884 = parse_int128_type(parser) - int128_type451 = _t884 - _t885 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type451)) - _t883 = _t885 + if prediction439 == 5 + _t872 = parse_int128_type(parser) + int128_type445 = _t872 + _t873 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type445)) + _t871 = _t873 else - if prediction445 == 4 - _t887 = parse_uint128_type(parser) - uint128_type450 = _t887 - _t888 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type450)) - _t886 = _t888 + if prediction439 == 4 + _t875 = parse_uint128_type(parser) + uint128_type444 = _t875 + _t876 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type444)) + _t874 = _t876 else - if prediction445 == 3 - _t890 = parse_float_type(parser) - float_type449 = _t890 - _t891 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type449)) - _t889 = _t891 + if prediction439 == 3 + _t878 = parse_float_type(parser) + float_type443 = _t878 + _t879 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type443)) + _t877 = _t879 else - if prediction445 == 2 - _t893 = parse_int_type(parser) - int_type448 = _t893 - _t894 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type448)) - _t892 = _t894 + if prediction439 == 2 + _t881 = parse_int_type(parser) + int_type442 = _t881 + _t882 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type442)) + _t880 = _t882 else - if prediction445 == 1 - _t896 = parse_string_type(parser) - string_type447 = _t896 - _t897 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type447)) - _t895 = _t897 + if prediction439 == 1 + _t884 = parse_string_type(parser) + string_type441 = _t884 + _t885 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type441)) + _t883 = _t885 else - if prediction445 == 0 - _t899 = parse_unspecified_type(parser) - unspecified_type446 = _t899 - _t900 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type446)) - _t898 = _t900 + if prediction439 == 0 + _t887 = parse_unspecified_type(parser) + unspecified_type440 = _t887 + _t888 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type440)) + _t886 = _t888 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t895 = _t898 + _t883 = _t886 end - _t892 = _t895 + _t880 = _t883 end - _t889 = _t892 + _t877 = _t880 end - _t886 = _t889 + _t874 = _t877 end - _t883 = _t886 + _t871 = _t874 end - _t880 = _t883 + _t868 = _t871 end - _t877 = _t880 + _t865 = _t868 end - _t874 = _t877 + _t862 = _t865 end - _t871 = _t874 + _t859 = _t862 end - _t868 = _t871 + _t856 = _t859 end - return _t868 + return _t856 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType consume_literal!(parser, "UNKNOWN") - _t901 = Proto.UnspecifiedType() - return _t901 + _t889 = Proto.UnspecifiedType() + return _t889 end function parse_string_type(parser::ParserState)::Proto.StringType consume_literal!(parser, "STRING") - _t902 = Proto.StringType() - return _t902 + _t890 = Proto.StringType() + return _t890 end function parse_int_type(parser::ParserState)::Proto.IntType consume_literal!(parser, "INT") - _t903 = Proto.IntType() - return _t903 + _t891 = Proto.IntType() + return _t891 end function parse_float_type(parser::ParserState)::Proto.FloatType consume_literal!(parser, "FLOAT") - _t904 = Proto.FloatType() - return _t904 + _t892 = Proto.FloatType() + return _t892 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type consume_literal!(parser, "UINT128") - _t905 = Proto.UInt128Type() - return _t905 + _t893 = Proto.UInt128Type() + return _t893 end function parse_int128_type(parser::ParserState)::Proto.Int128Type consume_literal!(parser, "INT128") - _t906 = Proto.Int128Type() - return _t906 + _t894 = Proto.Int128Type() + return _t894 end function parse_date_type(parser::ParserState)::Proto.DateType consume_literal!(parser, "DATE") - _t907 = Proto.DateType() - return _t907 + _t895 = Proto.DateType() + return _t895 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType consume_literal!(parser, "DATETIME") - _t908 = Proto.DateTimeType() - return _t908 + _t896 = Proto.DateTimeType() + return _t896 end function parse_missing_type(parser::ParserState)::Proto.MissingType consume_literal!(parser, "MISSING") - _t909 = Proto.MissingType() - return _t909 + _t897 = Proto.MissingType() + return _t897 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int457 = consume_terminal!(parser, "INT") - int_3458 = consume_terminal!(parser, "INT") + int451 = consume_terminal!(parser, "INT") + int_3452 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t910 = Proto.DecimalType(precision=Int32(int457), scale=Int32(int_3458)) - return _t910 + _t898 = Proto.DecimalType(precision=Int32(int451), scale=Int32(int_3452)) + return _t898 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType consume_literal!(parser, "BOOLEAN") - _t911 = Proto.BooleanType() - return _t911 + _t899 = Proto.BooleanType() + return _t899 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs459 = Proto.Binding[] - cond460 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond460 - _t912 = parse_binding(parser) - item461 = _t912 - push!(xs459, item461) - cond460 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs453 = Proto.Binding[] + cond454 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond454 + _t900 = parse_binding(parser) + item455 = _t900 + push!(xs453, item455) + cond454 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings462 = xs459 - return bindings462 + bindings456 = xs453 + return bindings456 end function parse_formula(parser::ParserState)::Proto.Formula if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t914 = 0 + _t902 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t915 = 11 + _t903 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t916 = 3 + _t904 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t917 = 10 + _t905 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t918 = 9 + _t906 = 9 else if match_lookahead_literal(parser, "or", 1) - _t919 = 5 + _t907 = 5 else if match_lookahead_literal(parser, "not", 1) - _t920 = 6 + _t908 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t921 = 7 + _t909 = 7 else if match_lookahead_literal(parser, "false", 1) - _t922 = 1 + _t910 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t923 = 2 + _t911 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t924 = 12 + _t912 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t925 = 8 + _t913 = 8 else if match_lookahead_literal(parser, "and", 1) - _t926 = 4 + _t914 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t927 = 10 + _t915 = 10 else if match_lookahead_literal(parser, ">", 1) - _t928 = 10 + _t916 = 10 else if match_lookahead_literal(parser, "=", 1) - _t929 = 10 + _t917 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t930 = 10 + _t918 = 10 else if match_lookahead_literal(parser, "<", 1) - _t931 = 10 + _t919 = 10 else if match_lookahead_literal(parser, "/", 1) - _t932 = 10 + _t920 = 10 else if match_lookahead_literal(parser, "-", 1) - _t933 = 10 + _t921 = 10 else if match_lookahead_literal(parser, "+", 1) - _t934 = 10 + _t922 = 10 else if match_lookahead_literal(parser, "*", 1) - _t935 = 10 + _t923 = 10 else - _t935 = -1 + _t923 = -1 end - _t934 = _t935 + _t922 = _t923 end - _t933 = _t934 + _t921 = _t922 end - _t932 = _t933 + _t920 = _t921 end - _t931 = _t932 + _t919 = _t920 end - _t930 = _t931 + _t918 = _t919 end - _t929 = _t930 + _t917 = _t918 end - _t928 = _t929 + _t916 = _t917 end - _t927 = _t928 + _t915 = _t916 end - _t926 = _t927 + _t914 = _t915 end - _t925 = _t926 + _t913 = _t914 end - _t924 = _t925 + _t912 = _t913 end - _t923 = _t924 + _t911 = _t912 end - _t922 = _t923 + _t910 = _t911 end - _t921 = _t922 + _t909 = _t910 end - _t920 = _t921 + _t908 = _t909 end - _t919 = _t920 + _t907 = _t908 end - _t918 = _t919 + _t906 = _t907 end - _t917 = _t918 + _t905 = _t906 end - _t916 = _t917 + _t904 = _t905 end - _t915 = _t916 + _t903 = _t904 end - _t914 = _t915 + _t902 = _t903 end - _t913 = _t914 + _t901 = _t902 else - _t913 = -1 - end - prediction463 = _t913 - if prediction463 == 12 - _t937 = parse_cast(parser) - cast476 = _t937 - _t938 = Proto.Formula(formula_type=OneOf(:cast, cast476)) - _t936 = _t938 + _t901 = -1 + end + prediction457 = _t901 + if prediction457 == 12 + _t925 = parse_cast(parser) + cast470 = _t925 + _t926 = Proto.Formula(formula_type=OneOf(:cast, cast470)) + _t924 = _t926 else - if prediction463 == 11 - _t940 = parse_rel_atom(parser) - rel_atom475 = _t940 - _t941 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom475)) - _t939 = _t941 + if prediction457 == 11 + _t928 = parse_rel_atom(parser) + rel_atom469 = _t928 + _t929 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom469)) + _t927 = _t929 else - if prediction463 == 10 - _t943 = parse_primitive(parser) - primitive474 = _t943 - _t944 = Proto.Formula(formula_type=OneOf(:primitive, primitive474)) - _t942 = _t944 + if prediction457 == 10 + _t931 = parse_primitive(parser) + primitive468 = _t931 + _t932 = Proto.Formula(formula_type=OneOf(:primitive, primitive468)) + _t930 = _t932 else - if prediction463 == 9 - _t946 = parse_pragma(parser) - pragma473 = _t946 - _t947 = Proto.Formula(formula_type=OneOf(:pragma, pragma473)) - _t945 = _t947 + if prediction457 == 9 + _t934 = parse_pragma(parser) + pragma467 = _t934 + _t935 = Proto.Formula(formula_type=OneOf(:pragma, pragma467)) + _t933 = _t935 else - if prediction463 == 8 - _t949 = parse_atom(parser) - atom472 = _t949 - _t950 = Proto.Formula(formula_type=OneOf(:atom, atom472)) - _t948 = _t950 + if prediction457 == 8 + _t937 = parse_atom(parser) + atom466 = _t937 + _t938 = Proto.Formula(formula_type=OneOf(:atom, atom466)) + _t936 = _t938 else - if prediction463 == 7 - _t952 = parse_ffi(parser) - ffi471 = _t952 - _t953 = Proto.Formula(formula_type=OneOf(:ffi, ffi471)) - _t951 = _t953 + if prediction457 == 7 + _t940 = parse_ffi(parser) + ffi465 = _t940 + _t941 = Proto.Formula(formula_type=OneOf(:ffi, ffi465)) + _t939 = _t941 else - if prediction463 == 6 - _t955 = parse_not(parser) - not470 = _t955 - _t956 = Proto.Formula(formula_type=OneOf(:not, not470)) - _t954 = _t956 + if prediction457 == 6 + _t943 = parse_not(parser) + not464 = _t943 + _t944 = Proto.Formula(formula_type=OneOf(:not, not464)) + _t942 = _t944 else - if prediction463 == 5 - _t958 = parse_disjunction(parser) - disjunction469 = _t958 - _t959 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction469)) - _t957 = _t959 + if prediction457 == 5 + _t946 = parse_disjunction(parser) + disjunction463 = _t946 + _t947 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction463)) + _t945 = _t947 else - if prediction463 == 4 - _t961 = parse_conjunction(parser) - conjunction468 = _t961 - _t962 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction468)) - _t960 = _t962 + if prediction457 == 4 + _t949 = parse_conjunction(parser) + conjunction462 = _t949 + _t950 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction462)) + _t948 = _t950 else - if prediction463 == 3 - _t964 = parse_reduce(parser) - reduce467 = _t964 - _t965 = Proto.Formula(formula_type=OneOf(:reduce, reduce467)) - _t963 = _t965 + if prediction457 == 3 + _t952 = parse_reduce(parser) + reduce461 = _t952 + _t953 = Proto.Formula(formula_type=OneOf(:reduce, reduce461)) + _t951 = _t953 else - if prediction463 == 2 - _t967 = parse_exists(parser) - exists466 = _t967 - _t968 = Proto.Formula(formula_type=OneOf(:exists, exists466)) - _t966 = _t968 + if prediction457 == 2 + _t955 = parse_exists(parser) + exists460 = _t955 + _t956 = Proto.Formula(formula_type=OneOf(:exists, exists460)) + _t954 = _t956 else - if prediction463 == 1 - _t970 = parse_false(parser) - false465 = _t970 - _t971 = Proto.Formula(formula_type=OneOf(:disjunction, false465)) - _t969 = _t971 + if prediction457 == 1 + _t958 = parse_false(parser) + false459 = _t958 + _t959 = Proto.Formula(formula_type=OneOf(:disjunction, false459)) + _t957 = _t959 else - if prediction463 == 0 - _t973 = parse_true(parser) - true464 = _t973 - _t974 = Proto.Formula(formula_type=OneOf(:conjunction, true464)) - _t972 = _t974 + if prediction457 == 0 + _t961 = parse_true(parser) + true458 = _t961 + _t962 = Proto.Formula(formula_type=OneOf(:conjunction, true458)) + _t960 = _t962 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t969 = _t972 + _t957 = _t960 end - _t966 = _t969 + _t954 = _t957 end - _t963 = _t966 + _t951 = _t954 end - _t960 = _t963 + _t948 = _t951 end - _t957 = _t960 + _t945 = _t948 end - _t954 = _t957 + _t942 = _t945 end - _t951 = _t954 + _t939 = _t942 end - _t948 = _t951 + _t936 = _t939 end - _t945 = _t948 + _t933 = _t936 end - _t942 = _t945 + _t930 = _t933 end - _t939 = _t942 + _t927 = _t930 end - _t936 = _t939 + _t924 = _t927 end - return _t936 + return _t924 end function parse_true(parser::ParserState)::Proto.Conjunction consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t975 = Proto.Conjunction(args=Proto.Formula[]) - return _t975 + _t963 = Proto.Conjunction(args=Proto.Formula[]) + return _t963 end function parse_false(parser::ParserState)::Proto.Disjunction consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t976 = Proto.Disjunction(args=Proto.Formula[]) - return _t976 + _t964 = Proto.Disjunction(args=Proto.Formula[]) + return _t964 end function parse_exists(parser::ParserState)::Proto.Exists consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t977 = parse_bindings(parser) - bindings477 = _t977 - _t978 = parse_formula(parser) - formula478 = _t978 + _t965 = parse_bindings(parser) + bindings471 = _t965 + _t966 = parse_formula(parser) + formula472 = _t966 consume_literal!(parser, ")") - _t979 = Proto.Abstraction(vars=vcat(bindings477[1], !isnothing(bindings477[2]) ? bindings477[2] : []), value=formula478) - _t980 = Proto.Exists(body=_t979) - return _t980 + _t967 = Proto.Abstraction(vars=vcat(bindings471[1], !isnothing(bindings471[2]) ? bindings471[2] : []), value=formula472) + _t968 = Proto.Exists(body=_t967) + return _t968 end function parse_reduce(parser::ParserState)::Proto.Reduce consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t981 = parse_abstraction(parser) - abstraction479 = _t981 - _t982 = parse_abstraction(parser) - abstraction_3480 = _t982 - _t983 = parse_terms(parser) - terms481 = _t983 + _t969 = parse_abstraction(parser) + abstraction473 = _t969 + _t970 = parse_abstraction(parser) + abstraction_3474 = _t970 + _t971 = parse_terms(parser) + terms475 = _t971 consume_literal!(parser, ")") - _t984 = Proto.Reduce(op=abstraction479, body=abstraction_3480, terms=terms481) - return _t984 + _t972 = Proto.Reduce(op=abstraction473, body=abstraction_3474, terms=terms475) + return _t972 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs482 = Proto.Term[] - cond483 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond483 - _t985 = parse_term(parser) - item484 = _t985 - push!(xs482, item484) - cond483 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + xs476 = Proto.Term[] + cond477 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond477 + _t973 = parse_term(parser) + item478 = _t973 + push!(xs476, item478) + cond477 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - terms485 = xs482 + terms479 = xs476 consume_literal!(parser, ")") - return terms485 + return terms479 end function parse_term(parser::ParserState)::Proto.Term if match_lookahead_literal(parser, "true", 0) - _t986 = 1 + _t974 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t987 = 1 + _t975 = 1 else if match_lookahead_literal(parser, "false", 0) - _t988 = 1 + _t976 = 1 else if match_lookahead_literal(parser, "(", 0) - _t989 = 1 + _t977 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t990 = 1 + _t978 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t991 = 0 + _t979 = 0 else if match_lookahead_terminal(parser, "STRING", 0) - _t992 = 1 + _t980 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t993 = 1 + _t981 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t994 = 1 + _t982 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t995 = 1 + _t983 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t996 = 1 + _t984 = 1 else - _t996 = -1 + _t984 = -1 end - _t995 = _t996 + _t983 = _t984 end - _t994 = _t995 + _t982 = _t983 end - _t993 = _t994 + _t981 = _t982 end - _t992 = _t993 + _t980 = _t981 end - _t991 = _t992 + _t979 = _t980 end - _t990 = _t991 + _t978 = _t979 end - _t989 = _t990 + _t977 = _t978 end - _t988 = _t989 + _t976 = _t977 end - _t987 = _t988 + _t975 = _t976 end - _t986 = _t987 - end - prediction486 = _t986 - if prediction486 == 1 - _t998 = parse_constant(parser) - constant488 = _t998 - _t999 = Proto.Term(term_type=OneOf(:constant, constant488)) - _t997 = _t999 + _t974 = _t975 + end + prediction480 = _t974 + if prediction480 == 1 + _t986 = parse_constant(parser) + constant482 = _t986 + _t987 = Proto.Term(term_type=OneOf(:constant, constant482)) + _t985 = _t987 else - if prediction486 == 0 - _t1001 = parse_var(parser) - var487 = _t1001 - _t1002 = Proto.Term(term_type=OneOf(:var, var487)) - _t1000 = _t1002 + if prediction480 == 0 + _t989 = parse_var(parser) + var481 = _t989 + _t990 = Proto.Term(term_type=OneOf(:var, var481)) + _t988 = _t990 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t997 = _t1000 + _t985 = _t988 end - return _t997 + return _t985 end function parse_var(parser::ParserState)::Proto.Var - symbol489 = consume_terminal!(parser, "SYMBOL") - _t1003 = Proto.Var(name=symbol489) - return _t1003 + symbol483 = consume_terminal!(parser, "SYMBOL") + _t991 = Proto.Var(name=symbol483) + return _t991 end function parse_constant(parser::ParserState)::Proto.Value - _t1004 = parse_value(parser) - value490 = _t1004 - return value490 + _t992 = parse_value(parser) + value484 = _t992 + return value484 end function parse_conjunction(parser::ParserState)::Proto.Conjunction consume_literal!(parser, "(") consume_literal!(parser, "and") - xs491 = Proto.Formula[] - cond492 = match_lookahead_literal(parser, "(", 0) - while cond492 - _t1005 = parse_formula(parser) - item493 = _t1005 - push!(xs491, item493) - cond492 = match_lookahead_literal(parser, "(", 0) + xs485 = Proto.Formula[] + cond486 = match_lookahead_literal(parser, "(", 0) + while cond486 + _t993 = parse_formula(parser) + item487 = _t993 + push!(xs485, item487) + cond486 = match_lookahead_literal(parser, "(", 0) end - formulas494 = xs491 + formulas488 = xs485 consume_literal!(parser, ")") - _t1006 = Proto.Conjunction(args=formulas494) - return _t1006 + _t994 = Proto.Conjunction(args=formulas488) + return _t994 end function parse_disjunction(parser::ParserState)::Proto.Disjunction consume_literal!(parser, "(") consume_literal!(parser, "or") - xs495 = Proto.Formula[] - cond496 = match_lookahead_literal(parser, "(", 0) - while cond496 - _t1007 = parse_formula(parser) - item497 = _t1007 - push!(xs495, item497) - cond496 = match_lookahead_literal(parser, "(", 0) + xs489 = Proto.Formula[] + cond490 = match_lookahead_literal(parser, "(", 0) + while cond490 + _t995 = parse_formula(parser) + item491 = _t995 + push!(xs489, item491) + cond490 = match_lookahead_literal(parser, "(", 0) end - formulas498 = xs495 + formulas492 = xs489 consume_literal!(parser, ")") - _t1008 = Proto.Disjunction(args=formulas498) - return _t1008 + _t996 = Proto.Disjunction(args=formulas492) + return _t996 end function parse_not(parser::ParserState)::Proto.Not consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1009 = parse_formula(parser) - formula499 = _t1009 + _t997 = parse_formula(parser) + formula493 = _t997 consume_literal!(parser, ")") - _t1010 = Proto.Not(arg=formula499) - return _t1010 + _t998 = Proto.Not(arg=formula493) + return _t998 end function parse_ffi(parser::ParserState)::Proto.FFI consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1011 = parse_name(parser) - name500 = _t1011 - _t1012 = parse_ffi_args(parser) - ffi_args501 = _t1012 - _t1013 = parse_terms(parser) - terms502 = _t1013 + _t999 = parse_name(parser) + name494 = _t999 + _t1000 = parse_ffi_args(parser) + ffi_args495 = _t1000 + _t1001 = parse_terms(parser) + terms496 = _t1001 consume_literal!(parser, ")") - _t1014 = Proto.FFI(name=name500, args=ffi_args501, terms=terms502) - return _t1014 + _t1002 = Proto.FFI(name=name494, args=ffi_args495, terms=terms496) + return _t1002 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol503 = consume_terminal!(parser, "SYMBOL") - return symbol503 + symbol497 = consume_terminal!(parser, "SYMBOL") + return symbol497 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs504 = Proto.Abstraction[] - cond505 = match_lookahead_literal(parser, "(", 0) - while cond505 - _t1015 = parse_abstraction(parser) - item506 = _t1015 - push!(xs504, item506) - cond505 = match_lookahead_literal(parser, "(", 0) + xs498 = Proto.Abstraction[] + cond499 = match_lookahead_literal(parser, "(", 0) + while cond499 + _t1003 = parse_abstraction(parser) + item500 = _t1003 + push!(xs498, item500) + cond499 = match_lookahead_literal(parser, "(", 0) end - abstractions507 = xs504 + abstractions501 = xs498 consume_literal!(parser, ")") - return abstractions507 + return abstractions501 end function parse_atom(parser::ParserState)::Proto.Atom consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1016 = parse_relation_id(parser) - relation_id508 = _t1016 - xs509 = Proto.Term[] - cond510 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond510 - _t1017 = parse_term(parser) - item511 = _t1017 - push!(xs509, item511) - cond510 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - end - terms512 = xs509 - consume_literal!(parser, ")") - _t1018 = Proto.Atom(name=relation_id508, terms=terms512) - return _t1018 + _t1004 = parse_relation_id(parser) + relation_id502 = _t1004 + xs503 = Proto.Term[] + cond504 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond504 + _t1005 = parse_term(parser) + item505 = _t1005 + push!(xs503, item505) + cond504 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + end + terms506 = xs503 + consume_literal!(parser, ")") + _t1006 = Proto.Atom(name=relation_id502, terms=terms506) + return _t1006 end function parse_pragma(parser::ParserState)::Proto.Pragma consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1019 = parse_name(parser) - name513 = _t1019 - xs514 = Proto.Term[] - cond515 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond515 - _t1020 = parse_term(parser) - item516 = _t1020 - push!(xs514, item516) - cond515 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - end - terms517 = xs514 - consume_literal!(parser, ")") - _t1021 = Proto.Pragma(name=name513, terms=terms517) - return _t1021 + _t1007 = parse_name(parser) + name507 = _t1007 + xs508 = Proto.Term[] + cond509 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond509 + _t1008 = parse_term(parser) + item510 = _t1008 + push!(xs508, item510) + cond509 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + end + terms511 = xs508 + consume_literal!(parser, ")") + _t1009 = Proto.Pragma(name=name507, terms=terms511) + return _t1009 end function parse_primitive(parser::ParserState)::Proto.Primitive if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1023 = 9 + _t1011 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1024 = 4 + _t1012 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1025 = 3 + _t1013 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1026 = 0 + _t1014 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1027 = 2 + _t1015 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1028 = 1 + _t1016 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1029 = 8 + _t1017 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1030 = 6 + _t1018 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1031 = 5 + _t1019 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1032 = 7 + _t1020 = 7 else - _t1032 = -1 + _t1020 = -1 end - _t1031 = _t1032 + _t1019 = _t1020 end - _t1030 = _t1031 + _t1018 = _t1019 end - _t1029 = _t1030 + _t1017 = _t1018 end - _t1028 = _t1029 + _t1016 = _t1017 end - _t1027 = _t1028 + _t1015 = _t1016 end - _t1026 = _t1027 + _t1014 = _t1015 end - _t1025 = _t1026 + _t1013 = _t1014 end - _t1024 = _t1025 + _t1012 = _t1013 end - _t1023 = _t1024 + _t1011 = _t1012 end - _t1022 = _t1023 + _t1010 = _t1011 else - _t1022 = -1 + _t1010 = -1 end - prediction518 = _t1022 - if prediction518 == 9 + prediction512 = _t1010 + if prediction512 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1034 = parse_name(parser) - name528 = _t1034 - xs529 = Proto.RelTerm[] - cond530 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond530 - _t1035 = parse_rel_term(parser) - item531 = _t1035 - push!(xs529, item531) - cond530 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1022 = parse_name(parser) + name522 = _t1022 + xs523 = Proto.RelTerm[] + cond524 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond524 + _t1023 = parse_rel_term(parser) + item525 = _t1023 + push!(xs523, item525) + cond524 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - rel_terms532 = xs529 + rel_terms526 = xs523 consume_literal!(parser, ")") - _t1036 = Proto.Primitive(name=name528, terms=rel_terms532) - _t1033 = _t1036 + _t1024 = Proto.Primitive(name=name522, terms=rel_terms526) + _t1021 = _t1024 else - if prediction518 == 8 - _t1038 = parse_divide(parser) - divide527 = _t1038 - _t1037 = divide527 + if prediction512 == 8 + _t1026 = parse_divide(parser) + divide521 = _t1026 + _t1025 = divide521 else - if prediction518 == 7 - _t1040 = parse_multiply(parser) - multiply526 = _t1040 - _t1039 = multiply526 + if prediction512 == 7 + _t1028 = parse_multiply(parser) + multiply520 = _t1028 + _t1027 = multiply520 else - if prediction518 == 6 - _t1042 = parse_minus(parser) - minus525 = _t1042 - _t1041 = minus525 + if prediction512 == 6 + _t1030 = parse_minus(parser) + minus519 = _t1030 + _t1029 = minus519 else - if prediction518 == 5 - _t1044 = parse_add(parser) - add524 = _t1044 - _t1043 = add524 + if prediction512 == 5 + _t1032 = parse_add(parser) + add518 = _t1032 + _t1031 = add518 else - if prediction518 == 4 - _t1046 = parse_gt_eq(parser) - gt_eq523 = _t1046 - _t1045 = gt_eq523 + if prediction512 == 4 + _t1034 = parse_gt_eq(parser) + gt_eq517 = _t1034 + _t1033 = gt_eq517 else - if prediction518 == 3 - _t1048 = parse_gt(parser) - gt522 = _t1048 - _t1047 = gt522 + if prediction512 == 3 + _t1036 = parse_gt(parser) + gt516 = _t1036 + _t1035 = gt516 else - if prediction518 == 2 - _t1050 = parse_lt_eq(parser) - lt_eq521 = _t1050 - _t1049 = lt_eq521 + if prediction512 == 2 + _t1038 = parse_lt_eq(parser) + lt_eq515 = _t1038 + _t1037 = lt_eq515 else - if prediction518 == 1 - _t1052 = parse_lt(parser) - lt520 = _t1052 - _t1051 = lt520 + if prediction512 == 1 + _t1040 = parse_lt(parser) + lt514 = _t1040 + _t1039 = lt514 else - if prediction518 == 0 - _t1054 = parse_eq(parser) - eq519 = _t1054 - _t1053 = eq519 + if prediction512 == 0 + _t1042 = parse_eq(parser) + eq513 = _t1042 + _t1041 = eq513 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1051 = _t1053 + _t1039 = _t1041 end - _t1049 = _t1051 + _t1037 = _t1039 end - _t1047 = _t1049 + _t1035 = _t1037 end - _t1045 = _t1047 + _t1033 = _t1035 end - _t1043 = _t1045 + _t1031 = _t1033 end - _t1041 = _t1043 + _t1029 = _t1031 end - _t1039 = _t1041 + _t1027 = _t1029 end - _t1037 = _t1039 + _t1025 = _t1027 end - _t1033 = _t1037 + _t1021 = _t1025 end - return _t1033 + return _t1021 end function parse_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1055 = parse_term(parser) - term533 = _t1055 - _t1056 = parse_term(parser) - term_3534 = _t1056 + _t1043 = parse_term(parser) + term527 = _t1043 + _t1044 = parse_term(parser) + term_3528 = _t1044 consume_literal!(parser, ")") - _t1057 = Proto.RelTerm(rel_term_type=OneOf(:term, term533)) - _t1058 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3534)) - _t1059 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1057, _t1058]) - return _t1059 + _t1045 = Proto.RelTerm(rel_term_type=OneOf(:term, term527)) + _t1046 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3528)) + _t1047 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1045, _t1046]) + return _t1047 end function parse_lt(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1060 = parse_term(parser) - term535 = _t1060 - _t1061 = parse_term(parser) - term_3536 = _t1061 + _t1048 = parse_term(parser) + term529 = _t1048 + _t1049 = parse_term(parser) + term_3530 = _t1049 consume_literal!(parser, ")") - _t1062 = Proto.RelTerm(rel_term_type=OneOf(:term, term535)) - _t1063 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3536)) - _t1064 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1062, _t1063]) - return _t1064 + _t1050 = Proto.RelTerm(rel_term_type=OneOf(:term, term529)) + _t1051 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3530)) + _t1052 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1050, _t1051]) + return _t1052 end function parse_lt_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1065 = parse_term(parser) - term537 = _t1065 - _t1066 = parse_term(parser) - term_3538 = _t1066 + _t1053 = parse_term(parser) + term531 = _t1053 + _t1054 = parse_term(parser) + term_3532 = _t1054 consume_literal!(parser, ")") - _t1067 = Proto.RelTerm(rel_term_type=OneOf(:term, term537)) - _t1068 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538)) - _t1069 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1067, _t1068]) - return _t1069 + _t1055 = Proto.RelTerm(rel_term_type=OneOf(:term, term531)) + _t1056 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3532)) + _t1057 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1055, _t1056]) + return _t1057 end function parse_gt(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1070 = parse_term(parser) - term539 = _t1070 - _t1071 = parse_term(parser) - term_3540 = _t1071 + _t1058 = parse_term(parser) + term533 = _t1058 + _t1059 = parse_term(parser) + term_3534 = _t1059 consume_literal!(parser, ")") - _t1072 = Proto.RelTerm(rel_term_type=OneOf(:term, term539)) - _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3540)) - _t1074 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1072, _t1073]) - return _t1074 + _t1060 = Proto.RelTerm(rel_term_type=OneOf(:term, term533)) + _t1061 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3534)) + _t1062 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1060, _t1061]) + return _t1062 end function parse_gt_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1075 = parse_term(parser) - term541 = _t1075 - _t1076 = parse_term(parser) - term_3542 = _t1076 + _t1063 = parse_term(parser) + term535 = _t1063 + _t1064 = parse_term(parser) + term_3536 = _t1064 consume_literal!(parser, ")") - _t1077 = Proto.RelTerm(rel_term_type=OneOf(:term, term541)) - _t1078 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3542)) - _t1079 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1077, _t1078]) - return _t1079 + _t1065 = Proto.RelTerm(rel_term_type=OneOf(:term, term535)) + _t1066 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3536)) + _t1067 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1065, _t1066]) + return _t1067 end function parse_add(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1080 = parse_term(parser) - term543 = _t1080 - _t1081 = parse_term(parser) - term_3544 = _t1081 - _t1082 = parse_term(parser) - term_4545 = _t1082 + _t1068 = parse_term(parser) + term537 = _t1068 + _t1069 = parse_term(parser) + term_3538 = _t1069 + _t1070 = parse_term(parser) + term_4539 = _t1070 consume_literal!(parser, ")") - _t1083 = Proto.RelTerm(rel_term_type=OneOf(:term, term543)) - _t1084 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3544)) - _t1085 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4545)) - _t1086 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1083, _t1084, _t1085]) - return _t1086 + _t1071 = Proto.RelTerm(rel_term_type=OneOf(:term, term537)) + _t1072 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538)) + _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4539)) + _t1074 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1071, _t1072, _t1073]) + return _t1074 end function parse_minus(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1087 = parse_term(parser) - term546 = _t1087 - _t1088 = parse_term(parser) - term_3547 = _t1088 - _t1089 = parse_term(parser) - term_4548 = _t1089 + _t1075 = parse_term(parser) + term540 = _t1075 + _t1076 = parse_term(parser) + term_3541 = _t1076 + _t1077 = parse_term(parser) + term_4542 = _t1077 consume_literal!(parser, ")") - _t1090 = Proto.RelTerm(rel_term_type=OneOf(:term, term546)) - _t1091 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3547)) - _t1092 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4548)) - _t1093 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1090, _t1091, _t1092]) - return _t1093 + _t1078 = Proto.RelTerm(rel_term_type=OneOf(:term, term540)) + _t1079 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3541)) + _t1080 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4542)) + _t1081 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1078, _t1079, _t1080]) + return _t1081 end function parse_multiply(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1094 = parse_term(parser) - term549 = _t1094 - _t1095 = parse_term(parser) - term_3550 = _t1095 - _t1096 = parse_term(parser) - term_4551 = _t1096 + _t1082 = parse_term(parser) + term543 = _t1082 + _t1083 = parse_term(parser) + term_3544 = _t1083 + _t1084 = parse_term(parser) + term_4545 = _t1084 consume_literal!(parser, ")") - _t1097 = Proto.RelTerm(rel_term_type=OneOf(:term, term549)) - _t1098 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3550)) - _t1099 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4551)) - _t1100 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1097, _t1098, _t1099]) - return _t1100 + _t1085 = Proto.RelTerm(rel_term_type=OneOf(:term, term543)) + _t1086 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3544)) + _t1087 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4545)) + _t1088 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1085, _t1086, _t1087]) + return _t1088 end function parse_divide(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1101 = parse_term(parser) - term552 = _t1101 - _t1102 = parse_term(parser) - term_3553 = _t1102 - _t1103 = parse_term(parser) - term_4554 = _t1103 + _t1089 = parse_term(parser) + term546 = _t1089 + _t1090 = parse_term(parser) + term_3547 = _t1090 + _t1091 = parse_term(parser) + term_4548 = _t1091 consume_literal!(parser, ")") - _t1104 = Proto.RelTerm(rel_term_type=OneOf(:term, term552)) - _t1105 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3553)) - _t1106 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4554)) - _t1107 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1104, _t1105, _t1106]) - return _t1107 + _t1092 = Proto.RelTerm(rel_term_type=OneOf(:term, term546)) + _t1093 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3547)) + _t1094 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4548)) + _t1095 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1092, _t1093, _t1094]) + return _t1095 end function parse_rel_term(parser::ParserState)::Proto.RelTerm if match_lookahead_literal(parser, "true", 0) - _t1108 = 1 + _t1096 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1109 = 1 + _t1097 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1110 = 1 + _t1098 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1111 = 1 + _t1099 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1112 = 0 + _t1100 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1113 = 1 + _t1101 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1114 = 1 + _t1102 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1115 = 1 + _t1103 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1116 = 1 + _t1104 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1117 = 1 + _t1105 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1118 = 1 + _t1106 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1119 = 1 + _t1107 = 1 else - _t1119 = -1 + _t1107 = -1 end - _t1118 = _t1119 + _t1106 = _t1107 end - _t1117 = _t1118 + _t1105 = _t1106 end - _t1116 = _t1117 + _t1104 = _t1105 end - _t1115 = _t1116 + _t1103 = _t1104 end - _t1114 = _t1115 + _t1102 = _t1103 end - _t1113 = _t1114 + _t1101 = _t1102 end - _t1112 = _t1113 + _t1100 = _t1101 end - _t1111 = _t1112 + _t1099 = _t1100 end - _t1110 = _t1111 + _t1098 = _t1099 end - _t1109 = _t1110 + _t1097 = _t1098 end - _t1108 = _t1109 - end - prediction555 = _t1108 - if prediction555 == 1 - _t1121 = parse_term(parser) - term557 = _t1121 - _t1122 = Proto.RelTerm(rel_term_type=OneOf(:term, term557)) - _t1120 = _t1122 + _t1096 = _t1097 + end + prediction549 = _t1096 + if prediction549 == 1 + _t1109 = parse_term(parser) + term551 = _t1109 + _t1110 = Proto.RelTerm(rel_term_type=OneOf(:term, term551)) + _t1108 = _t1110 else - if prediction555 == 0 - _t1124 = parse_specialized_value(parser) - specialized_value556 = _t1124 - _t1125 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value556)) - _t1123 = _t1125 + if prediction549 == 0 + _t1112 = parse_specialized_value(parser) + specialized_value550 = _t1112 + _t1113 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value550)) + _t1111 = _t1113 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1120 = _t1123 + _t1108 = _t1111 end - return _t1120 + return _t1108 end function parse_specialized_value(parser::ParserState)::Proto.Value consume_literal!(parser, "#") - _t1126 = parse_value(parser) - value558 = _t1126 - return value558 + _t1114 = parse_value(parser) + value552 = _t1114 + return value552 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1127 = parse_name(parser) - name559 = _t1127 - xs560 = Proto.RelTerm[] - cond561 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond561 - _t1128 = parse_rel_term(parser) - item562 = _t1128 - push!(xs560, item562) - cond561 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1115 = parse_name(parser) + name553 = _t1115 + xs554 = Proto.RelTerm[] + cond555 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond555 + _t1116 = parse_rel_term(parser) + item556 = _t1116 + push!(xs554, item556) + cond555 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - rel_terms563 = xs560 + rel_terms557 = xs554 consume_literal!(parser, ")") - _t1129 = Proto.RelAtom(name=name559, terms=rel_terms563) - return _t1129 + _t1117 = Proto.RelAtom(name=name553, terms=rel_terms557) + return _t1117 end function parse_cast(parser::ParserState)::Proto.Cast consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1130 = parse_term(parser) - term564 = _t1130 - _t1131 = parse_term(parser) - term_3565 = _t1131 + _t1118 = parse_term(parser) + term558 = _t1118 + _t1119 = parse_term(parser) + term_3559 = _t1119 consume_literal!(parser, ")") - _t1132 = Proto.Cast(input=term564, result=term_3565) - return _t1132 + _t1120 = Proto.Cast(input=term558, result=term_3559) + return _t1120 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs566 = Proto.Attribute[] - cond567 = match_lookahead_literal(parser, "(", 0) - while cond567 - _t1133 = parse_attribute(parser) - item568 = _t1133 - push!(xs566, item568) - cond567 = match_lookahead_literal(parser, "(", 0) + xs560 = Proto.Attribute[] + cond561 = match_lookahead_literal(parser, "(", 0) + while cond561 + _t1121 = parse_attribute(parser) + item562 = _t1121 + push!(xs560, item562) + cond561 = match_lookahead_literal(parser, "(", 0) end - attributes569 = xs566 + attributes563 = xs560 consume_literal!(parser, ")") - return attributes569 + return attributes563 end function parse_attribute(parser::ParserState)::Proto.Attribute consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1134 = parse_name(parser) - name570 = _t1134 - xs571 = Proto.Value[] - cond572 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond572 - _t1135 = parse_value(parser) - item573 = _t1135 - push!(xs571, item573) - cond572 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1122 = parse_name(parser) + name564 = _t1122 + xs565 = Proto.Value[] + cond566 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond566 + _t1123 = parse_value(parser) + item567 = _t1123 + push!(xs565, item567) + cond566 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - values574 = xs571 + values568 = xs565 consume_literal!(parser, ")") - _t1136 = Proto.Attribute(name=name570, args=values574) - return _t1136 + _t1124 = Proto.Attribute(name=name564, args=values568) + return _t1124 end function parse_algorithm(parser::ParserState)::Proto.Algorithm consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs575 = Proto.RelationId[] - cond576 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond576 - _t1137 = parse_relation_id(parser) - item577 = _t1137 - push!(xs575, item577) - cond576 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs569 = Proto.RelationId[] + cond570 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond570 + _t1125 = parse_relation_id(parser) + item571 = _t1125 + push!(xs569, item571) + cond570 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids578 = xs575 - _t1138 = parse_script(parser) - script579 = _t1138 + relation_ids572 = xs569 + _t1126 = parse_script(parser) + script573 = _t1126 consume_literal!(parser, ")") - _t1139 = Proto.Algorithm(var"#global"=relation_ids578, body=script579) - return _t1139 + _t1127 = Proto.Algorithm(var"#global"=relation_ids572, body=script573) + return _t1127 end function parse_script(parser::ParserState)::Proto.Script consume_literal!(parser, "(") consume_literal!(parser, "script") - xs580 = Proto.Construct[] - cond581 = match_lookahead_literal(parser, "(", 0) - while cond581 - _t1140 = parse_construct(parser) - item582 = _t1140 - push!(xs580, item582) - cond581 = match_lookahead_literal(parser, "(", 0) + xs574 = Proto.Construct[] + cond575 = match_lookahead_literal(parser, "(", 0) + while cond575 + _t1128 = parse_construct(parser) + item576 = _t1128 + push!(xs574, item576) + cond575 = match_lookahead_literal(parser, "(", 0) end - constructs583 = xs580 + constructs577 = xs574 consume_literal!(parser, ")") - _t1141 = Proto.Script(constructs=constructs583) - return _t1141 + _t1129 = Proto.Script(constructs=constructs577) + return _t1129 end function parse_construct(parser::ParserState)::Proto.Construct if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1143 = 1 + _t1131 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1144 = 1 + _t1132 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1145 = 1 + _t1133 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1146 = 0 + _t1134 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1147 = 1 + _t1135 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1148 = 1 + _t1136 = 1 else - _t1148 = -1 + _t1136 = -1 end - _t1147 = _t1148 + _t1135 = _t1136 end - _t1146 = _t1147 + _t1134 = _t1135 end - _t1145 = _t1146 + _t1133 = _t1134 end - _t1144 = _t1145 + _t1132 = _t1133 end - _t1143 = _t1144 + _t1131 = _t1132 end - _t1142 = _t1143 + _t1130 = _t1131 else - _t1142 = -1 - end - prediction584 = _t1142 - if prediction584 == 1 - _t1150 = parse_instruction(parser) - instruction586 = _t1150 - _t1151 = Proto.Construct(construct_type=OneOf(:instruction, instruction586)) - _t1149 = _t1151 + _t1130 = -1 + end + prediction578 = _t1130 + if prediction578 == 1 + _t1138 = parse_instruction(parser) + instruction580 = _t1138 + _t1139 = Proto.Construct(construct_type=OneOf(:instruction, instruction580)) + _t1137 = _t1139 else - if prediction584 == 0 - _t1153 = parse_loop(parser) - loop585 = _t1153 - _t1154 = Proto.Construct(construct_type=OneOf(:loop, loop585)) - _t1152 = _t1154 + if prediction578 == 0 + _t1141 = parse_loop(parser) + loop579 = _t1141 + _t1142 = Proto.Construct(construct_type=OneOf(:loop, loop579)) + _t1140 = _t1142 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1149 = _t1152 + _t1137 = _t1140 end - return _t1149 + return _t1137 end function parse_loop(parser::ParserState)::Proto.Loop consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1155 = parse_init(parser) - init587 = _t1155 - _t1156 = parse_script(parser) - script588 = _t1156 + _t1143 = parse_init(parser) + init581 = _t1143 + _t1144 = parse_script(parser) + script582 = _t1144 consume_literal!(parser, ")") - _t1157 = Proto.Loop(init=init587, body=script588) - return _t1157 + _t1145 = Proto.Loop(init=init581, body=script582) + return _t1145 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs589 = Proto.Instruction[] - cond590 = match_lookahead_literal(parser, "(", 0) - while cond590 - _t1158 = parse_instruction(parser) - item591 = _t1158 - push!(xs589, item591) - cond590 = match_lookahead_literal(parser, "(", 0) + xs583 = Proto.Instruction[] + cond584 = match_lookahead_literal(parser, "(", 0) + while cond584 + _t1146 = parse_instruction(parser) + item585 = _t1146 + push!(xs583, item585) + cond584 = match_lookahead_literal(parser, "(", 0) end - instructions592 = xs589 + instructions586 = xs583 consume_literal!(parser, ")") - return instructions592 + return instructions586 end function parse_instruction(parser::ParserState)::Proto.Instruction if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1160 = 1 + _t1148 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1161 = 4 + _t1149 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1162 = 3 + _t1150 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1163 = 2 + _t1151 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1164 = 0 + _t1152 = 0 else - _t1164 = -1 + _t1152 = -1 end - _t1163 = _t1164 + _t1151 = _t1152 end - _t1162 = _t1163 + _t1150 = _t1151 end - _t1161 = _t1162 + _t1149 = _t1150 end - _t1160 = _t1161 + _t1148 = _t1149 end - _t1159 = _t1160 + _t1147 = _t1148 else - _t1159 = -1 - end - prediction593 = _t1159 - if prediction593 == 4 - _t1166 = parse_monus_def(parser) - monus_def598 = _t1166 - _t1167 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def598)) - _t1165 = _t1167 + _t1147 = -1 + end + prediction587 = _t1147 + if prediction587 == 4 + _t1154 = parse_monus_def(parser) + monus_def592 = _t1154 + _t1155 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def592)) + _t1153 = _t1155 else - if prediction593 == 3 - _t1169 = parse_monoid_def(parser) - monoid_def597 = _t1169 - _t1170 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def597)) - _t1168 = _t1170 + if prediction587 == 3 + _t1157 = parse_monoid_def(parser) + monoid_def591 = _t1157 + _t1158 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def591)) + _t1156 = _t1158 else - if prediction593 == 2 - _t1172 = parse_break(parser) - break596 = _t1172 - _t1173 = Proto.Instruction(instr_type=OneOf(:var"#break", break596)) - _t1171 = _t1173 + if prediction587 == 2 + _t1160 = parse_break(parser) + break590 = _t1160 + _t1161 = Proto.Instruction(instr_type=OneOf(:var"#break", break590)) + _t1159 = _t1161 else - if prediction593 == 1 - _t1175 = parse_upsert(parser) - upsert595 = _t1175 - _t1176 = Proto.Instruction(instr_type=OneOf(:upsert, upsert595)) - _t1174 = _t1176 + if prediction587 == 1 + _t1163 = parse_upsert(parser) + upsert589 = _t1163 + _t1164 = Proto.Instruction(instr_type=OneOf(:upsert, upsert589)) + _t1162 = _t1164 else - if prediction593 == 0 - _t1178 = parse_assign(parser) - assign594 = _t1178 - _t1179 = Proto.Instruction(instr_type=OneOf(:assign, assign594)) - _t1177 = _t1179 + if prediction587 == 0 + _t1166 = parse_assign(parser) + assign588 = _t1166 + _t1167 = Proto.Instruction(instr_type=OneOf(:assign, assign588)) + _t1165 = _t1167 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1174 = _t1177 + _t1162 = _t1165 end - _t1171 = _t1174 + _t1159 = _t1162 end - _t1168 = _t1171 + _t1156 = _t1159 end - _t1165 = _t1168 + _t1153 = _t1156 end - return _t1165 + return _t1153 end function parse_assign(parser::ParserState)::Proto.Assign consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1180 = parse_relation_id(parser) - relation_id599 = _t1180 - _t1181 = parse_abstraction(parser) - abstraction600 = _t1181 + _t1168 = parse_relation_id(parser) + relation_id593 = _t1168 + _t1169 = parse_abstraction(parser) + abstraction594 = _t1169 if match_lookahead_literal(parser, "(", 0) - _t1183 = parse_attrs(parser) - _t1182 = _t1183 + _t1171 = parse_attrs(parser) + _t1170 = _t1171 else - _t1182 = nothing + _t1170 = nothing end - attrs601 = _t1182 + attrs595 = _t1170 consume_literal!(parser, ")") - _t1184 = Proto.Assign(name=relation_id599, body=abstraction600, attrs=(!isnothing(attrs601) ? attrs601 : Proto.Attribute[])) - return _t1184 + _t1172 = Proto.Assign(name=relation_id593, body=abstraction594, attrs=(!isnothing(attrs595) ? attrs595 : Proto.Attribute[])) + return _t1172 end function parse_upsert(parser::ParserState)::Proto.Upsert consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1185 = parse_relation_id(parser) - relation_id602 = _t1185 - _t1186 = parse_abstraction_with_arity(parser) - abstraction_with_arity603 = _t1186 + _t1173 = parse_relation_id(parser) + relation_id596 = _t1173 + _t1174 = parse_abstraction_with_arity(parser) + abstraction_with_arity597 = _t1174 if match_lookahead_literal(parser, "(", 0) - _t1188 = parse_attrs(parser) - _t1187 = _t1188 + _t1176 = parse_attrs(parser) + _t1175 = _t1176 else - _t1187 = nothing + _t1175 = nothing end - attrs604 = _t1187 + attrs598 = _t1175 consume_literal!(parser, ")") - _t1189 = Proto.Upsert(name=relation_id602, body=abstraction_with_arity603[1], attrs=(!isnothing(attrs604) ? attrs604 : Proto.Attribute[]), value_arity=abstraction_with_arity603[2]) - return _t1189 + _t1177 = Proto.Upsert(name=relation_id596, body=abstraction_with_arity597[1], attrs=(!isnothing(attrs598) ? attrs598 : Proto.Attribute[]), value_arity=abstraction_with_arity597[2]) + return _t1177 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1190 = parse_bindings(parser) - bindings605 = _t1190 - _t1191 = parse_formula(parser) - formula606 = _t1191 + _t1178 = parse_bindings(parser) + bindings599 = _t1178 + _t1179 = parse_formula(parser) + formula600 = _t1179 consume_literal!(parser, ")") - _t1192 = Proto.Abstraction(vars=vcat(bindings605[1], !isnothing(bindings605[2]) ? bindings605[2] : []), value=formula606) - return (_t1192, length(bindings605[2]),) + _t1180 = Proto.Abstraction(vars=vcat(bindings599[1], !isnothing(bindings599[2]) ? bindings599[2] : []), value=formula600) + return (_t1180, length(bindings599[2]),) end function parse_break(parser::ParserState)::Proto.Break consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1193 = parse_relation_id(parser) - relation_id607 = _t1193 - _t1194 = parse_abstraction(parser) - abstraction608 = _t1194 + _t1181 = parse_relation_id(parser) + relation_id601 = _t1181 + _t1182 = parse_abstraction(parser) + abstraction602 = _t1182 if match_lookahead_literal(parser, "(", 0) - _t1196 = parse_attrs(parser) - _t1195 = _t1196 + _t1184 = parse_attrs(parser) + _t1183 = _t1184 else - _t1195 = nothing + _t1183 = nothing end - attrs609 = _t1195 + attrs603 = _t1183 consume_literal!(parser, ")") - _t1197 = Proto.Break(name=relation_id607, body=abstraction608, attrs=(!isnothing(attrs609) ? attrs609 : Proto.Attribute[])) - return _t1197 + _t1185 = Proto.Break(name=relation_id601, body=abstraction602, attrs=(!isnothing(attrs603) ? attrs603 : Proto.Attribute[])) + return _t1185 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1198 = parse_monoid(parser) - monoid610 = _t1198 - _t1199 = parse_relation_id(parser) - relation_id611 = _t1199 - _t1200 = parse_abstraction_with_arity(parser) - abstraction_with_arity612 = _t1200 + _t1186 = parse_monoid(parser) + monoid604 = _t1186 + _t1187 = parse_relation_id(parser) + relation_id605 = _t1187 + _t1188 = parse_abstraction_with_arity(parser) + abstraction_with_arity606 = _t1188 if match_lookahead_literal(parser, "(", 0) - _t1202 = parse_attrs(parser) - _t1201 = _t1202 + _t1190 = parse_attrs(parser) + _t1189 = _t1190 else - _t1201 = nothing + _t1189 = nothing end - attrs613 = _t1201 + attrs607 = _t1189 consume_literal!(parser, ")") - _t1203 = Proto.MonoidDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[1], attrs=(!isnothing(attrs613) ? attrs613 : Proto.Attribute[]), value_arity=abstraction_with_arity612[2]) - return _t1203 + _t1191 = Proto.MonoidDef(monoid=monoid604, name=relation_id605, body=abstraction_with_arity606[1], attrs=(!isnothing(attrs607) ? attrs607 : Proto.Attribute[]), value_arity=abstraction_with_arity606[2]) + return _t1191 end function parse_monoid(parser::ParserState)::Proto.Monoid if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1205 = 3 + _t1193 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1206 = 0 + _t1194 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1207 = 1 + _t1195 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1208 = 2 + _t1196 = 2 else - _t1208 = -1 + _t1196 = -1 end - _t1207 = _t1208 + _t1195 = _t1196 end - _t1206 = _t1207 + _t1194 = _t1195 end - _t1205 = _t1206 + _t1193 = _t1194 end - _t1204 = _t1205 + _t1192 = _t1193 else - _t1204 = -1 - end - prediction614 = _t1204 - if prediction614 == 3 - _t1210 = parse_sum_monoid(parser) - sum_monoid618 = _t1210 - _t1211 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid618)) - _t1209 = _t1211 + _t1192 = -1 + end + prediction608 = _t1192 + if prediction608 == 3 + _t1198 = parse_sum_monoid(parser) + sum_monoid612 = _t1198 + _t1199 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid612)) + _t1197 = _t1199 else - if prediction614 == 2 - _t1213 = parse_max_monoid(parser) - max_monoid617 = _t1213 - _t1214 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid617)) - _t1212 = _t1214 + if prediction608 == 2 + _t1201 = parse_max_monoid(parser) + max_monoid611 = _t1201 + _t1202 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid611)) + _t1200 = _t1202 else - if prediction614 == 1 - _t1216 = parse_min_monoid(parser) - min_monoid616 = _t1216 - _t1217 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid616)) - _t1215 = _t1217 + if prediction608 == 1 + _t1204 = parse_min_monoid(parser) + min_monoid610 = _t1204 + _t1205 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid610)) + _t1203 = _t1205 else - if prediction614 == 0 - _t1219 = parse_or_monoid(parser) - or_monoid615 = _t1219 - _t1220 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid615)) - _t1218 = _t1220 + if prediction608 == 0 + _t1207 = parse_or_monoid(parser) + or_monoid609 = _t1207 + _t1208 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid609)) + _t1206 = _t1208 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1215 = _t1218 + _t1203 = _t1206 end - _t1212 = _t1215 + _t1200 = _t1203 end - _t1209 = _t1212 + _t1197 = _t1200 end - return _t1209 + return _t1197 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1221 = Proto.OrMonoid() - return _t1221 + _t1209 = Proto.OrMonoid() + return _t1209 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1222 = parse_type(parser) - type619 = _t1222 + _t1210 = parse_type(parser) + type613 = _t1210 consume_literal!(parser, ")") - _t1223 = Proto.MinMonoid(var"#type"=type619) - return _t1223 + _t1211 = Proto.MinMonoid(var"#type"=type613) + return _t1211 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1224 = parse_type(parser) - type620 = _t1224 + _t1212 = parse_type(parser) + type614 = _t1212 consume_literal!(parser, ")") - _t1225 = Proto.MaxMonoid(var"#type"=type620) - return _t1225 + _t1213 = Proto.MaxMonoid(var"#type"=type614) + return _t1213 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1226 = parse_type(parser) - type621 = _t1226 + _t1214 = parse_type(parser) + type615 = _t1214 consume_literal!(parser, ")") - _t1227 = Proto.SumMonoid(var"#type"=type621) - return _t1227 + _t1215 = Proto.SumMonoid(var"#type"=type615) + return _t1215 end function parse_monus_def(parser::ParserState)::Proto.MonusDef consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1228 = parse_monoid(parser) - monoid622 = _t1228 - _t1229 = parse_relation_id(parser) - relation_id623 = _t1229 - _t1230 = parse_abstraction_with_arity(parser) - abstraction_with_arity624 = _t1230 + _t1216 = parse_monoid(parser) + monoid616 = _t1216 + _t1217 = parse_relation_id(parser) + relation_id617 = _t1217 + _t1218 = parse_abstraction_with_arity(parser) + abstraction_with_arity618 = _t1218 if match_lookahead_literal(parser, "(", 0) - _t1232 = parse_attrs(parser) - _t1231 = _t1232 + _t1220 = parse_attrs(parser) + _t1219 = _t1220 else - _t1231 = nothing + _t1219 = nothing end - attrs625 = _t1231 + attrs619 = _t1219 consume_literal!(parser, ")") - _t1233 = Proto.MonusDef(monoid=monoid622, name=relation_id623, body=abstraction_with_arity624[1], attrs=(!isnothing(attrs625) ? attrs625 : Proto.Attribute[]), value_arity=abstraction_with_arity624[2]) - return _t1233 + _t1221 = Proto.MonusDef(monoid=monoid616, name=relation_id617, body=abstraction_with_arity618[1], attrs=(!isnothing(attrs619) ? attrs619 : Proto.Attribute[]), value_arity=abstraction_with_arity618[2]) + return _t1221 end function parse_constraint(parser::ParserState)::Proto.Constraint consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1234 = parse_relation_id(parser) - relation_id626 = _t1234 - _t1235 = parse_abstraction(parser) - abstraction627 = _t1235 - _t1236 = parse_functional_dependency_keys(parser) - functional_dependency_keys628 = _t1236 - _t1237 = parse_functional_dependency_values(parser) - functional_dependency_values629 = _t1237 - consume_literal!(parser, ")") - _t1238 = Proto.FunctionalDependency(guard=abstraction627, keys=functional_dependency_keys628, values=functional_dependency_values629) - _t1239 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1238), name=relation_id626) - return _t1239 + _t1222 = parse_relation_id(parser) + relation_id620 = _t1222 + _t1223 = parse_abstraction(parser) + abstraction621 = _t1223 + _t1224 = parse_functional_dependency_keys(parser) + functional_dependency_keys622 = _t1224 + _t1225 = parse_functional_dependency_values(parser) + functional_dependency_values623 = _t1225 + consume_literal!(parser, ")") + _t1226 = Proto.FunctionalDependency(guard=abstraction621, keys=functional_dependency_keys622, values=functional_dependency_values623) + _t1227 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1226), name=relation_id620) + return _t1227 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs630 = Proto.Var[] - cond631 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond631 - _t1240 = parse_var(parser) - item632 = _t1240 - push!(xs630, item632) - cond631 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs624 = Proto.Var[] + cond625 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond625 + _t1228 = parse_var(parser) + item626 = _t1228 + push!(xs624, item626) + cond625 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars633 = xs630 + vars627 = xs624 consume_literal!(parser, ")") - return vars633 + return vars627 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs634 = Proto.Var[] - cond635 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond635 - _t1241 = parse_var(parser) - item636 = _t1241 - push!(xs634, item636) - cond635 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs628 = Proto.Var[] + cond629 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond629 + _t1229 = parse_var(parser) + item630 = _t1229 + push!(xs628, item630) + cond629 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars637 = xs634 + vars631 = xs628 consume_literal!(parser, ")") - return vars637 + return vars631 end function parse_data(parser::ParserState)::Proto.Data if match_lookahead_literal(parser, "(", 0) - if match_lookahead_literal(parser, "rel_edb", 1) - _t1243 = 0 + if match_lookahead_literal(parser, "edb", 1) + _t1231 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1244 = 2 + _t1232 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1245 = 1 + _t1233 = 1 else - _t1245 = -1 + _t1233 = -1 end - _t1244 = _t1245 + _t1232 = _t1233 end - _t1243 = _t1244 + _t1231 = _t1232 end - _t1242 = _t1243 + _t1230 = _t1231 else - _t1242 = -1 - end - prediction638 = _t1242 - if prediction638 == 2 - _t1247 = parse_csv_data(parser) - csv_data641 = _t1247 - _t1248 = Proto.Data(data_type=OneOf(:csv_data, csv_data641)) - _t1246 = _t1248 + _t1230 = -1 + end + prediction632 = _t1230 + if prediction632 == 2 + _t1235 = parse_csv_data(parser) + csv_data635 = _t1235 + _t1236 = Proto.Data(data_type=OneOf(:csv_data, csv_data635)) + _t1234 = _t1236 else - if prediction638 == 1 - _t1250 = parse_betree_relation(parser) - betree_relation640 = _t1250 - _t1251 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation640)) - _t1249 = _t1251 + if prediction632 == 1 + _t1238 = parse_betree_relation(parser) + betree_relation634 = _t1238 + _t1239 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation634)) + _t1237 = _t1239 else - if prediction638 == 0 - _t1253 = parse_rel_edb(parser) - rel_edb639 = _t1253 - _t1254 = Proto.Data(data_type=OneOf(:rel_edb, rel_edb639)) - _t1252 = _t1254 + if prediction632 == 0 + _t1241 = parse_edb(parser) + edb633 = _t1241 + _t1242 = Proto.Data(data_type=OneOf(:edb, edb633)) + _t1240 = _t1242 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1249 = _t1252 + _t1237 = _t1240 end - _t1246 = _t1249 + _t1234 = _t1237 end - return _t1246 + return _t1234 end -function parse_rel_edb(parser::ParserState)::Proto.RelEDB +function parse_edb(parser::ParserState)::Proto.EDB consume_literal!(parser, "(") - consume_literal!(parser, "rel_edb") - _t1255 = parse_relation_id(parser) - relation_id642 = _t1255 - _t1256 = parse_rel_edb_path(parser) - rel_edb_path643 = _t1256 - _t1257 = parse_rel_edb_types(parser) - rel_edb_types644 = _t1257 + consume_literal!(parser, "edb") + _t1243 = parse_relation_id(parser) + relation_id636 = _t1243 + _t1244 = parse_edb_path(parser) + edb_path637 = _t1244 + _t1245 = parse_edb_types(parser) + edb_types638 = _t1245 consume_literal!(parser, ")") - _t1258 = Proto.RelEDB(target_id=relation_id642, path=rel_edb_path643, types=rel_edb_types644) - return _t1258 + _t1246 = Proto.EDB(target_id=relation_id636, path=edb_path637, types=edb_types638) + return _t1246 end -function parse_rel_edb_path(parser::ParserState)::Vector{String} +function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs645 = String[] - cond646 = match_lookahead_terminal(parser, "STRING", 0) - while cond646 - item647 = consume_terminal!(parser, "STRING") - push!(xs645, item647) - cond646 = match_lookahead_terminal(parser, "STRING", 0) - end - strings648 = xs645 + xs639 = String[] + cond640 = match_lookahead_terminal(parser, "STRING", 0) + while cond640 + item641 = consume_terminal!(parser, "STRING") + push!(xs639, item641) + cond640 = match_lookahead_terminal(parser, "STRING", 0) + end + strings642 = xs639 consume_literal!(parser, "]") - return strings648 + return strings642 end -function parse_rel_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} +function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs649 = Proto.var"#Type"[] - cond650 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond650 - _t1259 = parse_type(parser) - item651 = _t1259 - push!(xs649, item651) - cond650 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types652 = xs649 + xs643 = Proto.var"#Type"[] + cond644 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond644 + _t1247 = parse_type(parser) + item645 = _t1247 + push!(xs643, item645) + cond644 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types646 = xs643 consume_literal!(parser, "]") - return types652 + return types646 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1260 = parse_relation_id(parser) - relation_id653 = _t1260 - _t1261 = parse_betree_info(parser) - betree_info654 = _t1261 + _t1248 = parse_relation_id(parser) + relation_id647 = _t1248 + _t1249 = parse_betree_info(parser) + betree_info648 = _t1249 consume_literal!(parser, ")") - _t1262 = Proto.BeTreeRelation(name=relation_id653, relation_info=betree_info654) - return _t1262 + _t1250 = Proto.BeTreeRelation(name=relation_id647, relation_info=betree_info648) + return _t1250 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1263 = parse_betree_info_key_types(parser) - betree_info_key_types655 = _t1263 - _t1264 = parse_betree_info_value_types(parser) - betree_info_value_types656 = _t1264 - _t1265 = parse_config_dict(parser) - config_dict657 = _t1265 - consume_literal!(parser, ")") - _t1266 = construct_betree_info(parser, betree_info_key_types655, betree_info_value_types656, config_dict657) - return _t1266 + _t1251 = parse_betree_info_key_types(parser) + betree_info_key_types649 = _t1251 + _t1252 = parse_betree_info_value_types(parser) + betree_info_value_types650 = _t1252 + _t1253 = parse_config_dict(parser) + config_dict651 = _t1253 + consume_literal!(parser, ")") + _t1254 = construct_betree_info(parser, betree_info_key_types649, betree_info_value_types650, config_dict651) + return _t1254 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs658 = Proto.var"#Type"[] - cond659 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond659 - _t1267 = parse_type(parser) - item660 = _t1267 - push!(xs658, item660) - cond659 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs652 = Proto.var"#Type"[] + cond653 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond653 + _t1255 = parse_type(parser) + item654 = _t1255 + push!(xs652, item654) + cond653 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types661 = xs658 + types655 = xs652 consume_literal!(parser, ")") - return types661 + return types655 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs662 = Proto.var"#Type"[] - cond663 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond663 - _t1268 = parse_type(parser) - item664 = _t1268 - push!(xs662, item664) - cond663 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs656 = Proto.var"#Type"[] + cond657 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond657 + _t1256 = parse_type(parser) + item658 = _t1256 + push!(xs656, item658) + cond657 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types665 = xs662 + types659 = xs656 consume_literal!(parser, ")") - return types665 + return types659 end function parse_csv_data(parser::ParserState)::Proto.CSVData consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1269 = parse_csvlocator(parser) - csvlocator666 = _t1269 - _t1270 = parse_csv_config(parser) - csv_config667 = _t1270 - _t1271 = parse_csv_columns(parser) - csv_columns668 = _t1271 - _t1272 = parse_csv_asof(parser) - csv_asof669 = _t1272 + _t1257 = parse_csvlocator(parser) + csvlocator660 = _t1257 + _t1258 = parse_csv_config(parser) + csv_config661 = _t1258 + _t1259 = parse_gnf_columns(parser) + gnf_columns662 = _t1259 + _t1260 = parse_csv_asof(parser) + csv_asof663 = _t1260 consume_literal!(parser, ")") - _t1273 = Proto.CSVData(locator=csvlocator666, config=csv_config667, columns=csv_columns668, asof=csv_asof669) - return _t1273 + _t1261 = Proto.CSVData(locator=csvlocator660, config=csv_config661, columns=gnf_columns662, asof=csv_asof663) + return _t1261 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1275 = parse_csv_locator_paths(parser) - _t1274 = _t1275 + _t1263 = parse_csv_locator_paths(parser) + _t1262 = _t1263 else - _t1274 = nothing + _t1262 = nothing end - csv_locator_paths670 = _t1274 + csv_locator_paths664 = _t1262 if match_lookahead_literal(parser, "(", 0) - _t1277 = parse_csv_locator_inline_data(parser) - _t1276 = _t1277 + _t1265 = parse_csv_locator_inline_data(parser) + _t1264 = _t1265 else - _t1276 = nothing + _t1264 = nothing end - csv_locator_inline_data671 = _t1276 + csv_locator_inline_data665 = _t1264 consume_literal!(parser, ")") - _t1278 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths670) ? csv_locator_paths670 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data671) ? csv_locator_inline_data671 : ""))) - return _t1278 + _t1266 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths664) ? csv_locator_paths664 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data665) ? csv_locator_inline_data665 : ""))) + return _t1266 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs672 = String[] - cond673 = match_lookahead_terminal(parser, "STRING", 0) - while cond673 - item674 = consume_terminal!(parser, "STRING") - push!(xs672, item674) - cond673 = match_lookahead_terminal(parser, "STRING", 0) + xs666 = String[] + cond667 = match_lookahead_terminal(parser, "STRING", 0) + while cond667 + item668 = consume_terminal!(parser, "STRING") + push!(xs666, item668) + cond667 = match_lookahead_terminal(parser, "STRING", 0) end - strings675 = xs672 + strings669 = xs666 consume_literal!(parser, ")") - return strings675 + return strings669 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - string676 = consume_terminal!(parser, "STRING") + string670 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string676 + return string670 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1279 = parse_config_dict(parser) - config_dict677 = _t1279 + _t1267 = parse_config_dict(parser) + config_dict671 = _t1267 consume_literal!(parser, ")") - _t1280 = construct_csv_config(parser, config_dict677) - return _t1280 + _t1268 = construct_csv_config(parser, config_dict671) + return _t1268 end -function parse_csv_columns(parser::ParserState)::Vector{Proto.CSVColumn} +function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs678 = Proto.CSVColumn[] - cond679 = match_lookahead_literal(parser, "(", 0) - while cond679 - _t1281 = parse_csv_column(parser) - item680 = _t1281 - push!(xs678, item680) - cond679 = match_lookahead_literal(parser, "(", 0) + xs672 = Proto.GNFColumn[] + cond673 = match_lookahead_literal(parser, "(", 0) + while cond673 + _t1269 = parse_gnf_column(parser) + item674 = _t1269 + push!(xs672, item674) + cond673 = match_lookahead_literal(parser, "(", 0) end - csv_columns681 = xs678 + gnf_columns675 = xs672 consume_literal!(parser, ")") - return csv_columns681 + return gnf_columns675 end -function parse_csv_column(parser::ParserState)::Proto.CSVColumn +function parse_gnf_column(parser::ParserState)::Proto.GNFColumn consume_literal!(parser, "(") consume_literal!(parser, "column") - _t1282 = parse_csv_column_path(parser) - csv_column_path682 = _t1282 - if ((match_lookahead_literal(parser, ":", 0) || match_lookahead_literal(parser, "[", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - _t1284 = parse_csv_column_tail(parser) - _t1283 = _t1284 + _t1270 = parse_gnf_column_path(parser) + gnf_column_path676 = _t1270 + if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1272 = parse_relation_id(parser) + _t1271 = _t1272 else - _t1283 = nothing + _t1271 = nothing end - csv_column_tail683 = _t1283 + relation_id677 = _t1271 + consume_literal!(parser, "[") + xs678 = Proto.var"#Type"[] + cond679 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond679 + _t1273 = parse_type(parser) + item680 = _t1273 + push!(xs678, item680) + cond679 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types681 = xs678 + consume_literal!(parser, "]") consume_literal!(parser, ")") - _t1285 = construct_csv_column(parser, csv_column_path682, csv_column_tail683) - return _t1285 + _t1274 = Proto.GNFColumn(column_path=gnf_column_path676, target_id=relation_id677, types=types681) + return _t1274 end -function parse_csv_column_path(parser::ParserState)::Vector{String} +function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t1286 = 1 + _t1275 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1287 = 0 + _t1276 = 0 else - _t1287 = -1 + _t1276 = -1 end - _t1286 = _t1287 + _t1275 = _t1276 end - prediction684 = _t1286 - if prediction684 == 1 + prediction682 = _t1275 + if prediction682 == 1 consume_literal!(parser, "[") - xs686 = String[] - cond687 = match_lookahead_terminal(parser, "STRING", 0) - while cond687 - item688 = consume_terminal!(parser, "STRING") - push!(xs686, item688) - cond687 = match_lookahead_terminal(parser, "STRING", 0) + xs684 = String[] + cond685 = match_lookahead_terminal(parser, "STRING", 0) + while cond685 + item686 = consume_terminal!(parser, "STRING") + push!(xs684, item686) + cond685 = match_lookahead_terminal(parser, "STRING", 0) end - strings689 = xs686 + strings687 = xs684 consume_literal!(parser, "]") - _t1288 = strings689 + _t1277 = strings687 else - if prediction684 == 0 - string685 = consume_terminal!(parser, "STRING") - _t1289 = String[string685] + if prediction682 == 0 + string683 = consume_terminal!(parser, "STRING") + _t1278 = String[string683] else - throw(ParseError("Unexpected token in csv_column_path" * ": " * string(lookahead(parser, 0)))) + throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t1288 = _t1289 + _t1277 = _t1278 end - return _t1288 -end - -function parse_csv_column_tail(parser::ParserState)::Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}} - if match_lookahead_literal(parser, "[", 0) - _t1290 = 1 - else - if match_lookahead_literal(parser, ":", 0) - _t1291 = 0 - else - if match_lookahead_terminal(parser, "UINT128", 0) - _t1292 = 0 - else - _t1292 = -1 - end - _t1291 = _t1292 - end - _t1290 = _t1291 - end - prediction690 = _t1290 - if prediction690 == 1 - consume_literal!(parser, "[") - xs696 = Proto.var"#Type"[] - cond697 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond697 - _t1294 = parse_type(parser) - item698 = _t1294 - push!(xs696, item698) - cond697 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types699 = xs696 - consume_literal!(parser, "]") - _t1293 = (nothing, types699,) - else - if prediction690 == 0 - _t1296 = parse_relation_id(parser) - relation_id691 = _t1296 - consume_literal!(parser, "[") - xs692 = Proto.var"#Type"[] - cond693 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond693 - _t1297 = parse_type(parser) - item694 = _t1297 - push!(xs692, item694) - cond693 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types695 = xs692 - consume_literal!(parser, "]") - _t1295 = (relation_id691, types695,) - else - throw(ParseError("Unexpected token in csv_column_tail" * ": " * string(lookahead(parser, 0)))) - end - _t1293 = _t1295 - end - return _t1293 + return _t1277 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string700 = consume_terminal!(parser, "STRING") + string688 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string700 + return string688 end function parse_undefine(parser::ParserState)::Proto.Undefine consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t1298 = parse_fragment_id(parser) - fragment_id701 = _t1298 + _t1279 = parse_fragment_id(parser) + fragment_id689 = _t1279 consume_literal!(parser, ")") - _t1299 = Proto.Undefine(fragment_id=fragment_id701) - return _t1299 + _t1280 = Proto.Undefine(fragment_id=fragment_id689) + return _t1280 end function parse_context(parser::ParserState)::Proto.Context consume_literal!(parser, "(") consume_literal!(parser, "context") - xs702 = Proto.RelationId[] - cond703 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond703 - _t1300 = parse_relation_id(parser) - item704 = _t1300 - push!(xs702, item704) - cond703 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs690 = Proto.RelationId[] + cond691 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond691 + _t1281 = parse_relation_id(parser) + item692 = _t1281 + push!(xs690, item692) + cond691 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids705 = xs702 + relation_ids693 = xs690 consume_literal!(parser, ")") - _t1301 = Proto.Context(relations=relation_ids705) - return _t1301 + _t1282 = Proto.Context(relations=relation_ids693) + return _t1282 end function parse_snapshot(parser::ParserState)::Proto.Snapshot consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t1302 = parse_rel_edb_path(parser) - rel_edb_path706 = _t1302 - _t1303 = parse_relation_id(parser) - relation_id707 = _t1303 + _t1283 = parse_edb_path(parser) + edb_path694 = _t1283 + _t1284 = parse_relation_id(parser) + relation_id695 = _t1284 consume_literal!(parser, ")") - _t1304 = Proto.Snapshot(destination_path=rel_edb_path706, source_relation=relation_id707) - return _t1304 + _t1285 = Proto.Snapshot(destination_path=edb_path694, source_relation=relation_id695) + return _t1285 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs708 = Proto.Read[] - cond709 = match_lookahead_literal(parser, "(", 0) - while cond709 - _t1305 = parse_read(parser) - item710 = _t1305 - push!(xs708, item710) - cond709 = match_lookahead_literal(parser, "(", 0) + xs696 = Proto.Read[] + cond697 = match_lookahead_literal(parser, "(", 0) + while cond697 + _t1286 = parse_read(parser) + item698 = _t1286 + push!(xs696, item698) + cond697 = match_lookahead_literal(parser, "(", 0) end - reads711 = xs708 + reads699 = xs696 consume_literal!(parser, ")") - return reads711 + return reads699 end function parse_read(parser::ParserState)::Proto.Read if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t1307 = 2 + _t1288 = 2 else if match_lookahead_literal(parser, "output", 1) - _t1308 = 1 + _t1289 = 1 else if match_lookahead_literal(parser, "export", 1) - _t1309 = 4 + _t1290 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t1310 = 0 + _t1291 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t1311 = 3 + _t1292 = 3 else - _t1311 = -1 + _t1292 = -1 end - _t1310 = _t1311 + _t1291 = _t1292 end - _t1309 = _t1310 + _t1290 = _t1291 end - _t1308 = _t1309 + _t1289 = _t1290 end - _t1307 = _t1308 + _t1288 = _t1289 end - _t1306 = _t1307 + _t1287 = _t1288 else - _t1306 = -1 - end - prediction712 = _t1306 - if prediction712 == 4 - _t1313 = parse_export(parser) - export717 = _t1313 - _t1314 = Proto.Read(read_type=OneOf(:var"#export", export717)) - _t1312 = _t1314 + _t1287 = -1 + end + prediction700 = _t1287 + if prediction700 == 4 + _t1294 = parse_export(parser) + export705 = _t1294 + _t1295 = Proto.Read(read_type=OneOf(:var"#export", export705)) + _t1293 = _t1295 else - if prediction712 == 3 - _t1316 = parse_abort(parser) - abort716 = _t1316 - _t1317 = Proto.Read(read_type=OneOf(:abort, abort716)) - _t1315 = _t1317 + if prediction700 == 3 + _t1297 = parse_abort(parser) + abort704 = _t1297 + _t1298 = Proto.Read(read_type=OneOf(:abort, abort704)) + _t1296 = _t1298 else - if prediction712 == 2 - _t1319 = parse_what_if(parser) - what_if715 = _t1319 - _t1320 = Proto.Read(read_type=OneOf(:what_if, what_if715)) - _t1318 = _t1320 + if prediction700 == 2 + _t1300 = parse_what_if(parser) + what_if703 = _t1300 + _t1301 = Proto.Read(read_type=OneOf(:what_if, what_if703)) + _t1299 = _t1301 else - if prediction712 == 1 - _t1322 = parse_output(parser) - output714 = _t1322 - _t1323 = Proto.Read(read_type=OneOf(:output, output714)) - _t1321 = _t1323 + if prediction700 == 1 + _t1303 = parse_output(parser) + output702 = _t1303 + _t1304 = Proto.Read(read_type=OneOf(:output, output702)) + _t1302 = _t1304 else - if prediction712 == 0 - _t1325 = parse_demand(parser) - demand713 = _t1325 - _t1326 = Proto.Read(read_type=OneOf(:demand, demand713)) - _t1324 = _t1326 + if prediction700 == 0 + _t1306 = parse_demand(parser) + demand701 = _t1306 + _t1307 = Proto.Read(read_type=OneOf(:demand, demand701)) + _t1305 = _t1307 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t1321 = _t1324 + _t1302 = _t1305 end - _t1318 = _t1321 + _t1299 = _t1302 end - _t1315 = _t1318 + _t1296 = _t1299 end - _t1312 = _t1315 + _t1293 = _t1296 end - return _t1312 + return _t1293 end function parse_demand(parser::ParserState)::Proto.Demand consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t1327 = parse_relation_id(parser) - relation_id718 = _t1327 + _t1308 = parse_relation_id(parser) + relation_id706 = _t1308 consume_literal!(parser, ")") - _t1328 = Proto.Demand(relation_id=relation_id718) - return _t1328 + _t1309 = Proto.Demand(relation_id=relation_id706) + return _t1309 end function parse_output(parser::ParserState)::Proto.Output consume_literal!(parser, "(") consume_literal!(parser, "output") - _t1329 = parse_name(parser) - name719 = _t1329 - _t1330 = parse_relation_id(parser) - relation_id720 = _t1330 + _t1310 = parse_name(parser) + name707 = _t1310 + _t1311 = parse_relation_id(parser) + relation_id708 = _t1311 consume_literal!(parser, ")") - _t1331 = Proto.Output(name=name719, relation_id=relation_id720) - return _t1331 + _t1312 = Proto.Output(name=name707, relation_id=relation_id708) + return _t1312 end function parse_what_if(parser::ParserState)::Proto.WhatIf consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t1332 = parse_name(parser) - name721 = _t1332 - _t1333 = parse_epoch(parser) - epoch722 = _t1333 + _t1313 = parse_name(parser) + name709 = _t1313 + _t1314 = parse_epoch(parser) + epoch710 = _t1314 consume_literal!(parser, ")") - _t1334 = Proto.WhatIf(branch=name721, epoch=epoch722) - return _t1334 + _t1315 = Proto.WhatIf(branch=name709, epoch=epoch710) + return _t1315 end function parse_abort(parser::ParserState)::Proto.Abort consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t1336 = parse_name(parser) - _t1335 = _t1336 + _t1317 = parse_name(parser) + _t1316 = _t1317 else - _t1335 = nothing + _t1316 = nothing end - name723 = _t1335 - _t1337 = parse_relation_id(parser) - relation_id724 = _t1337 + name711 = _t1316 + _t1318 = parse_relation_id(parser) + relation_id712 = _t1318 consume_literal!(parser, ")") - _t1338 = Proto.Abort(name=(!isnothing(name723) ? name723 : "abort"), relation_id=relation_id724) - return _t1338 + _t1319 = Proto.Abort(name=(!isnothing(name711) ? name711 : "abort"), relation_id=relation_id712) + return _t1319 end function parse_export(parser::ParserState)::Proto.Export consume_literal!(parser, "(") consume_literal!(parser, "export") - _t1339 = parse_export_csv_config(parser) - export_csv_config725 = _t1339 + _t1320 = parse_export_csv_config(parser) + export_csv_config713 = _t1320 consume_literal!(parser, ")") - _t1340 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config725)) - return _t1340 + _t1321 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config713)) + return _t1321 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t1341 = parse_export_csv_path(parser) - export_csv_path726 = _t1341 - _t1342 = parse_export_csv_columns(parser) - export_csv_columns727 = _t1342 - _t1343 = parse_config_dict(parser) - config_dict728 = _t1343 + _t1322 = parse_export_csv_path(parser) + export_csv_path714 = _t1322 + _t1323 = parse_export_csv_columns(parser) + export_csv_columns715 = _t1323 + _t1324 = parse_config_dict(parser) + config_dict716 = _t1324 consume_literal!(parser, ")") - _t1344 = export_csv_config(parser, export_csv_path726, export_csv_columns727, config_dict728) - return _t1344 + _t1325 = export_csv_config(parser, export_csv_path714, export_csv_columns715, config_dict716) + return _t1325 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string729 = consume_terminal!(parser, "STRING") + string717 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string729 + return string717 end function parse_export_csv_columns(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs730 = Proto.ExportCSVColumn[] - cond731 = match_lookahead_literal(parser, "(", 0) - while cond731 - _t1345 = parse_export_csv_column(parser) - item732 = _t1345 - push!(xs730, item732) - cond731 = match_lookahead_literal(parser, "(", 0) + xs718 = Proto.ExportCSVColumn[] + cond719 = match_lookahead_literal(parser, "(", 0) + while cond719 + _t1326 = parse_export_csv_column(parser) + item720 = _t1326 + push!(xs718, item720) + cond719 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns733 = xs730 + export_csv_columns721 = xs718 consume_literal!(parser, ")") - return export_csv_columns733 + return export_csv_columns721 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn consume_literal!(parser, "(") consume_literal!(parser, "column") - string734 = consume_terminal!(parser, "STRING") - _t1346 = parse_relation_id(parser) - relation_id735 = _t1346 + string722 = consume_terminal!(parser, "STRING") + _t1327 = parse_relation_id(parser) + relation_id723 = _t1327 consume_literal!(parser, ")") - _t1347 = Proto.ExportCSVColumn(column_name=string734, column_data=relation_id735) - return _t1347 + _t1328 = Proto.ExportCSVColumn(column_name=string722, column_data=relation_id723) + return _t1328 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 76fd7f5c..58c5ff65 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -338,160 +338,151 @@ end # --- Helper functions --- function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1732 = Proto.Value(value=OneOf(:int_value, Int64(v))) - return _t1732 + _t1710 = Proto.Value(value=OneOf(:int_value, Int64(v))) + return _t1710 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1733 = Proto.Value(value=OneOf(:int_value, v)) - return _t1733 + _t1711 = Proto.Value(value=OneOf(:int_value, v)) + return _t1711 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1734 = Proto.Value(value=OneOf(:float_value, v)) - return _t1734 + _t1712 = Proto.Value(value=OneOf(:float_value, v)) + return _t1712 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1735 = Proto.Value(value=OneOf(:string_value, v)) - return _t1735 + _t1713 = Proto.Value(value=OneOf(:string_value, v)) + return _t1713 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1736 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1736 + _t1714 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1714 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1737 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1737 + _t1715 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1715 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 - _t1738 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1738,)) + _t1716 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1716,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1739 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1739,)) + _t1717 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1717,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1740 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1740,)) + _t1718 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1718,)) end end end - _t1741 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1741,)) + _t1719 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1719,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1742 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1742,)) - _t1743 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1743,)) + _t1720 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1720,)) + _t1721 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1721,)) if msg.new_line != "" - _t1744 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1744,)) - end - _t1745 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1745,)) - _t1746 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1746,)) - _t1747 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1747,)) + _t1722 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1722,)) + end + _t1723 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1723,)) + _t1724 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1724,)) + _t1725 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1725,)) if msg.comment != "" - _t1748 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1748,)) + _t1726 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1726,)) end for missing_string in msg.missing_strings - _t1749 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1749,)) - end - _t1750 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1750,)) - _t1751 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1751,)) - _t1752 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1752,)) + _t1727 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1727,)) + end + _t1728 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1728,)) + _t1729 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1729,)) + _t1730 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1730,)) return sort(result) end function deconstruct_betree_info_config(pp::PrettyPrinter, msg::Proto.BeTreeInfo)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1753 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1753,)) - _t1754 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1754,)) - _t1755 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1755,)) - _t1756 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1756,)) + _t1731 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1731,)) + _t1732 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1732,)) + _t1733 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1733,)) + _t1734 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1734,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1757 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1757,)) + _t1735 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1735,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1758 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1758,)) + _t1736 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1736,)) end end - _t1759 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1759,)) - _t1760 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1760,)) + _t1737 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1737,)) + _t1738 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1738,)) 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) - _t1761 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1761,)) + _t1739 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1739,)) end if !isnothing(msg.compression) - _t1762 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1762,)) + _t1740 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1740,)) end if !isnothing(msg.syntax_header_row) - _t1763 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1763,)) + _t1741 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1741,)) end if !isnothing(msg.syntax_missing_string) - _t1764 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1764,)) + _t1742 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1742,)) end if !isnothing(msg.syntax_delim) - _t1765 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1765,)) + _t1743 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1743,)) end if !isnothing(msg.syntax_quotechar) - _t1766 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1766,)) + _t1744 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1744,)) end if !isnothing(msg.syntax_escapechar) - _t1767 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1767,)) + _t1745 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1745,)) end return sort(result) end -function deconstruct_csv_column_tail(pp::PrettyPrinter, col::Proto.CSVColumn)::Union{Nothing, Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}} - if (_has_proto_field(col, Symbol("target_id")) || !isempty(col.types)) - return (col.target_id, col.types,) - else - _t1768 = nothing - end - return nothing -end - function deconstruct_relation_id_string(pp::PrettyPrinter, msg::Proto.RelationId)::String name = relation_id_to_string(pp, msg) return name @@ -502,7 +493,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1769 = nothing + _t1746 = nothing end return nothing end @@ -521,51 +512,51 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat654 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat654) - write(pp, flat654) + flat646 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat646) + write(pp, flat646) return nothing else - function _t1290(_dollar_dollar) + function _t1274(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1291 = _dollar_dollar.configure + _t1275 = _dollar_dollar.configure else - _t1291 = nothing + _t1275 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1292 = _dollar_dollar.sync + _t1276 = _dollar_dollar.sync else - _t1292 = nothing + _t1276 = nothing end - return (_t1291, _t1292, _dollar_dollar.epochs,) + return (_t1275, _t1276, _dollar_dollar.epochs,) end - _t1293 = _t1290(msg) - fields645 = _t1293 - unwrapped_fields646 = fields645 + _t1277 = _t1274(msg) + fields637 = _t1277 + unwrapped_fields638 = fields637 write(pp, "(") write(pp, "transaction") indent_sexp!(pp) - field647 = unwrapped_fields646[1] - if !isnothing(field647) + field639 = unwrapped_fields638[1] + if !isnothing(field639) newline(pp) - opt_val648 = field647 - pretty_configure(pp, opt_val648) + opt_val640 = field639 + pretty_configure(pp, opt_val640) end - field649 = unwrapped_fields646[2] - if !isnothing(field649) + field641 = unwrapped_fields638[2] + if !isnothing(field641) newline(pp) - opt_val650 = field649 - pretty_sync(pp, opt_val650) + opt_val642 = field641 + pretty_sync(pp, opt_val642) end - field651 = unwrapped_fields646[3] - if !isempty(field651) + field643 = unwrapped_fields638[3] + if !isempty(field643) newline(pp) - for (i1294, elem652) in enumerate(field651) - i653 = i1294 - 1 - if (i653 > 0) + for (i1278, elem644) in enumerate(field643) + i645 = i1278 - 1 + if (i645 > 0) newline(pp) end - pretty_epoch(pp, elem652) + pretty_epoch(pp, elem644) end end dedent!(pp) @@ -575,23 +566,23 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat657 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat657) - write(pp, flat657) + flat649 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat649) + write(pp, flat649) return nothing else - function _t1295(_dollar_dollar) - _t1296 = deconstruct_configure(pp, _dollar_dollar) - return _t1296 + function _t1279(_dollar_dollar) + _t1280 = deconstruct_configure(pp, _dollar_dollar) + return _t1280 end - _t1297 = _t1295(msg) - fields655 = _t1297 - unwrapped_fields656 = fields655 + _t1281 = _t1279(msg) + fields647 = _t1281 + unwrapped_fields648 = fields647 write(pp, "(") write(pp, "configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields656) + pretty_config_dict(pp, unwrapped_fields648) dedent!(pp) write(pp, ")") end @@ -599,22 +590,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat661 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat661) - write(pp, flat661) + flat653 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat653) + write(pp, flat653) return nothing else - fields658 = msg + fields650 = msg write(pp, "{") indent!(pp) - if !isempty(fields658) + if !isempty(fields650) newline(pp) - for (i1298, elem659) in enumerate(fields658) - i660 = i1298 - 1 - if (i660 > 0) + for (i1282, elem651) in enumerate(fields650) + i652 = i1282 - 1 + if (i652 > 0) newline(pp) end - pretty_config_key_value(pp, elem659) + pretty_config_key_value(pp, elem651) end end dedent!(pp) @@ -624,160 +615,160 @@ 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}) - flat666 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat666) - write(pp, flat666) + flat658 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat658) + write(pp, flat658) return nothing else - function _t1299(_dollar_dollar) + function _t1283(_dollar_dollar) return (_dollar_dollar[1], _dollar_dollar[2],) end - _t1300 = _t1299(msg) - fields662 = _t1300 - unwrapped_fields663 = fields662 + _t1284 = _t1283(msg) + fields654 = _t1284 + unwrapped_fields655 = fields654 write(pp, ":") - field664 = unwrapped_fields663[1] - write(pp, field664) + field656 = unwrapped_fields655[1] + write(pp, field656) write(pp, " ") - field665 = unwrapped_fields663[2] - pretty_value(pp, field665) + field657 = unwrapped_fields655[2] + pretty_value(pp, field657) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat686 = try_flat(pp, msg, pretty_value) - if !isnothing(flat686) - write(pp, flat686) + flat678 = try_flat(pp, msg, pretty_value) + if !isnothing(flat678) + write(pp, flat678) return nothing else - function _t1301(_dollar_dollar) + function _t1285(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1302 = _get_oneof_field(_dollar_dollar, :date_value) + _t1286 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1302 = nothing + _t1286 = nothing end - return _t1302 + return _t1286 end - _t1303 = _t1301(msg) - deconstruct_result684 = _t1303 - if !isnothing(deconstruct_result684) - unwrapped685 = deconstruct_result684 - pretty_date(pp, unwrapped685) + _t1287 = _t1285(msg) + deconstruct_result676 = _t1287 + if !isnothing(deconstruct_result676) + unwrapped677 = deconstruct_result676 + pretty_date(pp, unwrapped677) else - function _t1304(_dollar_dollar) + function _t1288(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1305 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1289 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1305 = nothing + _t1289 = nothing end - return _t1305 + return _t1289 end - _t1306 = _t1304(msg) - deconstruct_result682 = _t1306 - if !isnothing(deconstruct_result682) - unwrapped683 = deconstruct_result682 - pretty_datetime(pp, unwrapped683) + _t1290 = _t1288(msg) + deconstruct_result674 = _t1290 + if !isnothing(deconstruct_result674) + unwrapped675 = deconstruct_result674 + pretty_datetime(pp, unwrapped675) else - function _t1307(_dollar_dollar) + function _t1291(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1308 = _get_oneof_field(_dollar_dollar, :string_value) + _t1292 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1308 = nothing + _t1292 = nothing end - return _t1308 + return _t1292 end - _t1309 = _t1307(msg) - deconstruct_result680 = _t1309 - if !isnothing(deconstruct_result680) - unwrapped681 = deconstruct_result680 - write(pp, format_string(pp, unwrapped681)) + _t1293 = _t1291(msg) + deconstruct_result672 = _t1293 + if !isnothing(deconstruct_result672) + unwrapped673 = deconstruct_result672 + write(pp, format_string(pp, unwrapped673)) else - function _t1310(_dollar_dollar) + function _t1294(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1311 = _get_oneof_field(_dollar_dollar, :int_value) + _t1295 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1311 = nothing + _t1295 = nothing end - return _t1311 + return _t1295 end - _t1312 = _t1310(msg) - deconstruct_result678 = _t1312 - if !isnothing(deconstruct_result678) - unwrapped679 = deconstruct_result678 - write(pp, format_int(pp, unwrapped679)) + _t1296 = _t1294(msg) + deconstruct_result670 = _t1296 + if !isnothing(deconstruct_result670) + unwrapped671 = deconstruct_result670 + write(pp, format_int(pp, unwrapped671)) else - function _t1313(_dollar_dollar) + function _t1297(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1314 = _get_oneof_field(_dollar_dollar, :float_value) + _t1298 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1314 = nothing + _t1298 = nothing end - return _t1314 + return _t1298 end - _t1315 = _t1313(msg) - deconstruct_result676 = _t1315 - if !isnothing(deconstruct_result676) - unwrapped677 = deconstruct_result676 - write(pp, format_float(pp, unwrapped677)) + _t1299 = _t1297(msg) + deconstruct_result668 = _t1299 + if !isnothing(deconstruct_result668) + unwrapped669 = deconstruct_result668 + write(pp, format_float(pp, unwrapped669)) else - function _t1316(_dollar_dollar) + function _t1300(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1317 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1301 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1317 = nothing + _t1301 = nothing end - return _t1317 + return _t1301 end - _t1318 = _t1316(msg) - deconstruct_result674 = _t1318 - if !isnothing(deconstruct_result674) - unwrapped675 = deconstruct_result674 - write(pp, format_uint128(pp, unwrapped675)) + _t1302 = _t1300(msg) + deconstruct_result666 = _t1302 + if !isnothing(deconstruct_result666) + unwrapped667 = deconstruct_result666 + write(pp, format_uint128(pp, unwrapped667)) else - function _t1319(_dollar_dollar) + function _t1303(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1320 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1304 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1320 = nothing + _t1304 = nothing end - return _t1320 + return _t1304 end - _t1321 = _t1319(msg) - deconstruct_result672 = _t1321 - if !isnothing(deconstruct_result672) - unwrapped673 = deconstruct_result672 - write(pp, format_int128(pp, unwrapped673)) + _t1305 = _t1303(msg) + deconstruct_result664 = _t1305 + if !isnothing(deconstruct_result664) + unwrapped665 = deconstruct_result664 + write(pp, format_int128(pp, unwrapped665)) else - function _t1322(_dollar_dollar) + function _t1306(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1323 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1307 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1323 = nothing + _t1307 = nothing end - return _t1323 + return _t1307 end - _t1324 = _t1322(msg) - deconstruct_result670 = _t1324 - if !isnothing(deconstruct_result670) - unwrapped671 = deconstruct_result670 - write(pp, format_decimal(pp, unwrapped671)) + _t1308 = _t1306(msg) + deconstruct_result662 = _t1308 + if !isnothing(deconstruct_result662) + unwrapped663 = deconstruct_result662 + write(pp, format_decimal(pp, unwrapped663)) else - function _t1325(_dollar_dollar) + function _t1309(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1326 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1310 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1326 = nothing + _t1310 = nothing end - return _t1326 + return _t1310 end - _t1327 = _t1325(msg) - deconstruct_result668 = _t1327 - if !isnothing(deconstruct_result668) - unwrapped669 = deconstruct_result668 - pretty_boolean_value(pp, unwrapped669) + _t1311 = _t1309(msg) + deconstruct_result660 = _t1311 + if !isnothing(deconstruct_result660) + unwrapped661 = deconstruct_result660 + pretty_boolean_value(pp, unwrapped661) else - fields667 = msg + fields659 = msg write(pp, "missing") end end @@ -793,29 +784,29 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat692 = try_flat(pp, msg, pretty_date) - if !isnothing(flat692) - write(pp, flat692) + flat684 = try_flat(pp, msg, pretty_date) + if !isnothing(flat684) + write(pp, flat684) return nothing else - function _t1328(_dollar_dollar) + function _t1312(_dollar_dollar) return (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) end - _t1329 = _t1328(msg) - fields687 = _t1329 - unwrapped_fields688 = fields687 + _t1313 = _t1312(msg) + fields679 = _t1313 + unwrapped_fields680 = fields679 write(pp, "(") write(pp, "date") indent_sexp!(pp) newline(pp) - field689 = unwrapped_fields688[1] - write(pp, format_int(pp, field689)) + field681 = unwrapped_fields680[1] + write(pp, format_int(pp, field681)) newline(pp) - field690 = unwrapped_fields688[2] - write(pp, format_int(pp, field690)) + field682 = unwrapped_fields680[2] + write(pp, format_int(pp, field682)) newline(pp) - field691 = unwrapped_fields688[3] - write(pp, format_int(pp, field691)) + field683 = unwrapped_fields680[3] + write(pp, format_int(pp, field683)) dedent!(pp) write(pp, ")") end @@ -823,43 +814,43 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat703 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat703) - write(pp, flat703) + flat695 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat695) + write(pp, flat695) return nothing else - function _t1330(_dollar_dollar) + function _t1314(_dollar_dollar) return (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),) end - _t1331 = _t1330(msg) - fields693 = _t1331 - unwrapped_fields694 = fields693 + _t1315 = _t1314(msg) + fields685 = _t1315 + unwrapped_fields686 = fields685 write(pp, "(") write(pp, "datetime") indent_sexp!(pp) newline(pp) - field695 = unwrapped_fields694[1] - write(pp, format_int(pp, field695)) + field687 = unwrapped_fields686[1] + write(pp, format_int(pp, field687)) newline(pp) - field696 = unwrapped_fields694[2] - write(pp, format_int(pp, field696)) + field688 = unwrapped_fields686[2] + write(pp, format_int(pp, field688)) newline(pp) - field697 = unwrapped_fields694[3] - write(pp, format_int(pp, field697)) + field689 = unwrapped_fields686[3] + write(pp, format_int(pp, field689)) newline(pp) - field698 = unwrapped_fields694[4] - write(pp, format_int(pp, field698)) + field690 = unwrapped_fields686[4] + write(pp, format_int(pp, field690)) newline(pp) - field699 = unwrapped_fields694[5] - write(pp, format_int(pp, field699)) + field691 = unwrapped_fields686[5] + write(pp, format_int(pp, field691)) newline(pp) - field700 = unwrapped_fields694[6] - write(pp, format_int(pp, field700)) - field701 = unwrapped_fields694[7] - if !isnothing(field701) + field692 = unwrapped_fields686[6] + write(pp, format_int(pp, field692)) + field693 = unwrapped_fields686[7] + if !isnothing(field693) newline(pp) - opt_val702 = field701 - write(pp, format_int(pp, opt_val702)) + opt_val694 = field693 + write(pp, format_int(pp, opt_val694)) end dedent!(pp) write(pp, ")") @@ -868,32 +859,32 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) - function _t1332(_dollar_dollar) + function _t1316(_dollar_dollar) if _dollar_dollar - _t1333 = () + _t1317 = () else - _t1333 = nothing + _t1317 = nothing end - return _t1333 + return _t1317 end - _t1334 = _t1332(msg) - deconstruct_result706 = _t1334 - if !isnothing(deconstruct_result706) - unwrapped707 = deconstruct_result706 + _t1318 = _t1316(msg) + deconstruct_result698 = _t1318 + if !isnothing(deconstruct_result698) + unwrapped699 = deconstruct_result698 write(pp, "true") else - function _t1335(_dollar_dollar) + function _t1319(_dollar_dollar) if !_dollar_dollar - _t1336 = () + _t1320 = () else - _t1336 = nothing + _t1320 = nothing end - return _t1336 + return _t1320 end - _t1337 = _t1335(msg) - deconstruct_result704 = _t1337 - if !isnothing(deconstruct_result704) - unwrapped705 = deconstruct_result704 + _t1321 = _t1319(msg) + deconstruct_result696 = _t1321 + if !isnothing(deconstruct_result696) + unwrapped697 = deconstruct_result696 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -903,28 +894,28 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat712 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat712) - write(pp, flat712) + flat704 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat704) + write(pp, flat704) return nothing else - function _t1338(_dollar_dollar) + function _t1322(_dollar_dollar) return _dollar_dollar.fragments end - _t1339 = _t1338(msg) - fields708 = _t1339 - unwrapped_fields709 = fields708 + _t1323 = _t1322(msg) + fields700 = _t1323 + unwrapped_fields701 = fields700 write(pp, "(") write(pp, "sync") indent_sexp!(pp) - if !isempty(unwrapped_fields709) + if !isempty(unwrapped_fields701) newline(pp) - for (i1340, elem710) in enumerate(unwrapped_fields709) - i711 = i1340 - 1 - if (i711 > 0) + for (i1324, elem702) in enumerate(unwrapped_fields701) + i703 = i1324 - 1 + if (i703 > 0) newline(pp) end - pretty_fragment_id(pp, elem710) + pretty_fragment_id(pp, elem702) end end dedent!(pp) @@ -934,59 +925,59 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat715 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat715) - write(pp, flat715) + flat707 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat707) + write(pp, flat707) return nothing else - function _t1341(_dollar_dollar) + function _t1325(_dollar_dollar) return fragment_id_to_string(pp, _dollar_dollar) end - _t1342 = _t1341(msg) - fields713 = _t1342 - unwrapped_fields714 = fields713 + _t1326 = _t1325(msg) + fields705 = _t1326 + unwrapped_fields706 = fields705 write(pp, ":") - write(pp, unwrapped_fields714) + write(pp, unwrapped_fields706) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat722 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat722) - write(pp, flat722) + flat714 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat714) + write(pp, flat714) return nothing else - function _t1343(_dollar_dollar) + function _t1327(_dollar_dollar) if !isempty(_dollar_dollar.writes) - _t1344 = _dollar_dollar.writes + _t1328 = _dollar_dollar.writes else - _t1344 = nothing + _t1328 = nothing end if !isempty(_dollar_dollar.reads) - _t1345 = _dollar_dollar.reads + _t1329 = _dollar_dollar.reads else - _t1345 = nothing + _t1329 = nothing end - return (_t1344, _t1345,) + return (_t1328, _t1329,) end - _t1346 = _t1343(msg) - fields716 = _t1346 - unwrapped_fields717 = fields716 + _t1330 = _t1327(msg) + fields708 = _t1330 + unwrapped_fields709 = fields708 write(pp, "(") write(pp, "epoch") indent_sexp!(pp) - field718 = unwrapped_fields717[1] - if !isnothing(field718) + field710 = unwrapped_fields709[1] + if !isnothing(field710) newline(pp) - opt_val719 = field718 - pretty_epoch_writes(pp, opt_val719) + opt_val711 = field710 + pretty_epoch_writes(pp, opt_val711) end - field720 = unwrapped_fields717[2] - if !isnothing(field720) + field712 = unwrapped_fields709[2] + if !isnothing(field712) newline(pp) - opt_val721 = field720 - pretty_epoch_reads(pp, opt_val721) + opt_val713 = field712 + pretty_epoch_reads(pp, opt_val713) end dedent!(pp) write(pp, ")") @@ -995,23 +986,23 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat726 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat726) - write(pp, flat726) + flat718 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat718) + write(pp, flat718) return nothing else - fields723 = msg + fields715 = msg write(pp, "(") write(pp, "writes") indent_sexp!(pp) - if !isempty(fields723) + if !isempty(fields715) newline(pp) - for (i1347, elem724) in enumerate(fields723) - i725 = i1347 - 1 - if (i725 > 0) + for (i1331, elem716) in enumerate(fields715) + i717 = i1331 - 1 + if (i717 > 0) newline(pp) end - pretty_write(pp, elem724) + pretty_write(pp, elem716) end end dedent!(pp) @@ -1021,66 +1012,66 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat735 = try_flat(pp, msg, pretty_write) - if !isnothing(flat735) - write(pp, flat735) + flat727 = try_flat(pp, msg, pretty_write) + if !isnothing(flat727) + write(pp, flat727) return nothing else - function _t1348(_dollar_dollar) + function _t1332(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1349 = _get_oneof_field(_dollar_dollar, :define) + _t1333 = _get_oneof_field(_dollar_dollar, :define) else - _t1349 = nothing + _t1333 = nothing end - return _t1349 + return _t1333 end - _t1350 = _t1348(msg) - deconstruct_result733 = _t1350 - if !isnothing(deconstruct_result733) - unwrapped734 = deconstruct_result733 - pretty_define(pp, unwrapped734) + _t1334 = _t1332(msg) + deconstruct_result725 = _t1334 + if !isnothing(deconstruct_result725) + unwrapped726 = deconstruct_result725 + pretty_define(pp, unwrapped726) else - function _t1351(_dollar_dollar) + function _t1335(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1352 = _get_oneof_field(_dollar_dollar, :undefine) + _t1336 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1352 = nothing + _t1336 = nothing end - return _t1352 + return _t1336 end - _t1353 = _t1351(msg) - deconstruct_result731 = _t1353 - if !isnothing(deconstruct_result731) - unwrapped732 = deconstruct_result731 - pretty_undefine(pp, unwrapped732) + _t1337 = _t1335(msg) + deconstruct_result723 = _t1337 + if !isnothing(deconstruct_result723) + unwrapped724 = deconstruct_result723 + pretty_undefine(pp, unwrapped724) else - function _t1354(_dollar_dollar) + function _t1338(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1355 = _get_oneof_field(_dollar_dollar, :context) + _t1339 = _get_oneof_field(_dollar_dollar, :context) else - _t1355 = nothing + _t1339 = nothing end - return _t1355 + return _t1339 end - _t1356 = _t1354(msg) - deconstruct_result729 = _t1356 - if !isnothing(deconstruct_result729) - unwrapped730 = deconstruct_result729 - pretty_context(pp, unwrapped730) + _t1340 = _t1338(msg) + deconstruct_result721 = _t1340 + if !isnothing(deconstruct_result721) + unwrapped722 = deconstruct_result721 + pretty_context(pp, unwrapped722) else - function _t1357(_dollar_dollar) + function _t1341(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1358 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1342 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1358 = nothing + _t1342 = nothing end - return _t1358 + return _t1342 end - _t1359 = _t1357(msg) - deconstruct_result727 = _t1359 - if !isnothing(deconstruct_result727) - unwrapped728 = deconstruct_result727 - pretty_snapshot(pp, unwrapped728) + _t1343 = _t1341(msg) + deconstruct_result719 = _t1343 + if !isnothing(deconstruct_result719) + unwrapped720 = deconstruct_result719 + pretty_snapshot(pp, unwrapped720) else throw(ParseError("No matching rule for write")) end @@ -1092,22 +1083,22 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat738 = try_flat(pp, msg, pretty_define) - if !isnothing(flat738) - write(pp, flat738) + flat730 = try_flat(pp, msg, pretty_define) + if !isnothing(flat730) + write(pp, flat730) return nothing else - function _t1360(_dollar_dollar) + function _t1344(_dollar_dollar) return _dollar_dollar.fragment end - _t1361 = _t1360(msg) - fields736 = _t1361 - unwrapped_fields737 = fields736 + _t1345 = _t1344(msg) + fields728 = _t1345 + unwrapped_fields729 = fields728 write(pp, "(") write(pp, "define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields737) + pretty_fragment(pp, unwrapped_fields729) dedent!(pp) write(pp, ")") end @@ -1115,33 +1106,33 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat745 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat745) - write(pp, flat745) + flat737 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat737) + write(pp, flat737) return nothing else - function _t1362(_dollar_dollar) + function _t1346(_dollar_dollar) start_pretty_fragment(pp, _dollar_dollar) return (_dollar_dollar.id, _dollar_dollar.declarations,) end - _t1363 = _t1362(msg) - fields739 = _t1363 - unwrapped_fields740 = fields739 + _t1347 = _t1346(msg) + fields731 = _t1347 + unwrapped_fields732 = fields731 write(pp, "(") write(pp, "fragment") indent_sexp!(pp) newline(pp) - field741 = unwrapped_fields740[1] - pretty_new_fragment_id(pp, field741) - field742 = unwrapped_fields740[2] - if !isempty(field742) + field733 = unwrapped_fields732[1] + pretty_new_fragment_id(pp, field733) + field734 = unwrapped_fields732[2] + if !isempty(field734) newline(pp) - for (i1364, elem743) in enumerate(field742) - i744 = i1364 - 1 - if (i744 > 0) + for (i1348, elem735) in enumerate(field734) + i736 = i1348 - 1 + if (i736 > 0) newline(pp) end - pretty_declaration(pp, elem743) + pretty_declaration(pp, elem735) end end dedent!(pp) @@ -1151,78 +1142,78 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat747 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat747) - write(pp, flat747) + flat739 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat739) + write(pp, flat739) return nothing else - fields746 = msg - pretty_fragment_id(pp, fields746) + fields738 = msg + pretty_fragment_id(pp, fields738) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat756 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat756) - write(pp, flat756) + flat748 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat748) + write(pp, flat748) return nothing else - function _t1365(_dollar_dollar) + function _t1349(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1366 = _get_oneof_field(_dollar_dollar, :def) + _t1350 = _get_oneof_field(_dollar_dollar, :def) else - _t1366 = nothing + _t1350 = nothing end - return _t1366 + return _t1350 end - _t1367 = _t1365(msg) - deconstruct_result754 = _t1367 - if !isnothing(deconstruct_result754) - unwrapped755 = deconstruct_result754 - pretty_def(pp, unwrapped755) + _t1351 = _t1349(msg) + deconstruct_result746 = _t1351 + if !isnothing(deconstruct_result746) + unwrapped747 = deconstruct_result746 + pretty_def(pp, unwrapped747) else - function _t1368(_dollar_dollar) + function _t1352(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1369 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1353 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1369 = nothing + _t1353 = nothing end - return _t1369 + return _t1353 end - _t1370 = _t1368(msg) - deconstruct_result752 = _t1370 - if !isnothing(deconstruct_result752) - unwrapped753 = deconstruct_result752 - pretty_algorithm(pp, unwrapped753) + _t1354 = _t1352(msg) + deconstruct_result744 = _t1354 + if !isnothing(deconstruct_result744) + unwrapped745 = deconstruct_result744 + pretty_algorithm(pp, unwrapped745) else - function _t1371(_dollar_dollar) + function _t1355(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1372 = _get_oneof_field(_dollar_dollar, :constraint) + _t1356 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1372 = nothing + _t1356 = nothing end - return _t1372 + return _t1356 end - _t1373 = _t1371(msg) - deconstruct_result750 = _t1373 - if !isnothing(deconstruct_result750) - unwrapped751 = deconstruct_result750 - pretty_constraint(pp, unwrapped751) + _t1357 = _t1355(msg) + deconstruct_result742 = _t1357 + if !isnothing(deconstruct_result742) + unwrapped743 = deconstruct_result742 + pretty_constraint(pp, unwrapped743) else - function _t1374(_dollar_dollar) + function _t1358(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1375 = _get_oneof_field(_dollar_dollar, :data) + _t1359 = _get_oneof_field(_dollar_dollar, :data) else - _t1375 = nothing + _t1359 = nothing end - return _t1375 + return _t1359 end - _t1376 = _t1374(msg) - deconstruct_result748 = _t1376 - if !isnothing(deconstruct_result748) - unwrapped749 = deconstruct_result748 - pretty_data(pp, unwrapped749) + _t1360 = _t1358(msg) + deconstruct_result740 = _t1360 + if !isnothing(deconstruct_result740) + unwrapped741 = deconstruct_result740 + pretty_data(pp, unwrapped741) else throw(ParseError("No matching rule for declaration")) end @@ -1234,36 +1225,36 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat763 = try_flat(pp, msg, pretty_def) - if !isnothing(flat763) - write(pp, flat763) + flat755 = try_flat(pp, msg, pretty_def) + if !isnothing(flat755) + write(pp, flat755) return nothing else - function _t1377(_dollar_dollar) + function _t1361(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1378 = _dollar_dollar.attrs + _t1362 = _dollar_dollar.attrs else - _t1378 = nothing + _t1362 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1378,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1362,) end - _t1379 = _t1377(msg) - fields757 = _t1379 - unwrapped_fields758 = fields757 + _t1363 = _t1361(msg) + fields749 = _t1363 + unwrapped_fields750 = fields749 write(pp, "(") write(pp, "def") indent_sexp!(pp) newline(pp) - field759 = unwrapped_fields758[1] - pretty_relation_id(pp, field759) + field751 = unwrapped_fields750[1] + pretty_relation_id(pp, field751) newline(pp) - field760 = unwrapped_fields758[2] - pretty_abstraction(pp, field760) - field761 = unwrapped_fields758[3] - if !isnothing(field761) + field752 = unwrapped_fields750[2] + pretty_abstraction(pp, field752) + field753 = unwrapped_fields750[3] + if !isnothing(field753) newline(pp) - opt_val762 = field761 - pretty_attrs(pp, opt_val762) + opt_val754 = field753 + pretty_attrs(pp, opt_val754) end dedent!(pp) write(pp, ")") @@ -1272,36 +1263,36 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat768 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat768) - write(pp, flat768) + flat760 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat760) + write(pp, flat760) return nothing else - function _t1380(_dollar_dollar) + function _t1364(_dollar_dollar) if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1382 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1381 = _t1382 + _t1366 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1365 = _t1366 else - _t1381 = nothing + _t1365 = nothing end - return _t1381 + return _t1365 end - _t1383 = _t1380(msg) - deconstruct_result766 = _t1383 - if !isnothing(deconstruct_result766) - unwrapped767 = deconstruct_result766 + _t1367 = _t1364(msg) + deconstruct_result758 = _t1367 + if !isnothing(deconstruct_result758) + unwrapped759 = deconstruct_result758 write(pp, ":") - write(pp, unwrapped767) + write(pp, unwrapped759) else - function _t1384(_dollar_dollar) - _t1385 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - return _t1385 + function _t1368(_dollar_dollar) + _t1369 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + return _t1369 end - _t1386 = _t1384(msg) - deconstruct_result764 = _t1386 - if !isnothing(deconstruct_result764) - unwrapped765 = deconstruct_result764 - write(pp, format_uint128(pp, unwrapped765)) + _t1370 = _t1368(msg) + deconstruct_result756 = _t1370 + if !isnothing(deconstruct_result756) + unwrapped757 = deconstruct_result756 + write(pp, format_uint128(pp, unwrapped757)) else throw(ParseError("No matching rule for relation_id")) end @@ -1311,25 +1302,25 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat773 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat773) - write(pp, flat773) + flat765 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat765) + write(pp, flat765) return nothing else - function _t1387(_dollar_dollar) - _t1388 = deconstruct_bindings(pp, _dollar_dollar) - return (_t1388, _dollar_dollar.value,) + function _t1371(_dollar_dollar) + _t1372 = deconstruct_bindings(pp, _dollar_dollar) + return (_t1372, _dollar_dollar.value,) end - _t1389 = _t1387(msg) - fields769 = _t1389 - unwrapped_fields770 = fields769 + _t1373 = _t1371(msg) + fields761 = _t1373 + unwrapped_fields762 = fields761 write(pp, "(") indent!(pp) - field771 = unwrapped_fields770[1] - pretty_bindings(pp, field771) + field763 = unwrapped_fields762[1] + pretty_bindings(pp, field763) newline(pp) - field772 = unwrapped_fields770[2] - pretty_formula(pp, field772) + field764 = unwrapped_fields762[2] + pretty_formula(pp, field764) dedent!(pp) write(pp, ")") end @@ -1337,37 +1328,37 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat781 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat781) - write(pp, flat781) + flat773 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat773) + write(pp, flat773) return nothing else - function _t1390(_dollar_dollar) + function _t1374(_dollar_dollar) if !isempty(_dollar_dollar[2]) - _t1391 = _dollar_dollar[2] + _t1375 = _dollar_dollar[2] else - _t1391 = nothing + _t1375 = nothing end - return (_dollar_dollar[1], _t1391,) + return (_dollar_dollar[1], _t1375,) end - _t1392 = _t1390(msg) - fields774 = _t1392 - unwrapped_fields775 = fields774 + _t1376 = _t1374(msg) + fields766 = _t1376 + unwrapped_fields767 = fields766 write(pp, "[") indent!(pp) - field776 = unwrapped_fields775[1] - for (i1393, elem777) in enumerate(field776) - i778 = i1393 - 1 - if (i778 > 0) + field768 = unwrapped_fields767[1] + for (i1377, elem769) in enumerate(field768) + i770 = i1377 - 1 + if (i770 > 0) newline(pp) end - pretty_binding(pp, elem777) + pretty_binding(pp, elem769) end - field779 = unwrapped_fields775[2] - if !isnothing(field779) + field771 = unwrapped_fields767[2] + if !isnothing(field771) newline(pp) - opt_val780 = field779 - pretty_value_bindings(pp, opt_val780) + opt_val772 = field771 + pretty_value_bindings(pp, opt_val772) end dedent!(pp) write(pp, "]") @@ -1376,185 +1367,185 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat786 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat786) - write(pp, flat786) + flat778 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat778) + write(pp, flat778) return nothing else - function _t1394(_dollar_dollar) + function _t1378(_dollar_dollar) return (_dollar_dollar.var.name, _dollar_dollar.var"#type",) end - _t1395 = _t1394(msg) - fields782 = _t1395 - unwrapped_fields783 = fields782 - field784 = unwrapped_fields783[1] - write(pp, field784) + _t1379 = _t1378(msg) + fields774 = _t1379 + unwrapped_fields775 = fields774 + field776 = unwrapped_fields775[1] + write(pp, field776) write(pp, "::") - field785 = unwrapped_fields783[2] - pretty_type(pp, field785) + field777 = unwrapped_fields775[2] + pretty_type(pp, field777) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat809 = try_flat(pp, msg, pretty_type) - if !isnothing(flat809) - write(pp, flat809) + flat801 = try_flat(pp, msg, pretty_type) + if !isnothing(flat801) + write(pp, flat801) return nothing else - function _t1396(_dollar_dollar) + function _t1380(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1397 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1381 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1397 = nothing + _t1381 = nothing end - return _t1397 + return _t1381 end - _t1398 = _t1396(msg) - deconstruct_result807 = _t1398 - if !isnothing(deconstruct_result807) - unwrapped808 = deconstruct_result807 - pretty_unspecified_type(pp, unwrapped808) + _t1382 = _t1380(msg) + deconstruct_result799 = _t1382 + if !isnothing(deconstruct_result799) + unwrapped800 = deconstruct_result799 + pretty_unspecified_type(pp, unwrapped800) else - function _t1399(_dollar_dollar) + function _t1383(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1400 = _get_oneof_field(_dollar_dollar, :string_type) + _t1384 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1400 = nothing + _t1384 = nothing end - return _t1400 + return _t1384 end - _t1401 = _t1399(msg) - deconstruct_result805 = _t1401 - if !isnothing(deconstruct_result805) - unwrapped806 = deconstruct_result805 - pretty_string_type(pp, unwrapped806) + _t1385 = _t1383(msg) + deconstruct_result797 = _t1385 + if !isnothing(deconstruct_result797) + unwrapped798 = deconstruct_result797 + pretty_string_type(pp, unwrapped798) else - function _t1402(_dollar_dollar) + function _t1386(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1403 = _get_oneof_field(_dollar_dollar, :int_type) + _t1387 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1403 = nothing + _t1387 = nothing end - return _t1403 + return _t1387 end - _t1404 = _t1402(msg) - deconstruct_result803 = _t1404 - if !isnothing(deconstruct_result803) - unwrapped804 = deconstruct_result803 - pretty_int_type(pp, unwrapped804) + _t1388 = _t1386(msg) + deconstruct_result795 = _t1388 + if !isnothing(deconstruct_result795) + unwrapped796 = deconstruct_result795 + pretty_int_type(pp, unwrapped796) else - function _t1405(_dollar_dollar) + function _t1389(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1406 = _get_oneof_field(_dollar_dollar, :float_type) + _t1390 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1406 = nothing + _t1390 = nothing end - return _t1406 + return _t1390 end - _t1407 = _t1405(msg) - deconstruct_result801 = _t1407 - if !isnothing(deconstruct_result801) - unwrapped802 = deconstruct_result801 - pretty_float_type(pp, unwrapped802) + _t1391 = _t1389(msg) + deconstruct_result793 = _t1391 + if !isnothing(deconstruct_result793) + unwrapped794 = deconstruct_result793 + pretty_float_type(pp, unwrapped794) else - function _t1408(_dollar_dollar) + function _t1392(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1409 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1393 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1409 = nothing + _t1393 = nothing end - return _t1409 + return _t1393 end - _t1410 = _t1408(msg) - deconstruct_result799 = _t1410 - if !isnothing(deconstruct_result799) - unwrapped800 = deconstruct_result799 - pretty_uint128_type(pp, unwrapped800) + _t1394 = _t1392(msg) + deconstruct_result791 = _t1394 + if !isnothing(deconstruct_result791) + unwrapped792 = deconstruct_result791 + pretty_uint128_type(pp, unwrapped792) else - function _t1411(_dollar_dollar) + function _t1395(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1412 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1396 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1412 = nothing + _t1396 = nothing end - return _t1412 + return _t1396 end - _t1413 = _t1411(msg) - deconstruct_result797 = _t1413 - if !isnothing(deconstruct_result797) - unwrapped798 = deconstruct_result797 - pretty_int128_type(pp, unwrapped798) + _t1397 = _t1395(msg) + deconstruct_result789 = _t1397 + if !isnothing(deconstruct_result789) + unwrapped790 = deconstruct_result789 + pretty_int128_type(pp, unwrapped790) else - function _t1414(_dollar_dollar) + function _t1398(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1415 = _get_oneof_field(_dollar_dollar, :date_type) + _t1399 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1415 = nothing + _t1399 = nothing end - return _t1415 + return _t1399 end - _t1416 = _t1414(msg) - deconstruct_result795 = _t1416 - if !isnothing(deconstruct_result795) - unwrapped796 = deconstruct_result795 - pretty_date_type(pp, unwrapped796) + _t1400 = _t1398(msg) + deconstruct_result787 = _t1400 + if !isnothing(deconstruct_result787) + unwrapped788 = deconstruct_result787 + pretty_date_type(pp, unwrapped788) else - function _t1417(_dollar_dollar) + function _t1401(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1418 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1402 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1418 = nothing + _t1402 = nothing end - return _t1418 + return _t1402 end - _t1419 = _t1417(msg) - deconstruct_result793 = _t1419 - if !isnothing(deconstruct_result793) - unwrapped794 = deconstruct_result793 - pretty_datetime_type(pp, unwrapped794) + _t1403 = _t1401(msg) + deconstruct_result785 = _t1403 + if !isnothing(deconstruct_result785) + unwrapped786 = deconstruct_result785 + pretty_datetime_type(pp, unwrapped786) else - function _t1420(_dollar_dollar) + function _t1404(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1421 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1405 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1421 = nothing + _t1405 = nothing end - return _t1421 + return _t1405 end - _t1422 = _t1420(msg) - deconstruct_result791 = _t1422 - if !isnothing(deconstruct_result791) - unwrapped792 = deconstruct_result791 - pretty_missing_type(pp, unwrapped792) + _t1406 = _t1404(msg) + deconstruct_result783 = _t1406 + if !isnothing(deconstruct_result783) + unwrapped784 = deconstruct_result783 + pretty_missing_type(pp, unwrapped784) else - function _t1423(_dollar_dollar) + function _t1407(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1424 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1408 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1424 = nothing + _t1408 = nothing end - return _t1424 + return _t1408 end - _t1425 = _t1423(msg) - deconstruct_result789 = _t1425 - if !isnothing(deconstruct_result789) - unwrapped790 = deconstruct_result789 - pretty_decimal_type(pp, unwrapped790) + _t1409 = _t1407(msg) + deconstruct_result781 = _t1409 + if !isnothing(deconstruct_result781) + unwrapped782 = deconstruct_result781 + pretty_decimal_type(pp, unwrapped782) else - function _t1426(_dollar_dollar) + function _t1410(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1427 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1411 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1427 = nothing + _t1411 = nothing end - return _t1427 + return _t1411 end - _t1428 = _t1426(msg) - deconstruct_result787 = _t1428 - if !isnothing(deconstruct_result787) - unwrapped788 = deconstruct_result787 - pretty_boolean_type(pp, unwrapped788) + _t1412 = _t1410(msg) + deconstruct_result779 = _t1412 + if !isnothing(deconstruct_result779) + unwrapped780 = deconstruct_result779 + pretty_boolean_type(pp, unwrapped780) else throw(ParseError("No matching rule for type")) end @@ -1573,80 +1564,80 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields810 = msg + fields802 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields811 = msg + fields803 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields812 = msg + fields804 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields813 = msg + fields805 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields814 = msg + fields806 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields815 = msg + fields807 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields816 = msg + fields808 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields817 = msg + fields809 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields818 = msg + fields810 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat823 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat823) - write(pp, flat823) + flat815 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat815) + write(pp, flat815) return nothing else - function _t1429(_dollar_dollar) + function _t1413(_dollar_dollar) return (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) end - _t1430 = _t1429(msg) - fields819 = _t1430 - unwrapped_fields820 = fields819 + _t1414 = _t1413(msg) + fields811 = _t1414 + unwrapped_fields812 = fields811 write(pp, "(") write(pp, "DECIMAL") indent_sexp!(pp) newline(pp) - field821 = unwrapped_fields820[1] - write(pp, format_int(pp, field821)) + field813 = unwrapped_fields812[1] + write(pp, format_int(pp, field813)) newline(pp) - field822 = unwrapped_fields820[2] - write(pp, format_int(pp, field822)) + field814 = unwrapped_fields812[2] + write(pp, format_int(pp, field814)) dedent!(pp) write(pp, ")") end @@ -1654,27 +1645,27 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields824 = msg + fields816 = msg write(pp, "BOOLEAN") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat828 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat828) - write(pp, flat828) + flat820 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat820) + write(pp, flat820) return nothing else - fields825 = msg + fields817 = msg write(pp, "|") - if !isempty(fields825) + if !isempty(fields817) write(pp, " ") - for (i1431, elem826) in enumerate(fields825) - i827 = i1431 - 1 - if (i827 > 0) + for (i1415, elem818) in enumerate(fields817) + i819 = i1415 - 1 + if (i819 > 0) newline(pp) end - pretty_binding(pp, elem826) + pretty_binding(pp, elem818) end end end @@ -1682,192 +1673,192 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat855 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat855) - write(pp, flat855) + flat847 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat847) + write(pp, flat847) return nothing else - function _t1432(_dollar_dollar) + function _t1416(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1433 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1417 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1433 = nothing + _t1417 = nothing end - return _t1433 + return _t1417 end - _t1434 = _t1432(msg) - deconstruct_result853 = _t1434 - if !isnothing(deconstruct_result853) - unwrapped854 = deconstruct_result853 - pretty_true(pp, unwrapped854) + _t1418 = _t1416(msg) + deconstruct_result845 = _t1418 + if !isnothing(deconstruct_result845) + unwrapped846 = deconstruct_result845 + pretty_true(pp, unwrapped846) else - function _t1435(_dollar_dollar) + function _t1419(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1436 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1420 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1436 = nothing + _t1420 = nothing end - return _t1436 + return _t1420 end - _t1437 = _t1435(msg) - deconstruct_result851 = _t1437 - if !isnothing(deconstruct_result851) - unwrapped852 = deconstruct_result851 - pretty_false(pp, unwrapped852) + _t1421 = _t1419(msg) + deconstruct_result843 = _t1421 + if !isnothing(deconstruct_result843) + unwrapped844 = deconstruct_result843 + pretty_false(pp, unwrapped844) else - function _t1438(_dollar_dollar) + function _t1422(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1439 = _get_oneof_field(_dollar_dollar, :exists) + _t1423 = _get_oneof_field(_dollar_dollar, :exists) else - _t1439 = nothing + _t1423 = nothing end - return _t1439 + return _t1423 end - _t1440 = _t1438(msg) - deconstruct_result849 = _t1440 - if !isnothing(deconstruct_result849) - unwrapped850 = deconstruct_result849 - pretty_exists(pp, unwrapped850) + _t1424 = _t1422(msg) + deconstruct_result841 = _t1424 + if !isnothing(deconstruct_result841) + unwrapped842 = deconstruct_result841 + pretty_exists(pp, unwrapped842) else - function _t1441(_dollar_dollar) + function _t1425(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1442 = _get_oneof_field(_dollar_dollar, :reduce) + _t1426 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1442 = nothing + _t1426 = nothing end - return _t1442 + return _t1426 end - _t1443 = _t1441(msg) - deconstruct_result847 = _t1443 - if !isnothing(deconstruct_result847) - unwrapped848 = deconstruct_result847 - pretty_reduce(pp, unwrapped848) + _t1427 = _t1425(msg) + deconstruct_result839 = _t1427 + if !isnothing(deconstruct_result839) + unwrapped840 = deconstruct_result839 + pretty_reduce(pp, unwrapped840) else - function _t1444(_dollar_dollar) + function _t1428(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1445 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1429 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1445 = nothing + _t1429 = nothing end - return _t1445 + return _t1429 end - _t1446 = _t1444(msg) - deconstruct_result845 = _t1446 - if !isnothing(deconstruct_result845) - unwrapped846 = deconstruct_result845 - pretty_conjunction(pp, unwrapped846) + _t1430 = _t1428(msg) + deconstruct_result837 = _t1430 + if !isnothing(deconstruct_result837) + unwrapped838 = deconstruct_result837 + pretty_conjunction(pp, unwrapped838) else - function _t1447(_dollar_dollar) + function _t1431(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1448 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1432 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1448 = nothing + _t1432 = nothing end - return _t1448 + return _t1432 end - _t1449 = _t1447(msg) - deconstruct_result843 = _t1449 - if !isnothing(deconstruct_result843) - unwrapped844 = deconstruct_result843 - pretty_disjunction(pp, unwrapped844) + _t1433 = _t1431(msg) + deconstruct_result835 = _t1433 + if !isnothing(deconstruct_result835) + unwrapped836 = deconstruct_result835 + pretty_disjunction(pp, unwrapped836) else - function _t1450(_dollar_dollar) + function _t1434(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1451 = _get_oneof_field(_dollar_dollar, :not) + _t1435 = _get_oneof_field(_dollar_dollar, :not) else - _t1451 = nothing + _t1435 = nothing end - return _t1451 + return _t1435 end - _t1452 = _t1450(msg) - deconstruct_result841 = _t1452 - if !isnothing(deconstruct_result841) - unwrapped842 = deconstruct_result841 - pretty_not(pp, unwrapped842) + _t1436 = _t1434(msg) + deconstruct_result833 = _t1436 + if !isnothing(deconstruct_result833) + unwrapped834 = deconstruct_result833 + pretty_not(pp, unwrapped834) else - function _t1453(_dollar_dollar) + function _t1437(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1454 = _get_oneof_field(_dollar_dollar, :ffi) + _t1438 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1454 = nothing + _t1438 = nothing end - return _t1454 + return _t1438 end - _t1455 = _t1453(msg) - deconstruct_result839 = _t1455 - if !isnothing(deconstruct_result839) - unwrapped840 = deconstruct_result839 - pretty_ffi(pp, unwrapped840) + _t1439 = _t1437(msg) + deconstruct_result831 = _t1439 + if !isnothing(deconstruct_result831) + unwrapped832 = deconstruct_result831 + pretty_ffi(pp, unwrapped832) else - function _t1456(_dollar_dollar) + function _t1440(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1457 = _get_oneof_field(_dollar_dollar, :atom) + _t1441 = _get_oneof_field(_dollar_dollar, :atom) else - _t1457 = nothing + _t1441 = nothing end - return _t1457 + return _t1441 end - _t1458 = _t1456(msg) - deconstruct_result837 = _t1458 - if !isnothing(deconstruct_result837) - unwrapped838 = deconstruct_result837 - pretty_atom(pp, unwrapped838) + _t1442 = _t1440(msg) + deconstruct_result829 = _t1442 + if !isnothing(deconstruct_result829) + unwrapped830 = deconstruct_result829 + pretty_atom(pp, unwrapped830) else - function _t1459(_dollar_dollar) + function _t1443(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1460 = _get_oneof_field(_dollar_dollar, :pragma) + _t1444 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1460 = nothing + _t1444 = nothing end - return _t1460 + return _t1444 end - _t1461 = _t1459(msg) - deconstruct_result835 = _t1461 - if !isnothing(deconstruct_result835) - unwrapped836 = deconstruct_result835 - pretty_pragma(pp, unwrapped836) + _t1445 = _t1443(msg) + deconstruct_result827 = _t1445 + if !isnothing(deconstruct_result827) + unwrapped828 = deconstruct_result827 + pretty_pragma(pp, unwrapped828) else - function _t1462(_dollar_dollar) + function _t1446(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1463 = _get_oneof_field(_dollar_dollar, :primitive) + _t1447 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1463 = nothing + _t1447 = nothing end - return _t1463 + return _t1447 end - _t1464 = _t1462(msg) - deconstruct_result833 = _t1464 - if !isnothing(deconstruct_result833) - unwrapped834 = deconstruct_result833 - pretty_primitive(pp, unwrapped834) + _t1448 = _t1446(msg) + deconstruct_result825 = _t1448 + if !isnothing(deconstruct_result825) + unwrapped826 = deconstruct_result825 + pretty_primitive(pp, unwrapped826) else - function _t1465(_dollar_dollar) + function _t1449(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1466 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1450 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1466 = nothing + _t1450 = nothing end - return _t1466 + return _t1450 end - _t1467 = _t1465(msg) - deconstruct_result831 = _t1467 - if !isnothing(deconstruct_result831) - unwrapped832 = deconstruct_result831 - pretty_rel_atom(pp, unwrapped832) + _t1451 = _t1449(msg) + deconstruct_result823 = _t1451 + if !isnothing(deconstruct_result823) + unwrapped824 = deconstruct_result823 + pretty_rel_atom(pp, unwrapped824) else - function _t1468(_dollar_dollar) + function _t1452(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1469 = _get_oneof_field(_dollar_dollar, :cast) + _t1453 = _get_oneof_field(_dollar_dollar, :cast) else - _t1469 = nothing + _t1453 = nothing end - return _t1469 + return _t1453 end - _t1470 = _t1468(msg) - deconstruct_result829 = _t1470 - if !isnothing(deconstruct_result829) - unwrapped830 = deconstruct_result829 - pretty_cast(pp, unwrapped830) + _t1454 = _t1452(msg) + deconstruct_result821 = _t1454 + if !isnothing(deconstruct_result821) + unwrapped822 = deconstruct_result821 + pretty_cast(pp, unwrapped822) else throw(ParseError("No matching rule for formula")) end @@ -1888,7 +1879,7 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields856 = msg + fields848 = msg write(pp, "(") write(pp, "true") write(pp, ")") @@ -1896,7 +1887,7 @@ function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields857 = msg + fields849 = msg write(pp, "(") write(pp, "false") write(pp, ")") @@ -1904,27 +1895,27 @@ function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat862 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat862) - write(pp, flat862) + flat854 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat854) + write(pp, flat854) return nothing else - function _t1471(_dollar_dollar) - _t1472 = deconstruct_bindings(pp, _dollar_dollar.body) - return (_t1472, _dollar_dollar.body.value,) + function _t1455(_dollar_dollar) + _t1456 = deconstruct_bindings(pp, _dollar_dollar.body) + return (_t1456, _dollar_dollar.body.value,) end - _t1473 = _t1471(msg) - fields858 = _t1473 - unwrapped_fields859 = fields858 + _t1457 = _t1455(msg) + fields850 = _t1457 + unwrapped_fields851 = fields850 write(pp, "(") write(pp, "exists") indent_sexp!(pp) newline(pp) - field860 = unwrapped_fields859[1] - pretty_bindings(pp, field860) + field852 = unwrapped_fields851[1] + pretty_bindings(pp, field852) newline(pp) - field861 = unwrapped_fields859[2] - pretty_formula(pp, field861) + field853 = unwrapped_fields851[2] + pretty_formula(pp, field853) dedent!(pp) write(pp, ")") end @@ -1932,29 +1923,29 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat868 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat868) - write(pp, flat868) + flat860 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat860) + write(pp, flat860) return nothing else - function _t1474(_dollar_dollar) + function _t1458(_dollar_dollar) return (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) end - _t1475 = _t1474(msg) - fields863 = _t1475 - unwrapped_fields864 = fields863 + _t1459 = _t1458(msg) + fields855 = _t1459 + unwrapped_fields856 = fields855 write(pp, "(") write(pp, "reduce") indent_sexp!(pp) newline(pp) - field865 = unwrapped_fields864[1] - pretty_abstraction(pp, field865) + field857 = unwrapped_fields856[1] + pretty_abstraction(pp, field857) newline(pp) - field866 = unwrapped_fields864[2] - pretty_abstraction(pp, field866) + field858 = unwrapped_fields856[2] + pretty_abstraction(pp, field858) newline(pp) - field867 = unwrapped_fields864[3] - pretty_terms(pp, field867) + field859 = unwrapped_fields856[3] + pretty_terms(pp, field859) dedent!(pp) write(pp, ")") end @@ -1962,23 +1953,23 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat872 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat872) - write(pp, flat872) + flat864 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat864) + write(pp, flat864) return nothing else - fields869 = msg + fields861 = msg write(pp, "(") write(pp, "terms") indent_sexp!(pp) - if !isempty(fields869) + if !isempty(fields861) newline(pp) - for (i1476, elem870) in enumerate(fields869) - i871 = i1476 - 1 - if (i871 > 0) + for (i1460, elem862) in enumerate(fields861) + i863 = i1460 - 1 + if (i863 > 0) newline(pp) end - pretty_term(pp, elem870) + pretty_term(pp, elem862) end end dedent!(pp) @@ -1988,38 +1979,38 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat877 = try_flat(pp, msg, pretty_term) - if !isnothing(flat877) - write(pp, flat877) + flat869 = try_flat(pp, msg, pretty_term) + if !isnothing(flat869) + write(pp, flat869) return nothing else - function _t1477(_dollar_dollar) + function _t1461(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1478 = _get_oneof_field(_dollar_dollar, :var) + _t1462 = _get_oneof_field(_dollar_dollar, :var) else - _t1478 = nothing + _t1462 = nothing end - return _t1478 + return _t1462 end - _t1479 = _t1477(msg) - deconstruct_result875 = _t1479 - if !isnothing(deconstruct_result875) - unwrapped876 = deconstruct_result875 - pretty_var(pp, unwrapped876) + _t1463 = _t1461(msg) + deconstruct_result867 = _t1463 + if !isnothing(deconstruct_result867) + unwrapped868 = deconstruct_result867 + pretty_var(pp, unwrapped868) else - function _t1480(_dollar_dollar) + function _t1464(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1481 = _get_oneof_field(_dollar_dollar, :constant) + _t1465 = _get_oneof_field(_dollar_dollar, :constant) else - _t1481 = nothing + _t1465 = nothing end - return _t1481 + return _t1465 end - _t1482 = _t1480(msg) - deconstruct_result873 = _t1482 - if !isnothing(deconstruct_result873) - unwrapped874 = deconstruct_result873 - pretty_constant(pp, unwrapped874) + _t1466 = _t1464(msg) + deconstruct_result865 = _t1466 + if !isnothing(deconstruct_result865) + unwrapped866 = deconstruct_result865 + pretty_constant(pp, unwrapped866) else throw(ParseError("No matching rule for term")) end @@ -2029,57 +2020,57 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat880 = try_flat(pp, msg, pretty_var) - if !isnothing(flat880) - write(pp, flat880) + flat872 = try_flat(pp, msg, pretty_var) + if !isnothing(flat872) + write(pp, flat872) return nothing else - function _t1483(_dollar_dollar) + function _t1467(_dollar_dollar) return _dollar_dollar.name end - _t1484 = _t1483(msg) - fields878 = _t1484 - unwrapped_fields879 = fields878 - write(pp, unwrapped_fields879) + _t1468 = _t1467(msg) + fields870 = _t1468 + unwrapped_fields871 = fields870 + write(pp, unwrapped_fields871) end return nothing end function pretty_constant(pp::PrettyPrinter, msg::Proto.Value) - flat882 = try_flat(pp, msg, pretty_constant) - if !isnothing(flat882) - write(pp, flat882) + flat874 = try_flat(pp, msg, pretty_constant) + if !isnothing(flat874) + write(pp, flat874) return nothing else - fields881 = msg - pretty_value(pp, fields881) + fields873 = msg + pretty_value(pp, fields873) end return nothing end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat887 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat887) - write(pp, flat887) + flat879 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat879) + write(pp, flat879) return nothing else - function _t1485(_dollar_dollar) + function _t1469(_dollar_dollar) return _dollar_dollar.args end - _t1486 = _t1485(msg) - fields883 = _t1486 - unwrapped_fields884 = fields883 + _t1470 = _t1469(msg) + fields875 = _t1470 + unwrapped_fields876 = fields875 write(pp, "(") write(pp, "and") indent_sexp!(pp) - if !isempty(unwrapped_fields884) + if !isempty(unwrapped_fields876) newline(pp) - for (i1487, elem885) in enumerate(unwrapped_fields884) - i886 = i1487 - 1 - if (i886 > 0) + for (i1471, elem877) in enumerate(unwrapped_fields876) + i878 = i1471 - 1 + if (i878 > 0) newline(pp) end - pretty_formula(pp, elem885) + pretty_formula(pp, elem877) end end dedent!(pp) @@ -2089,28 +2080,28 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat892 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat892) - write(pp, flat892) + flat884 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat884) + write(pp, flat884) return nothing else - function _t1488(_dollar_dollar) + function _t1472(_dollar_dollar) return _dollar_dollar.args end - _t1489 = _t1488(msg) - fields888 = _t1489 - unwrapped_fields889 = fields888 + _t1473 = _t1472(msg) + fields880 = _t1473 + unwrapped_fields881 = fields880 write(pp, "(") write(pp, "or") indent_sexp!(pp) - if !isempty(unwrapped_fields889) + if !isempty(unwrapped_fields881) newline(pp) - for (i1490, elem890) in enumerate(unwrapped_fields889) - i891 = i1490 - 1 - if (i891 > 0) + for (i1474, elem882) in enumerate(unwrapped_fields881) + i883 = i1474 - 1 + if (i883 > 0) newline(pp) end - pretty_formula(pp, elem890) + pretty_formula(pp, elem882) end end dedent!(pp) @@ -2120,22 +2111,22 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat895 = try_flat(pp, msg, pretty_not) - if !isnothing(flat895) - write(pp, flat895) + flat887 = try_flat(pp, msg, pretty_not) + if !isnothing(flat887) + write(pp, flat887) return nothing else - function _t1491(_dollar_dollar) + function _t1475(_dollar_dollar) return _dollar_dollar.arg end - _t1492 = _t1491(msg) - fields893 = _t1492 - unwrapped_fields894 = fields893 + _t1476 = _t1475(msg) + fields885 = _t1476 + unwrapped_fields886 = fields885 write(pp, "(") write(pp, "not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields894) + pretty_formula(pp, unwrapped_fields886) dedent!(pp) write(pp, ")") end @@ -2143,29 +2134,29 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat901 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat901) - write(pp, flat901) + flat893 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat893) + write(pp, flat893) return nothing else - function _t1493(_dollar_dollar) + function _t1477(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) end - _t1494 = _t1493(msg) - fields896 = _t1494 - unwrapped_fields897 = fields896 + _t1478 = _t1477(msg) + fields888 = _t1478 + unwrapped_fields889 = fields888 write(pp, "(") write(pp, "ffi") indent_sexp!(pp) newline(pp) - field898 = unwrapped_fields897[1] - pretty_name(pp, field898) + field890 = unwrapped_fields889[1] + pretty_name(pp, field890) newline(pp) - field899 = unwrapped_fields897[2] - pretty_ffi_args(pp, field899) + field891 = unwrapped_fields889[2] + pretty_ffi_args(pp, field891) newline(pp) - field900 = unwrapped_fields897[3] - pretty_terms(pp, field900) + field892 = unwrapped_fields889[3] + pretty_terms(pp, field892) dedent!(pp) write(pp, ")") end @@ -2173,36 +2164,36 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat903 = try_flat(pp, msg, pretty_name) - if !isnothing(flat903) - write(pp, flat903) + flat895 = try_flat(pp, msg, pretty_name) + if !isnothing(flat895) + write(pp, flat895) return nothing else - fields902 = msg + fields894 = msg write(pp, ":") - write(pp, fields902) + write(pp, fields894) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat907 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat907) - write(pp, flat907) + flat899 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat899) + write(pp, flat899) return nothing else - fields904 = msg + fields896 = msg write(pp, "(") write(pp, "args") indent_sexp!(pp) - if !isempty(fields904) + if !isempty(fields896) newline(pp) - for (i1495, elem905) in enumerate(fields904) - i906 = i1495 - 1 - if (i906 > 0) + for (i1479, elem897) in enumerate(fields896) + i898 = i1479 - 1 + if (i898 > 0) newline(pp) end - pretty_abstraction(pp, elem905) + pretty_abstraction(pp, elem897) end end dedent!(pp) @@ -2212,32 +2203,32 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat914 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat914) - write(pp, flat914) + flat906 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat906) + write(pp, flat906) return nothing else - function _t1496(_dollar_dollar) + function _t1480(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1497 = _t1496(msg) - fields908 = _t1497 - unwrapped_fields909 = fields908 + _t1481 = _t1480(msg) + fields900 = _t1481 + unwrapped_fields901 = fields900 write(pp, "(") write(pp, "atom") indent_sexp!(pp) newline(pp) - field910 = unwrapped_fields909[1] - pretty_relation_id(pp, field910) - field911 = unwrapped_fields909[2] - if !isempty(field911) + field902 = unwrapped_fields901[1] + pretty_relation_id(pp, field902) + field903 = unwrapped_fields901[2] + if !isempty(field903) newline(pp) - for (i1498, elem912) in enumerate(field911) - i913 = i1498 - 1 - if (i913 > 0) + for (i1482, elem904) in enumerate(field903) + i905 = i1482 - 1 + if (i905 > 0) newline(pp) end - pretty_term(pp, elem912) + pretty_term(pp, elem904) end end dedent!(pp) @@ -2247,32 +2238,32 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat921 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat921) - write(pp, flat921) + flat913 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat913) + write(pp, flat913) return nothing else - function _t1499(_dollar_dollar) + function _t1483(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1500 = _t1499(msg) - fields915 = _t1500 - unwrapped_fields916 = fields915 + _t1484 = _t1483(msg) + fields907 = _t1484 + unwrapped_fields908 = fields907 write(pp, "(") write(pp, "pragma") indent_sexp!(pp) newline(pp) - field917 = unwrapped_fields916[1] - pretty_name(pp, field917) - field918 = unwrapped_fields916[2] - if !isempty(field918) + field909 = unwrapped_fields908[1] + pretty_name(pp, field909) + field910 = unwrapped_fields908[2] + if !isempty(field910) newline(pp) - for (i1501, elem919) in enumerate(field918) - i920 = i1501 - 1 - if (i920 > 0) + for (i1485, elem911) in enumerate(field910) + i912 = i1485 - 1 + if (i912 > 0) newline(pp) end - pretty_term(pp, elem919) + pretty_term(pp, elem911) end end dedent!(pp) @@ -2282,149 +2273,149 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat937 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat937) - write(pp, flat937) + flat929 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat929) + write(pp, flat929) return nothing else - function _t1502(_dollar_dollar) + function _t1486(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_eq" - _t1503 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1487 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1503 = nothing + _t1487 = nothing end - return _t1503 + return _t1487 end - _t1504 = _t1502(msg) - guard_result936 = _t1504 - if !isnothing(guard_result936) + _t1488 = _t1486(msg) + guard_result928 = _t1488 + if !isnothing(guard_result928) pretty_eq(pp, msg) else - function _t1505(_dollar_dollar) + function _t1489(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1506 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1490 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1506 = nothing + _t1490 = nothing end - return _t1506 + return _t1490 end - _t1507 = _t1505(msg) - guard_result935 = _t1507 - if !isnothing(guard_result935) + _t1491 = _t1489(msg) + guard_result927 = _t1491 + if !isnothing(guard_result927) pretty_lt(pp, msg) else - function _t1508(_dollar_dollar) + function _t1492(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1509 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1493 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1509 = nothing + _t1493 = nothing end - return _t1509 + return _t1493 end - _t1510 = _t1508(msg) - guard_result934 = _t1510 - if !isnothing(guard_result934) + _t1494 = _t1492(msg) + guard_result926 = _t1494 + if !isnothing(guard_result926) pretty_lt_eq(pp, msg) else - function _t1511(_dollar_dollar) + function _t1495(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1512 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1496 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1512 = nothing + _t1496 = nothing end - return _t1512 + return _t1496 end - _t1513 = _t1511(msg) - guard_result933 = _t1513 - if !isnothing(guard_result933) + _t1497 = _t1495(msg) + guard_result925 = _t1497 + if !isnothing(guard_result925) pretty_gt(pp, msg) else - function _t1514(_dollar_dollar) + function _t1498(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1515 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1499 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1515 = nothing + _t1499 = nothing end - return _t1515 + return _t1499 end - _t1516 = _t1514(msg) - guard_result932 = _t1516 - if !isnothing(guard_result932) + _t1500 = _t1498(msg) + guard_result924 = _t1500 + if !isnothing(guard_result924) pretty_gt_eq(pp, msg) else - function _t1517(_dollar_dollar) + function _t1501(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1518 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1502 = (_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 - _t1518 = nothing + _t1502 = nothing end - return _t1518 + return _t1502 end - _t1519 = _t1517(msg) - guard_result931 = _t1519 - if !isnothing(guard_result931) + _t1503 = _t1501(msg) + guard_result923 = _t1503 + if !isnothing(guard_result923) pretty_add(pp, msg) else - function _t1520(_dollar_dollar) + function _t1504(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1521 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1505 = (_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 - _t1521 = nothing + _t1505 = nothing end - return _t1521 + return _t1505 end - _t1522 = _t1520(msg) - guard_result930 = _t1522 - if !isnothing(guard_result930) + _t1506 = _t1504(msg) + guard_result922 = _t1506 + if !isnothing(guard_result922) pretty_minus(pp, msg) else - function _t1523(_dollar_dollar) + function _t1507(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1524 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1508 = (_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 - _t1524 = nothing + _t1508 = nothing end - return _t1524 + return _t1508 end - _t1525 = _t1523(msg) - guard_result929 = _t1525 - if !isnothing(guard_result929) + _t1509 = _t1507(msg) + guard_result921 = _t1509 + if !isnothing(guard_result921) pretty_multiply(pp, msg) else - function _t1526(_dollar_dollar) + function _t1510(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1527 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1511 = (_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 - _t1527 = nothing + _t1511 = nothing end - return _t1527 + return _t1511 end - _t1528 = _t1526(msg) - guard_result928 = _t1528 - if !isnothing(guard_result928) + _t1512 = _t1510(msg) + guard_result920 = _t1512 + if !isnothing(guard_result920) pretty_divide(pp, msg) else - function _t1529(_dollar_dollar) + function _t1513(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1530 = _t1529(msg) - fields922 = _t1530 - unwrapped_fields923 = fields922 + _t1514 = _t1513(msg) + fields914 = _t1514 + unwrapped_fields915 = fields914 write(pp, "(") write(pp, "primitive") indent_sexp!(pp) newline(pp) - field924 = unwrapped_fields923[1] - pretty_name(pp, field924) - field925 = unwrapped_fields923[2] - if !isempty(field925) + field916 = unwrapped_fields915[1] + pretty_name(pp, field916) + field917 = unwrapped_fields915[2] + if !isempty(field917) newline(pp) - for (i1531, elem926) in enumerate(field925) - i927 = i1531 - 1 - if (i927 > 0) + for (i1515, elem918) in enumerate(field917) + i919 = i1515 - 1 + if (i919 > 0) newline(pp) end - pretty_rel_term(pp, elem926) + pretty_rel_term(pp, elem918) end end dedent!(pp) @@ -2443,31 +2434,31 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat942 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat942) - write(pp, flat942) + flat934 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat934) + write(pp, flat934) return nothing else - function _t1532(_dollar_dollar) + function _t1516(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_eq" - _t1533 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1517 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1533 = nothing + _t1517 = nothing end - return _t1533 + return _t1517 end - _t1534 = _t1532(msg) - fields938 = _t1534 - unwrapped_fields939 = fields938 + _t1518 = _t1516(msg) + fields930 = _t1518 + unwrapped_fields931 = fields930 write(pp, "(") write(pp, "=") indent_sexp!(pp) newline(pp) - field940 = unwrapped_fields939[1] - pretty_term(pp, field940) + field932 = unwrapped_fields931[1] + pretty_term(pp, field932) newline(pp) - field941 = unwrapped_fields939[2] - pretty_term(pp, field941) + field933 = unwrapped_fields931[2] + pretty_term(pp, field933) dedent!(pp) write(pp, ")") end @@ -2475,31 +2466,31 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat947 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat947) - write(pp, flat947) + flat939 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat939) + write(pp, flat939) return nothing else - function _t1535(_dollar_dollar) + function _t1519(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1536 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1520 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1536 = nothing + _t1520 = nothing end - return _t1536 + return _t1520 end - _t1537 = _t1535(msg) - fields943 = _t1537 - unwrapped_fields944 = fields943 + _t1521 = _t1519(msg) + fields935 = _t1521 + unwrapped_fields936 = fields935 write(pp, "(") write(pp, "<") indent_sexp!(pp) newline(pp) - field945 = unwrapped_fields944[1] - pretty_term(pp, field945) + field937 = unwrapped_fields936[1] + pretty_term(pp, field937) newline(pp) - field946 = unwrapped_fields944[2] - pretty_term(pp, field946) + field938 = unwrapped_fields936[2] + pretty_term(pp, field938) dedent!(pp) write(pp, ")") end @@ -2507,31 +2498,31 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat952 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat952) - write(pp, flat952) + flat944 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat944) + write(pp, flat944) return nothing else - function _t1538(_dollar_dollar) + function _t1522(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1539 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1523 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1539 = nothing + _t1523 = nothing end - return _t1539 + return _t1523 end - _t1540 = _t1538(msg) - fields948 = _t1540 - unwrapped_fields949 = fields948 + _t1524 = _t1522(msg) + fields940 = _t1524 + unwrapped_fields941 = fields940 write(pp, "(") write(pp, "<=") indent_sexp!(pp) newline(pp) - field950 = unwrapped_fields949[1] - pretty_term(pp, field950) + field942 = unwrapped_fields941[1] + pretty_term(pp, field942) newline(pp) - field951 = unwrapped_fields949[2] - pretty_term(pp, field951) + field943 = unwrapped_fields941[2] + pretty_term(pp, field943) dedent!(pp) write(pp, ")") end @@ -2539,31 +2530,31 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat957 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat957) - write(pp, flat957) + flat949 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat949) + write(pp, flat949) return nothing else - function _t1541(_dollar_dollar) + function _t1525(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1542 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1526 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1542 = nothing + _t1526 = nothing end - return _t1542 + return _t1526 end - _t1543 = _t1541(msg) - fields953 = _t1543 - unwrapped_fields954 = fields953 + _t1527 = _t1525(msg) + fields945 = _t1527 + unwrapped_fields946 = fields945 write(pp, "(") write(pp, ">") indent_sexp!(pp) newline(pp) - field955 = unwrapped_fields954[1] - pretty_term(pp, field955) + field947 = unwrapped_fields946[1] + pretty_term(pp, field947) newline(pp) - field956 = unwrapped_fields954[2] - pretty_term(pp, field956) + field948 = unwrapped_fields946[2] + pretty_term(pp, field948) dedent!(pp) write(pp, ")") end @@ -2571,31 +2562,31 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat962 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat962) - write(pp, flat962) + flat954 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat954) + write(pp, flat954) return nothing else - function _t1544(_dollar_dollar) + function _t1528(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1545 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1529 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1545 = nothing + _t1529 = nothing end - return _t1545 + return _t1529 end - _t1546 = _t1544(msg) - fields958 = _t1546 - unwrapped_fields959 = fields958 + _t1530 = _t1528(msg) + fields950 = _t1530 + unwrapped_fields951 = fields950 write(pp, "(") write(pp, ">=") indent_sexp!(pp) newline(pp) - field960 = unwrapped_fields959[1] - pretty_term(pp, field960) + field952 = unwrapped_fields951[1] + pretty_term(pp, field952) newline(pp) - field961 = unwrapped_fields959[2] - pretty_term(pp, field961) + field953 = unwrapped_fields951[2] + pretty_term(pp, field953) dedent!(pp) write(pp, ")") end @@ -2603,34 +2594,34 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat968 = try_flat(pp, msg, pretty_add) - if !isnothing(flat968) - write(pp, flat968) + flat960 = try_flat(pp, msg, pretty_add) + if !isnothing(flat960) + write(pp, flat960) return nothing else - function _t1547(_dollar_dollar) + function _t1531(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1548 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1532 = (_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 - _t1548 = nothing + _t1532 = nothing end - return _t1548 + return _t1532 end - _t1549 = _t1547(msg) - fields963 = _t1549 - unwrapped_fields964 = fields963 + _t1533 = _t1531(msg) + fields955 = _t1533 + unwrapped_fields956 = fields955 write(pp, "(") write(pp, "+") indent_sexp!(pp) newline(pp) - field965 = unwrapped_fields964[1] - pretty_term(pp, field965) + field957 = unwrapped_fields956[1] + pretty_term(pp, field957) newline(pp) - field966 = unwrapped_fields964[2] - pretty_term(pp, field966) + field958 = unwrapped_fields956[2] + pretty_term(pp, field958) newline(pp) - field967 = unwrapped_fields964[3] - pretty_term(pp, field967) + field959 = unwrapped_fields956[3] + pretty_term(pp, field959) dedent!(pp) write(pp, ")") end @@ -2638,34 +2629,34 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat974 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat974) - write(pp, flat974) + flat966 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat966) + write(pp, flat966) return nothing else - function _t1550(_dollar_dollar) + function _t1534(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1551 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1535 = (_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 - _t1551 = nothing + _t1535 = nothing end - return _t1551 + return _t1535 end - _t1552 = _t1550(msg) - fields969 = _t1552 - unwrapped_fields970 = fields969 + _t1536 = _t1534(msg) + fields961 = _t1536 + unwrapped_fields962 = fields961 write(pp, "(") write(pp, "-") indent_sexp!(pp) newline(pp) - field971 = unwrapped_fields970[1] - pretty_term(pp, field971) + field963 = unwrapped_fields962[1] + pretty_term(pp, field963) newline(pp) - field972 = unwrapped_fields970[2] - pretty_term(pp, field972) + field964 = unwrapped_fields962[2] + pretty_term(pp, field964) newline(pp) - field973 = unwrapped_fields970[3] - pretty_term(pp, field973) + field965 = unwrapped_fields962[3] + pretty_term(pp, field965) dedent!(pp) write(pp, ")") end @@ -2673,34 +2664,34 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat980 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat980) - write(pp, flat980) + flat972 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat972) + write(pp, flat972) return nothing else - function _t1553(_dollar_dollar) + function _t1537(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1554 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1538 = (_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 - _t1554 = nothing + _t1538 = nothing end - return _t1554 + return _t1538 end - _t1555 = _t1553(msg) - fields975 = _t1555 - unwrapped_fields976 = fields975 + _t1539 = _t1537(msg) + fields967 = _t1539 + unwrapped_fields968 = fields967 write(pp, "(") write(pp, "*") indent_sexp!(pp) newline(pp) - field977 = unwrapped_fields976[1] - pretty_term(pp, field977) + field969 = unwrapped_fields968[1] + pretty_term(pp, field969) newline(pp) - field978 = unwrapped_fields976[2] - pretty_term(pp, field978) + field970 = unwrapped_fields968[2] + pretty_term(pp, field970) newline(pp) - field979 = unwrapped_fields976[3] - pretty_term(pp, field979) + field971 = unwrapped_fields968[3] + pretty_term(pp, field971) dedent!(pp) write(pp, ")") end @@ -2708,34 +2699,34 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat986 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat986) - write(pp, flat986) + flat978 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat978) + write(pp, flat978) return nothing else - function _t1556(_dollar_dollar) + function _t1540(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1557 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1541 = (_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 - _t1557 = nothing + _t1541 = nothing end - return _t1557 + return _t1541 end - _t1558 = _t1556(msg) - fields981 = _t1558 - unwrapped_fields982 = fields981 + _t1542 = _t1540(msg) + fields973 = _t1542 + unwrapped_fields974 = fields973 write(pp, "(") write(pp, "/") indent_sexp!(pp) newline(pp) - field983 = unwrapped_fields982[1] - pretty_term(pp, field983) + field975 = unwrapped_fields974[1] + pretty_term(pp, field975) newline(pp) - field984 = unwrapped_fields982[2] - pretty_term(pp, field984) + field976 = unwrapped_fields974[2] + pretty_term(pp, field976) newline(pp) - field985 = unwrapped_fields982[3] - pretty_term(pp, field985) + field977 = unwrapped_fields974[3] + pretty_term(pp, field977) dedent!(pp) write(pp, ")") end @@ -2743,38 +2734,38 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat991 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat991) - write(pp, flat991) + flat983 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat983) + write(pp, flat983) return nothing else - function _t1559(_dollar_dollar) + function _t1543(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1560 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1544 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1560 = nothing + _t1544 = nothing end - return _t1560 + return _t1544 end - _t1561 = _t1559(msg) - deconstruct_result989 = _t1561 - if !isnothing(deconstruct_result989) - unwrapped990 = deconstruct_result989 - pretty_specialized_value(pp, unwrapped990) + _t1545 = _t1543(msg) + deconstruct_result981 = _t1545 + if !isnothing(deconstruct_result981) + unwrapped982 = deconstruct_result981 + pretty_specialized_value(pp, unwrapped982) else - function _t1562(_dollar_dollar) + function _t1546(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1563 = _get_oneof_field(_dollar_dollar, :term) + _t1547 = _get_oneof_field(_dollar_dollar, :term) else - _t1563 = nothing + _t1547 = nothing end - return _t1563 + return _t1547 end - _t1564 = _t1562(msg) - deconstruct_result987 = _t1564 - if !isnothing(deconstruct_result987) - unwrapped988 = deconstruct_result987 - pretty_term(pp, unwrapped988) + _t1548 = _t1546(msg) + deconstruct_result979 = _t1548 + if !isnothing(deconstruct_result979) + unwrapped980 = deconstruct_result979 + pretty_term(pp, unwrapped980) else throw(ParseError("No matching rule for rel_term")) end @@ -2784,45 +2775,45 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat993 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat993) - write(pp, flat993) + flat985 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat985) + write(pp, flat985) return nothing else - fields992 = msg + fields984 = msg write(pp, "#") - pretty_value(pp, fields992) + pretty_value(pp, fields984) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1000 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1000) - write(pp, flat1000) + flat992 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat992) + write(pp, flat992) return nothing else - function _t1565(_dollar_dollar) + function _t1549(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1566 = _t1565(msg) - fields994 = _t1566 - unwrapped_fields995 = fields994 + _t1550 = _t1549(msg) + fields986 = _t1550 + unwrapped_fields987 = fields986 write(pp, "(") write(pp, "relatom") indent_sexp!(pp) newline(pp) - field996 = unwrapped_fields995[1] - pretty_name(pp, field996) - field997 = unwrapped_fields995[2] - if !isempty(field997) + field988 = unwrapped_fields987[1] + pretty_name(pp, field988) + field989 = unwrapped_fields987[2] + if !isempty(field989) newline(pp) - for (i1567, elem998) in enumerate(field997) - i999 = i1567 - 1 - if (i999 > 0) + for (i1551, elem990) in enumerate(field989) + i991 = i1551 - 1 + if (i991 > 0) newline(pp) end - pretty_rel_term(pp, elem998) + pretty_rel_term(pp, elem990) end end dedent!(pp) @@ -2832,26 +2823,26 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1005 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1005) - write(pp, flat1005) + flat997 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat997) + write(pp, flat997) return nothing else - function _t1568(_dollar_dollar) + function _t1552(_dollar_dollar) return (_dollar_dollar.input, _dollar_dollar.result,) end - _t1569 = _t1568(msg) - fields1001 = _t1569 - unwrapped_fields1002 = fields1001 + _t1553 = _t1552(msg) + fields993 = _t1553 + unwrapped_fields994 = fields993 write(pp, "(") write(pp, "cast") indent_sexp!(pp) newline(pp) - field1003 = unwrapped_fields1002[1] - pretty_term(pp, field1003) + field995 = unwrapped_fields994[1] + pretty_term(pp, field995) newline(pp) - field1004 = unwrapped_fields1002[2] - pretty_term(pp, field1004) + field996 = unwrapped_fields994[2] + pretty_term(pp, field996) dedent!(pp) write(pp, ")") end @@ -2859,23 +2850,23 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1009 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1009) - write(pp, flat1009) + flat1001 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1001) + write(pp, flat1001) return nothing else - fields1006 = msg + fields998 = msg write(pp, "(") write(pp, "attrs") indent_sexp!(pp) - if !isempty(fields1006) + if !isempty(fields998) newline(pp) - for (i1570, elem1007) in enumerate(fields1006) - i1008 = i1570 - 1 - if (i1008 > 0) + for (i1554, elem999) in enumerate(fields998) + i1000 = i1554 - 1 + if (i1000 > 0) newline(pp) end - pretty_attribute(pp, elem1007) + pretty_attribute(pp, elem999) end end dedent!(pp) @@ -2885,32 +2876,32 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1016 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1016) - write(pp, flat1016) + flat1008 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1008) + write(pp, flat1008) return nothing else - function _t1571(_dollar_dollar) + function _t1555(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.args,) end - _t1572 = _t1571(msg) - fields1010 = _t1572 - unwrapped_fields1011 = fields1010 + _t1556 = _t1555(msg) + fields1002 = _t1556 + unwrapped_fields1003 = fields1002 write(pp, "(") write(pp, "attribute") indent_sexp!(pp) newline(pp) - field1012 = unwrapped_fields1011[1] - pretty_name(pp, field1012) - field1013 = unwrapped_fields1011[2] - if !isempty(field1013) + field1004 = unwrapped_fields1003[1] + pretty_name(pp, field1004) + field1005 = unwrapped_fields1003[2] + if !isempty(field1005) newline(pp) - for (i1573, elem1014) in enumerate(field1013) - i1015 = i1573 - 1 - if (i1015 > 0) + for (i1557, elem1006) in enumerate(field1005) + i1007 = i1557 - 1 + if (i1007 > 0) newline(pp) end - pretty_value(pp, elem1014) + pretty_value(pp, elem1006) end end dedent!(pp) @@ -2920,34 +2911,34 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1023 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1023) - write(pp, flat1023) + flat1015 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1015) + write(pp, flat1015) return nothing else - function _t1574(_dollar_dollar) + function _t1558(_dollar_dollar) return (_dollar_dollar.var"#global", _dollar_dollar.body,) end - _t1575 = _t1574(msg) - fields1017 = _t1575 - unwrapped_fields1018 = fields1017 + _t1559 = _t1558(msg) + fields1009 = _t1559 + unwrapped_fields1010 = fields1009 write(pp, "(") write(pp, "algorithm") indent_sexp!(pp) - field1019 = unwrapped_fields1018[1] - if !isempty(field1019) + field1011 = unwrapped_fields1010[1] + if !isempty(field1011) newline(pp) - for (i1576, elem1020) in enumerate(field1019) - i1021 = i1576 - 1 - if (i1021 > 0) + for (i1560, elem1012) in enumerate(field1011) + i1013 = i1560 - 1 + if (i1013 > 0) newline(pp) end - pretty_relation_id(pp, elem1020) + pretty_relation_id(pp, elem1012) end end newline(pp) - field1022 = unwrapped_fields1018[2] - pretty_script(pp, field1022) + field1014 = unwrapped_fields1010[2] + pretty_script(pp, field1014) dedent!(pp) write(pp, ")") end @@ -2955,28 +2946,28 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1028 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1028) - write(pp, flat1028) + flat1020 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1020) + write(pp, flat1020) return nothing else - function _t1577(_dollar_dollar) + function _t1561(_dollar_dollar) return _dollar_dollar.constructs end - _t1578 = _t1577(msg) - fields1024 = _t1578 - unwrapped_fields1025 = fields1024 + _t1562 = _t1561(msg) + fields1016 = _t1562 + unwrapped_fields1017 = fields1016 write(pp, "(") write(pp, "script") indent_sexp!(pp) - if !isempty(unwrapped_fields1025) + if !isempty(unwrapped_fields1017) newline(pp) - for (i1579, elem1026) in enumerate(unwrapped_fields1025) - i1027 = i1579 - 1 - if (i1027 > 0) + for (i1563, elem1018) in enumerate(unwrapped_fields1017) + i1019 = i1563 - 1 + if (i1019 > 0) newline(pp) end - pretty_construct(pp, elem1026) + pretty_construct(pp, elem1018) end end dedent!(pp) @@ -2986,38 +2977,38 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1033 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1033) - write(pp, flat1033) + flat1025 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1025) + write(pp, flat1025) return nothing else - function _t1580(_dollar_dollar) + function _t1564(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1581 = _get_oneof_field(_dollar_dollar, :loop) + _t1565 = _get_oneof_field(_dollar_dollar, :loop) else - _t1581 = nothing + _t1565 = nothing end - return _t1581 + return _t1565 end - _t1582 = _t1580(msg) - deconstruct_result1031 = _t1582 - if !isnothing(deconstruct_result1031) - unwrapped1032 = deconstruct_result1031 - pretty_loop(pp, unwrapped1032) + _t1566 = _t1564(msg) + deconstruct_result1023 = _t1566 + if !isnothing(deconstruct_result1023) + unwrapped1024 = deconstruct_result1023 + pretty_loop(pp, unwrapped1024) else - function _t1583(_dollar_dollar) + function _t1567(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1584 = _get_oneof_field(_dollar_dollar, :instruction) + _t1568 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1584 = nothing + _t1568 = nothing end - return _t1584 + return _t1568 end - _t1585 = _t1583(msg) - deconstruct_result1029 = _t1585 - if !isnothing(deconstruct_result1029) - unwrapped1030 = deconstruct_result1029 - pretty_instruction(pp, unwrapped1030) + _t1569 = _t1567(msg) + deconstruct_result1021 = _t1569 + if !isnothing(deconstruct_result1021) + unwrapped1022 = deconstruct_result1021 + pretty_instruction(pp, unwrapped1022) else throw(ParseError("No matching rule for construct")) end @@ -3027,26 +3018,26 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1038 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1038) - write(pp, flat1038) + flat1030 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1030) + write(pp, flat1030) return nothing else - function _t1586(_dollar_dollar) + function _t1570(_dollar_dollar) return (_dollar_dollar.init, _dollar_dollar.body,) end - _t1587 = _t1586(msg) - fields1034 = _t1587 - unwrapped_fields1035 = fields1034 + _t1571 = _t1570(msg) + fields1026 = _t1571 + unwrapped_fields1027 = fields1026 write(pp, "(") write(pp, "loop") indent_sexp!(pp) newline(pp) - field1036 = unwrapped_fields1035[1] - pretty_init(pp, field1036) + field1028 = unwrapped_fields1027[1] + pretty_init(pp, field1028) newline(pp) - field1037 = unwrapped_fields1035[2] - pretty_script(pp, field1037) + field1029 = unwrapped_fields1027[2] + pretty_script(pp, field1029) dedent!(pp) write(pp, ")") end @@ -3054,23 +3045,23 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1042 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1042) - write(pp, flat1042) + flat1034 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1034) + write(pp, flat1034) return nothing else - fields1039 = msg + fields1031 = msg write(pp, "(") write(pp, "init") indent_sexp!(pp) - if !isempty(fields1039) + if !isempty(fields1031) newline(pp) - for (i1588, elem1040) in enumerate(fields1039) - i1041 = i1588 - 1 - if (i1041 > 0) + for (i1572, elem1032) in enumerate(fields1031) + i1033 = i1572 - 1 + if (i1033 > 0) newline(pp) end - pretty_instruction(pp, elem1040) + pretty_instruction(pp, elem1032) end end dedent!(pp) @@ -3080,80 +3071,80 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1053 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1053) - write(pp, flat1053) + flat1045 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1045) + write(pp, flat1045) return nothing else - function _t1589(_dollar_dollar) + function _t1573(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1590 = _get_oneof_field(_dollar_dollar, :assign) + _t1574 = _get_oneof_field(_dollar_dollar, :assign) else - _t1590 = nothing + _t1574 = nothing end - return _t1590 + return _t1574 end - _t1591 = _t1589(msg) - deconstruct_result1051 = _t1591 - if !isnothing(deconstruct_result1051) - unwrapped1052 = deconstruct_result1051 - pretty_assign(pp, unwrapped1052) + _t1575 = _t1573(msg) + deconstruct_result1043 = _t1575 + if !isnothing(deconstruct_result1043) + unwrapped1044 = deconstruct_result1043 + pretty_assign(pp, unwrapped1044) else - function _t1592(_dollar_dollar) + function _t1576(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1593 = _get_oneof_field(_dollar_dollar, :upsert) + _t1577 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1593 = nothing + _t1577 = nothing end - return _t1593 + return _t1577 end - _t1594 = _t1592(msg) - deconstruct_result1049 = _t1594 - if !isnothing(deconstruct_result1049) - unwrapped1050 = deconstruct_result1049 - pretty_upsert(pp, unwrapped1050) + _t1578 = _t1576(msg) + deconstruct_result1041 = _t1578 + if !isnothing(deconstruct_result1041) + unwrapped1042 = deconstruct_result1041 + pretty_upsert(pp, unwrapped1042) else - function _t1595(_dollar_dollar) + function _t1579(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1596 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1580 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1596 = nothing + _t1580 = nothing end - return _t1596 + return _t1580 end - _t1597 = _t1595(msg) - deconstruct_result1047 = _t1597 - if !isnothing(deconstruct_result1047) - unwrapped1048 = deconstruct_result1047 - pretty_break(pp, unwrapped1048) + _t1581 = _t1579(msg) + deconstruct_result1039 = _t1581 + if !isnothing(deconstruct_result1039) + unwrapped1040 = deconstruct_result1039 + pretty_break(pp, unwrapped1040) else - function _t1598(_dollar_dollar) + function _t1582(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1599 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1583 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1599 = nothing + _t1583 = nothing end - return _t1599 + return _t1583 end - _t1600 = _t1598(msg) - deconstruct_result1045 = _t1600 - if !isnothing(deconstruct_result1045) - unwrapped1046 = deconstruct_result1045 - pretty_monoid_def(pp, unwrapped1046) + _t1584 = _t1582(msg) + deconstruct_result1037 = _t1584 + if !isnothing(deconstruct_result1037) + unwrapped1038 = deconstruct_result1037 + pretty_monoid_def(pp, unwrapped1038) else - function _t1601(_dollar_dollar) + function _t1585(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1602 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1586 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1602 = nothing + _t1586 = nothing end - return _t1602 + return _t1586 end - _t1603 = _t1601(msg) - deconstruct_result1043 = _t1603 - if !isnothing(deconstruct_result1043) - unwrapped1044 = deconstruct_result1043 - pretty_monus_def(pp, unwrapped1044) + _t1587 = _t1585(msg) + deconstruct_result1035 = _t1587 + if !isnothing(deconstruct_result1035) + unwrapped1036 = deconstruct_result1035 + pretty_monus_def(pp, unwrapped1036) else throw(ParseError("No matching rule for instruction")) end @@ -3166,36 +3157,36 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1060 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1060) - write(pp, flat1060) + flat1052 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1052) + write(pp, flat1052) return nothing else - function _t1604(_dollar_dollar) + function _t1588(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1605 = _dollar_dollar.attrs + _t1589 = _dollar_dollar.attrs else - _t1605 = nothing + _t1589 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1605,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1589,) end - _t1606 = _t1604(msg) - fields1054 = _t1606 - unwrapped_fields1055 = fields1054 + _t1590 = _t1588(msg) + fields1046 = _t1590 + unwrapped_fields1047 = fields1046 write(pp, "(") write(pp, "assign") indent_sexp!(pp) newline(pp) - field1056 = unwrapped_fields1055[1] - pretty_relation_id(pp, field1056) + field1048 = unwrapped_fields1047[1] + pretty_relation_id(pp, field1048) newline(pp) - field1057 = unwrapped_fields1055[2] - pretty_abstraction(pp, field1057) - field1058 = unwrapped_fields1055[3] - if !isnothing(field1058) + field1049 = unwrapped_fields1047[2] + pretty_abstraction(pp, field1049) + field1050 = unwrapped_fields1047[3] + if !isnothing(field1050) newline(pp) - opt_val1059 = field1058 - pretty_attrs(pp, opt_val1059) + opt_val1051 = field1050 + pretty_attrs(pp, opt_val1051) end dedent!(pp) write(pp, ")") @@ -3204,36 +3195,36 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1067 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1067) - write(pp, flat1067) + flat1059 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1059) + write(pp, flat1059) return nothing else - function _t1607(_dollar_dollar) + function _t1591(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1608 = _dollar_dollar.attrs + _t1592 = _dollar_dollar.attrs else - _t1608 = nothing + _t1592 = nothing end - return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1608,) + return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1592,) end - _t1609 = _t1607(msg) - fields1061 = _t1609 - unwrapped_fields1062 = fields1061 + _t1593 = _t1591(msg) + fields1053 = _t1593 + unwrapped_fields1054 = fields1053 write(pp, "(") write(pp, "upsert") indent_sexp!(pp) newline(pp) - field1063 = unwrapped_fields1062[1] - pretty_relation_id(pp, field1063) + field1055 = unwrapped_fields1054[1] + pretty_relation_id(pp, field1055) newline(pp) - field1064 = unwrapped_fields1062[2] - pretty_abstraction_with_arity(pp, field1064) - field1065 = unwrapped_fields1062[3] - if !isnothing(field1065) + field1056 = unwrapped_fields1054[2] + pretty_abstraction_with_arity(pp, field1056) + field1057 = unwrapped_fields1054[3] + if !isnothing(field1057) newline(pp) - opt_val1066 = field1065 - pretty_attrs(pp, opt_val1066) + opt_val1058 = field1057 + pretty_attrs(pp, opt_val1058) end dedent!(pp) write(pp, ")") @@ -3242,25 +3233,25 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1072 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1072) - write(pp, flat1072) + flat1064 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1064) + write(pp, flat1064) return nothing else - function _t1610(_dollar_dollar) - _t1611 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - return (_t1611, _dollar_dollar[1].value,) + function _t1594(_dollar_dollar) + _t1595 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + return (_t1595, _dollar_dollar[1].value,) end - _t1612 = _t1610(msg) - fields1068 = _t1612 - unwrapped_fields1069 = fields1068 + _t1596 = _t1594(msg) + fields1060 = _t1596 + unwrapped_fields1061 = fields1060 write(pp, "(") indent!(pp) - field1070 = unwrapped_fields1069[1] - pretty_bindings(pp, field1070) + field1062 = unwrapped_fields1061[1] + pretty_bindings(pp, field1062) newline(pp) - field1071 = unwrapped_fields1069[2] - pretty_formula(pp, field1071) + field1063 = unwrapped_fields1061[2] + pretty_formula(pp, field1063) dedent!(pp) write(pp, ")") end @@ -3268,36 +3259,36 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1079 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1079) - write(pp, flat1079) + flat1071 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1071) + write(pp, flat1071) return nothing else - function _t1613(_dollar_dollar) + function _t1597(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1614 = _dollar_dollar.attrs + _t1598 = _dollar_dollar.attrs else - _t1614 = nothing + _t1598 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1614,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1598,) end - _t1615 = _t1613(msg) - fields1073 = _t1615 - unwrapped_fields1074 = fields1073 + _t1599 = _t1597(msg) + fields1065 = _t1599 + unwrapped_fields1066 = fields1065 write(pp, "(") write(pp, "break") indent_sexp!(pp) newline(pp) - field1075 = unwrapped_fields1074[1] - pretty_relation_id(pp, field1075) + field1067 = unwrapped_fields1066[1] + pretty_relation_id(pp, field1067) newline(pp) - field1076 = unwrapped_fields1074[2] - pretty_abstraction(pp, field1076) - field1077 = unwrapped_fields1074[3] - if !isnothing(field1077) + field1068 = unwrapped_fields1066[2] + pretty_abstraction(pp, field1068) + field1069 = unwrapped_fields1066[3] + if !isnothing(field1069) newline(pp) - opt_val1078 = field1077 - pretty_attrs(pp, opt_val1078) + opt_val1070 = field1069 + pretty_attrs(pp, opt_val1070) end dedent!(pp) write(pp, ")") @@ -3306,39 +3297,39 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1087 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1087) - write(pp, flat1087) + flat1079 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1079) + write(pp, flat1079) return nothing else - function _t1616(_dollar_dollar) + function _t1600(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1617 = _dollar_dollar.attrs + _t1601 = _dollar_dollar.attrs else - _t1617 = nothing + _t1601 = nothing end - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1617,) + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1601,) end - _t1618 = _t1616(msg) - fields1080 = _t1618 - unwrapped_fields1081 = fields1080 + _t1602 = _t1600(msg) + fields1072 = _t1602 + unwrapped_fields1073 = fields1072 write(pp, "(") write(pp, "monoid") indent_sexp!(pp) newline(pp) - field1082 = unwrapped_fields1081[1] - pretty_monoid(pp, field1082) + field1074 = unwrapped_fields1073[1] + pretty_monoid(pp, field1074) newline(pp) - field1083 = unwrapped_fields1081[2] - pretty_relation_id(pp, field1083) + field1075 = unwrapped_fields1073[2] + pretty_relation_id(pp, field1075) newline(pp) - field1084 = unwrapped_fields1081[3] - pretty_abstraction_with_arity(pp, field1084) - field1085 = unwrapped_fields1081[4] - if !isnothing(field1085) + field1076 = unwrapped_fields1073[3] + pretty_abstraction_with_arity(pp, field1076) + field1077 = unwrapped_fields1073[4] + if !isnothing(field1077) newline(pp) - opt_val1086 = field1085 - pretty_attrs(pp, opt_val1086) + opt_val1078 = field1077 + pretty_attrs(pp, opt_val1078) end dedent!(pp) write(pp, ")") @@ -3347,66 +3338,66 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1096 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1096) - write(pp, flat1096) + flat1088 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1088) + write(pp, flat1088) return nothing else - function _t1619(_dollar_dollar) + function _t1603(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1620 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1604 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1620 = nothing + _t1604 = nothing end - return _t1620 + return _t1604 end - _t1621 = _t1619(msg) - deconstruct_result1094 = _t1621 - if !isnothing(deconstruct_result1094) - unwrapped1095 = deconstruct_result1094 - pretty_or_monoid(pp, unwrapped1095) + _t1605 = _t1603(msg) + deconstruct_result1086 = _t1605 + if !isnothing(deconstruct_result1086) + unwrapped1087 = deconstruct_result1086 + pretty_or_monoid(pp, unwrapped1087) else - function _t1622(_dollar_dollar) + function _t1606(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1623 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1607 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1623 = nothing + _t1607 = nothing end - return _t1623 + return _t1607 end - _t1624 = _t1622(msg) - deconstruct_result1092 = _t1624 - if !isnothing(deconstruct_result1092) - unwrapped1093 = deconstruct_result1092 - pretty_min_monoid(pp, unwrapped1093) + _t1608 = _t1606(msg) + deconstruct_result1084 = _t1608 + if !isnothing(deconstruct_result1084) + unwrapped1085 = deconstruct_result1084 + pretty_min_monoid(pp, unwrapped1085) else - function _t1625(_dollar_dollar) + function _t1609(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1626 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1610 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1626 = nothing + _t1610 = nothing end - return _t1626 + return _t1610 end - _t1627 = _t1625(msg) - deconstruct_result1090 = _t1627 - if !isnothing(deconstruct_result1090) - unwrapped1091 = deconstruct_result1090 - pretty_max_monoid(pp, unwrapped1091) + _t1611 = _t1609(msg) + deconstruct_result1082 = _t1611 + if !isnothing(deconstruct_result1082) + unwrapped1083 = deconstruct_result1082 + pretty_max_monoid(pp, unwrapped1083) else - function _t1628(_dollar_dollar) + function _t1612(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1629 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1613 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1629 = nothing + _t1613 = nothing end - return _t1629 + return _t1613 end - _t1630 = _t1628(msg) - deconstruct_result1088 = _t1630 - if !isnothing(deconstruct_result1088) - unwrapped1089 = deconstruct_result1088 - pretty_sum_monoid(pp, unwrapped1089) + _t1614 = _t1612(msg) + deconstruct_result1080 = _t1614 + if !isnothing(deconstruct_result1080) + unwrapped1081 = deconstruct_result1080 + pretty_sum_monoid(pp, unwrapped1081) else throw(ParseError("No matching rule for monoid")) end @@ -3418,7 +3409,7 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1097 = msg + fields1089 = msg write(pp, "(") write(pp, "or") write(pp, ")") @@ -3426,22 +3417,22 @@ function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1100 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1100) - write(pp, flat1100) + flat1092 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1092) + write(pp, flat1092) return nothing else - function _t1631(_dollar_dollar) + function _t1615(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1632 = _t1631(msg) - fields1098 = _t1632 - unwrapped_fields1099 = fields1098 + _t1616 = _t1615(msg) + fields1090 = _t1616 + unwrapped_fields1091 = fields1090 write(pp, "(") write(pp, "min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1099) + pretty_type(pp, unwrapped_fields1091) dedent!(pp) write(pp, ")") end @@ -3449,22 +3440,22 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1103 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1103) - write(pp, flat1103) + flat1095 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1095) + write(pp, flat1095) return nothing else - function _t1633(_dollar_dollar) + function _t1617(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1634 = _t1633(msg) - fields1101 = _t1634 - unwrapped_fields1102 = fields1101 + _t1618 = _t1617(msg) + fields1093 = _t1618 + unwrapped_fields1094 = fields1093 write(pp, "(") write(pp, "max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1102) + pretty_type(pp, unwrapped_fields1094) dedent!(pp) write(pp, ")") end @@ -3472,22 +3463,22 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1106 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1106) - write(pp, flat1106) + flat1098 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1098) + write(pp, flat1098) return nothing else - function _t1635(_dollar_dollar) + function _t1619(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1636 = _t1635(msg) - fields1104 = _t1636 - unwrapped_fields1105 = fields1104 + _t1620 = _t1619(msg) + fields1096 = _t1620 + unwrapped_fields1097 = fields1096 write(pp, "(") write(pp, "sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1105) + pretty_type(pp, unwrapped_fields1097) dedent!(pp) write(pp, ")") end @@ -3495,39 +3486,39 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1114 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1114) - write(pp, flat1114) + flat1106 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1106) + write(pp, flat1106) return nothing else - function _t1637(_dollar_dollar) + function _t1621(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1638 = _dollar_dollar.attrs + _t1622 = _dollar_dollar.attrs else - _t1638 = nothing + _t1622 = nothing end - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1638,) + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1622,) end - _t1639 = _t1637(msg) - fields1107 = _t1639 - unwrapped_fields1108 = fields1107 + _t1623 = _t1621(msg) + fields1099 = _t1623 + unwrapped_fields1100 = fields1099 write(pp, "(") write(pp, "monus") indent_sexp!(pp) newline(pp) - field1109 = unwrapped_fields1108[1] - pretty_monoid(pp, field1109) + field1101 = unwrapped_fields1100[1] + pretty_monoid(pp, field1101) newline(pp) - field1110 = unwrapped_fields1108[2] - pretty_relation_id(pp, field1110) + field1102 = unwrapped_fields1100[2] + pretty_relation_id(pp, field1102) newline(pp) - field1111 = unwrapped_fields1108[3] - pretty_abstraction_with_arity(pp, field1111) - field1112 = unwrapped_fields1108[4] - if !isnothing(field1112) + field1103 = unwrapped_fields1100[3] + pretty_abstraction_with_arity(pp, field1103) + field1104 = unwrapped_fields1100[4] + if !isnothing(field1104) newline(pp) - opt_val1113 = field1112 - pretty_attrs(pp, opt_val1113) + opt_val1105 = field1104 + pretty_attrs(pp, opt_val1105) end dedent!(pp) write(pp, ")") @@ -3536,32 +3527,32 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1121 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1121) - write(pp, flat1121) + flat1113 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1113) + write(pp, flat1113) return nothing else - function _t1640(_dollar_dollar) + function _t1624(_dollar_dollar) return (_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,) end - _t1641 = _t1640(msg) - fields1115 = _t1641 - unwrapped_fields1116 = fields1115 + _t1625 = _t1624(msg) + fields1107 = _t1625 + unwrapped_fields1108 = fields1107 write(pp, "(") write(pp, "functional_dependency") indent_sexp!(pp) newline(pp) - field1117 = unwrapped_fields1116[1] - pretty_relation_id(pp, field1117) + field1109 = unwrapped_fields1108[1] + pretty_relation_id(pp, field1109) newline(pp) - field1118 = unwrapped_fields1116[2] - pretty_abstraction(pp, field1118) + field1110 = unwrapped_fields1108[2] + pretty_abstraction(pp, field1110) newline(pp) - field1119 = unwrapped_fields1116[3] - pretty_functional_dependency_keys(pp, field1119) + field1111 = unwrapped_fields1108[3] + pretty_functional_dependency_keys(pp, field1111) newline(pp) - field1120 = unwrapped_fields1116[4] - pretty_functional_dependency_values(pp, field1120) + field1112 = unwrapped_fields1108[4] + pretty_functional_dependency_values(pp, field1112) dedent!(pp) write(pp, ")") end @@ -3569,23 +3560,23 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1125 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1125) - write(pp, flat1125) + flat1117 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1117) + write(pp, flat1117) return nothing else - fields1122 = msg + fields1114 = msg write(pp, "(") write(pp, "keys") indent_sexp!(pp) - if !isempty(fields1122) + if !isempty(fields1114) newline(pp) - for (i1642, elem1123) in enumerate(fields1122) - i1124 = i1642 - 1 - if (i1124 > 0) + for (i1626, elem1115) in enumerate(fields1114) + i1116 = i1626 - 1 + if (i1116 > 0) newline(pp) end - pretty_var(pp, elem1123) + pretty_var(pp, elem1115) end end dedent!(pp) @@ -3595,23 +3586,23 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1129 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1129) - write(pp, flat1129) + flat1121 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1121) + write(pp, flat1121) return nothing else - fields1126 = msg + fields1118 = msg write(pp, "(") write(pp, "values") indent_sexp!(pp) - if !isempty(fields1126) + if !isempty(fields1118) newline(pp) - for (i1643, elem1127) in enumerate(fields1126) - i1128 = i1643 - 1 - if (i1128 > 0) + for (i1627, elem1119) in enumerate(fields1118) + i1120 = i1627 - 1 + if (i1120 > 0) newline(pp) end - pretty_var(pp, elem1127) + pretty_var(pp, elem1119) end end dedent!(pp) @@ -3621,52 +3612,52 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1136 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1136) - write(pp, flat1136) + flat1128 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1128) + write(pp, flat1128) return nothing else - function _t1644(_dollar_dollar) - if _has_proto_field(_dollar_dollar, Symbol("rel_edb")) - _t1645 = _get_oneof_field(_dollar_dollar, :rel_edb) + function _t1628(_dollar_dollar) + if _has_proto_field(_dollar_dollar, Symbol("edb")) + _t1629 = _get_oneof_field(_dollar_dollar, :edb) else - _t1645 = nothing + _t1629 = nothing end - return _t1645 + return _t1629 end - _t1646 = _t1644(msg) - deconstruct_result1134 = _t1646 - if !isnothing(deconstruct_result1134) - unwrapped1135 = deconstruct_result1134 - pretty_rel_edb(pp, unwrapped1135) + _t1630 = _t1628(msg) + deconstruct_result1126 = _t1630 + if !isnothing(deconstruct_result1126) + unwrapped1127 = deconstruct_result1126 + pretty_edb(pp, unwrapped1127) else - function _t1647(_dollar_dollar) + function _t1631(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1648 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1632 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1648 = nothing + _t1632 = nothing end - return _t1648 + return _t1632 end - _t1649 = _t1647(msg) - deconstruct_result1132 = _t1649 - if !isnothing(deconstruct_result1132) - unwrapped1133 = deconstruct_result1132 - pretty_betree_relation(pp, unwrapped1133) + _t1633 = _t1631(msg) + deconstruct_result1124 = _t1633 + if !isnothing(deconstruct_result1124) + unwrapped1125 = deconstruct_result1124 + pretty_betree_relation(pp, unwrapped1125) else - function _t1650(_dollar_dollar) + function _t1634(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1651 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1635 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1651 = nothing + _t1635 = nothing end - return _t1651 + return _t1635 end - _t1652 = _t1650(msg) - deconstruct_result1130 = _t1652 - if !isnothing(deconstruct_result1130) - unwrapped1131 = deconstruct_result1130 - pretty_csv_data(pp, unwrapped1131) + _t1636 = _t1634(msg) + deconstruct_result1122 = _t1636 + if !isnothing(deconstruct_result1122) + unwrapped1123 = deconstruct_result1122 + pretty_csv_data(pp, unwrapped1123) else throw(ParseError("No matching rule for data")) end @@ -3676,51 +3667,51 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) return nothing end -function pretty_rel_edb(pp::PrettyPrinter, msg::Proto.RelEDB) - flat1142 = try_flat(pp, msg, pretty_rel_edb) - if !isnothing(flat1142) - write(pp, flat1142) +function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) + flat1134 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1134) + write(pp, flat1134) return nothing else - function _t1653(_dollar_dollar) + function _t1637(_dollar_dollar) return (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) end - _t1654 = _t1653(msg) - fields1137 = _t1654 - unwrapped_fields1138 = fields1137 + _t1638 = _t1637(msg) + fields1129 = _t1638 + unwrapped_fields1130 = fields1129 write(pp, "(") - write(pp, "rel_edb") + write(pp, "edb") indent_sexp!(pp) newline(pp) - field1139 = unwrapped_fields1138[1] - pretty_relation_id(pp, field1139) + field1131 = unwrapped_fields1130[1] + pretty_relation_id(pp, field1131) newline(pp) - field1140 = unwrapped_fields1138[2] - pretty_rel_edb_path(pp, field1140) + field1132 = unwrapped_fields1130[2] + pretty_edb_path(pp, field1132) newline(pp) - field1141 = unwrapped_fields1138[3] - pretty_rel_edb_types(pp, field1141) + field1133 = unwrapped_fields1130[3] + pretty_edb_types(pp, field1133) dedent!(pp) write(pp, ")") end return nothing end -function pretty_rel_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1146 = try_flat(pp, msg, pretty_rel_edb_path) - if !isnothing(flat1146) - write(pp, flat1146) +function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) + flat1138 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1138) + write(pp, flat1138) return nothing else - fields1143 = msg + fields1135 = msg write(pp, "[") indent!(pp) - for (i1655, elem1144) in enumerate(fields1143) - i1145 = i1655 - 1 - if (i1145 > 0) + for (i1639, elem1136) in enumerate(fields1135) + i1137 = i1639 - 1 + if (i1137 > 0) newline(pp) end - write(pp, format_string(pp, elem1144)) + write(pp, format_string(pp, elem1136)) end dedent!(pp) write(pp, "]") @@ -3728,21 +3719,21 @@ function pretty_rel_edb_path(pp::PrettyPrinter, msg::Vector{String}) return nothing end -function pretty_rel_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1150 = try_flat(pp, msg, pretty_rel_edb_types) - if !isnothing(flat1150) - write(pp, flat1150) +function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) + flat1142 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1142) + write(pp, flat1142) return nothing else - fields1147 = msg + fields1139 = msg write(pp, "[") indent!(pp) - for (i1656, elem1148) in enumerate(fields1147) - i1149 = i1656 - 1 - if (i1149 > 0) + for (i1640, elem1140) in enumerate(fields1139) + i1141 = i1640 - 1 + if (i1141 > 0) newline(pp) end - pretty_type(pp, elem1148) + pretty_type(pp, elem1140) end dedent!(pp) write(pp, "]") @@ -3751,26 +3742,26 @@ function pretty_rel_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1155 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1155) - write(pp, flat1155) + flat1147 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1147) + write(pp, flat1147) return nothing else - function _t1657(_dollar_dollar) + function _t1641(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.relation_info,) end - _t1658 = _t1657(msg) - fields1151 = _t1658 - unwrapped_fields1152 = fields1151 + _t1642 = _t1641(msg) + fields1143 = _t1642 + unwrapped_fields1144 = fields1143 write(pp, "(") write(pp, "betree_relation") indent_sexp!(pp) newline(pp) - field1153 = unwrapped_fields1152[1] - pretty_relation_id(pp, field1153) + field1145 = unwrapped_fields1144[1] + pretty_relation_id(pp, field1145) newline(pp) - field1154 = unwrapped_fields1152[2] - pretty_betree_info(pp, field1154) + field1146 = unwrapped_fields1144[2] + pretty_betree_info(pp, field1146) dedent!(pp) write(pp, ")") end @@ -3778,30 +3769,30 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1161 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1161) - write(pp, flat1161) + flat1153 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1153) + write(pp, flat1153) return nothing else - function _t1659(_dollar_dollar) - _t1660 = deconstruct_betree_info_config(pp, _dollar_dollar) - return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1660,) + function _t1643(_dollar_dollar) + _t1644 = deconstruct_betree_info_config(pp, _dollar_dollar) + return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1644,) end - _t1661 = _t1659(msg) - fields1156 = _t1661 - unwrapped_fields1157 = fields1156 + _t1645 = _t1643(msg) + fields1148 = _t1645 + unwrapped_fields1149 = fields1148 write(pp, "(") write(pp, "betree_info") indent_sexp!(pp) newline(pp) - field1158 = unwrapped_fields1157[1] - pretty_betree_info_key_types(pp, field1158) + field1150 = unwrapped_fields1149[1] + pretty_betree_info_key_types(pp, field1150) newline(pp) - field1159 = unwrapped_fields1157[2] - pretty_betree_info_value_types(pp, field1159) + field1151 = unwrapped_fields1149[2] + pretty_betree_info_value_types(pp, field1151) newline(pp) - field1160 = unwrapped_fields1157[3] - pretty_config_dict(pp, field1160) + field1152 = unwrapped_fields1149[3] + pretty_config_dict(pp, field1152) dedent!(pp) write(pp, ")") end @@ -3809,23 +3800,23 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1165 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1165) - write(pp, flat1165) + flat1157 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1157) + write(pp, flat1157) return nothing else - fields1162 = msg + fields1154 = msg write(pp, "(") write(pp, "key_types") indent_sexp!(pp) - if !isempty(fields1162) + if !isempty(fields1154) newline(pp) - for (i1662, elem1163) in enumerate(fields1162) - i1164 = i1662 - 1 - if (i1164 > 0) + for (i1646, elem1155) in enumerate(fields1154) + i1156 = i1646 - 1 + if (i1156 > 0) newline(pp) end - pretty_type(pp, elem1163) + pretty_type(pp, elem1155) end end dedent!(pp) @@ -3835,23 +3826,23 @@ 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"}) - flat1169 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1169) - write(pp, flat1169) + flat1161 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1161) + write(pp, flat1161) return nothing else - fields1166 = msg + fields1158 = msg write(pp, "(") write(pp, "value_types") indent_sexp!(pp) - if !isempty(fields1166) + if !isempty(fields1158) newline(pp) - for (i1663, elem1167) in enumerate(fields1166) - i1168 = i1663 - 1 - if (i1168 > 0) + for (i1647, elem1159) in enumerate(fields1158) + i1160 = i1647 - 1 + if (i1160 > 0) newline(pp) end - pretty_type(pp, elem1167) + pretty_type(pp, elem1159) end end dedent!(pp) @@ -3861,32 +3852,32 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1176 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1176) - write(pp, flat1176) + flat1168 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1168) + write(pp, flat1168) return nothing else - function _t1664(_dollar_dollar) + function _t1648(_dollar_dollar) return (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) end - _t1665 = _t1664(msg) - fields1170 = _t1665 - unwrapped_fields1171 = fields1170 + _t1649 = _t1648(msg) + fields1162 = _t1649 + unwrapped_fields1163 = fields1162 write(pp, "(") write(pp, "csv_data") indent_sexp!(pp) newline(pp) - field1172 = unwrapped_fields1171[1] - pretty_csvlocator(pp, field1172) + field1164 = unwrapped_fields1163[1] + pretty_csvlocator(pp, field1164) newline(pp) - field1173 = unwrapped_fields1171[2] - pretty_csv_config(pp, field1173) + field1165 = unwrapped_fields1163[2] + pretty_csv_config(pp, field1165) newline(pp) - field1174 = unwrapped_fields1171[3] - pretty_csv_columns(pp, field1174) + field1166 = unwrapped_fields1163[3] + pretty_gnf_columns(pp, field1166) newline(pp) - field1175 = unwrapped_fields1171[4] - pretty_csv_asof(pp, field1175) + field1167 = unwrapped_fields1163[4] + pretty_csv_asof(pp, field1167) dedent!(pp) write(pp, ")") end @@ -3894,41 +3885,41 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1183 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1183) - write(pp, flat1183) + flat1175 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1175) + write(pp, flat1175) return nothing else - function _t1666(_dollar_dollar) + function _t1650(_dollar_dollar) if !isempty(_dollar_dollar.paths) - _t1667 = _dollar_dollar.paths + _t1651 = _dollar_dollar.paths else - _t1667 = nothing + _t1651 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1668 = String(copy(_dollar_dollar.inline_data)) + _t1652 = String(copy(_dollar_dollar.inline_data)) else - _t1668 = nothing + _t1652 = nothing end - return (_t1667, _t1668,) + return (_t1651, _t1652,) end - _t1669 = _t1666(msg) - fields1177 = _t1669 - unwrapped_fields1178 = fields1177 + _t1653 = _t1650(msg) + fields1169 = _t1653 + unwrapped_fields1170 = fields1169 write(pp, "(") write(pp, "csv_locator") indent_sexp!(pp) - field1179 = unwrapped_fields1178[1] - if !isnothing(field1179) + field1171 = unwrapped_fields1170[1] + if !isnothing(field1171) newline(pp) - opt_val1180 = field1179 - pretty_csv_locator_paths(pp, opt_val1180) + opt_val1172 = field1171 + pretty_csv_locator_paths(pp, opt_val1172) end - field1181 = unwrapped_fields1178[2] - if !isnothing(field1181) + field1173 = unwrapped_fields1170[2] + if !isnothing(field1173) newline(pp) - opt_val1182 = field1181 - pretty_csv_locator_inline_data(pp, opt_val1182) + opt_val1174 = field1173 + pretty_csv_locator_inline_data(pp, opt_val1174) end dedent!(pp) write(pp, ")") @@ -3937,23 +3928,23 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1187 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1187) - write(pp, flat1187) + flat1179 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1179) + write(pp, flat1179) return nothing else - fields1184 = msg + fields1176 = msg write(pp, "(") write(pp, "paths") indent_sexp!(pp) - if !isempty(fields1184) + if !isempty(fields1176) newline(pp) - for (i1670, elem1185) in enumerate(fields1184) - i1186 = i1670 - 1 - if (i1186 > 0) + for (i1654, elem1177) in enumerate(fields1176) + i1178 = i1654 - 1 + if (i1178 > 0) newline(pp) end - write(pp, format_string(pp, elem1185)) + write(pp, format_string(pp, elem1177)) end end dedent!(pp) @@ -3963,17 +3954,17 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1189 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1189) - write(pp, flat1189) + flat1181 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1181) + write(pp, flat1181) return nothing else - fields1188 = msg + fields1180 = msg write(pp, "(") write(pp, "inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1188)) + write(pp, format_string(pp, fields1180)) dedent!(pp) write(pp, ")") end @@ -3981,47 +3972,47 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1192 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1192) - write(pp, flat1192) + flat1184 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1184) + write(pp, flat1184) return nothing else - function _t1671(_dollar_dollar) - _t1672 = deconstruct_csv_config(pp, _dollar_dollar) - return _t1672 + function _t1655(_dollar_dollar) + _t1656 = deconstruct_csv_config(pp, _dollar_dollar) + return _t1656 end - _t1673 = _t1671(msg) - fields1190 = _t1673 - unwrapped_fields1191 = fields1190 + _t1657 = _t1655(msg) + fields1182 = _t1657 + unwrapped_fields1183 = fields1182 write(pp, "(") write(pp, "csv_config") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields1191) + pretty_config_dict(pp, unwrapped_fields1183) dedent!(pp) write(pp, ")") end return nothing end -function pretty_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.CSVColumn}) - flat1196 = try_flat(pp, msg, pretty_csv_columns) - if !isnothing(flat1196) - write(pp, flat1196) +function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) + flat1188 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1188) + write(pp, flat1188) return nothing else - fields1193 = msg + fields1185 = msg write(pp, "(") write(pp, "columns") indent_sexp!(pp) - if !isempty(fields1193) + if !isempty(fields1185) newline(pp) - for (i1674, elem1194) in enumerate(fields1193) - i1195 = i1674 - 1 - if (i1195 > 0) + for (i1658, elem1186) in enumerate(fields1185) + i1187 = i1658 - 1 + if (i1187 > 0) newline(pp) end - pretty_csv_column(pp, elem1194) + pretty_gnf_column(pp, elem1186) end end dedent!(pp) @@ -4030,154 +4021,115 @@ function pretty_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.CSVColumn}) return nothing end -function pretty_csv_column(pp::PrettyPrinter, msg::Proto.CSVColumn) - flat1202 = try_flat(pp, msg, pretty_csv_column) - if !isnothing(flat1202) - write(pp, flat1202) +function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) + flat1197 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1197) + write(pp, flat1197) return nothing else - function _t1675(_dollar_dollar) - _t1676 = deconstruct_csv_column_tail(pp, _dollar_dollar) - return (_dollar_dollar.column_path, _t1676,) + function _t1659(_dollar_dollar) + if _has_proto_field(_dollar_dollar, Symbol("target_id")) + _t1660 = _dollar_dollar.target_id + else + _t1660 = nothing + end + return (_dollar_dollar.column_path, _t1660, _dollar_dollar.types,) end - _t1677 = _t1675(msg) - fields1197 = _t1677 - unwrapped_fields1198 = fields1197 + _t1661 = _t1659(msg) + fields1189 = _t1661 + unwrapped_fields1190 = fields1189 write(pp, "(") write(pp, "column") indent_sexp!(pp) newline(pp) - field1199 = unwrapped_fields1198[1] - pretty_csv_column_path(pp, field1199) - field1200 = unwrapped_fields1198[2] - if !isnothing(field1200) + field1191 = unwrapped_fields1190[1] + pretty_gnf_column_path(pp, field1191) + field1192 = unwrapped_fields1190[2] + if !isnothing(field1192) newline(pp) - opt_val1201 = field1200 - pretty_csv_column_tail(pp, opt_val1201) + opt_val1193 = field1192 + pretty_relation_id(pp, opt_val1193) + end + newline(pp) + write(pp, "[") + field1194 = unwrapped_fields1190[3] + for (i1662, elem1195) in enumerate(field1194) + i1196 = i1662 - 1 + if (i1196 > 0) + newline(pp) + end + pretty_type(pp, elem1195) end + write(pp, "]") dedent!(pp) write(pp, ")") end return nothing end -function pretty_csv_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1209 = try_flat(pp, msg, pretty_csv_column_path) - if !isnothing(flat1209) - write(pp, flat1209) +function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) + flat1204 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1204) + write(pp, flat1204) return nothing else - function _t1678(_dollar_dollar) + function _t1663(_dollar_dollar) if length(_dollar_dollar) == 1 - _t1679 = _dollar_dollar[1] + _t1664 = _dollar_dollar[1] else - _t1679 = nothing + _t1664 = nothing end - return _t1679 + return _t1664 end - _t1680 = _t1678(msg) - deconstruct_result1207 = _t1680 - if !isnothing(deconstruct_result1207) - unwrapped1208 = deconstruct_result1207 - write(pp, format_string(pp, unwrapped1208)) + _t1665 = _t1663(msg) + deconstruct_result1202 = _t1665 + if !isnothing(deconstruct_result1202) + unwrapped1203 = deconstruct_result1202 + write(pp, format_string(pp, unwrapped1203)) else - function _t1681(_dollar_dollar) + function _t1666(_dollar_dollar) if length(_dollar_dollar) != 1 - _t1682 = _dollar_dollar + _t1667 = _dollar_dollar else - _t1682 = nothing + _t1667 = nothing end - return _t1682 + return _t1667 end - _t1683 = _t1681(msg) - deconstruct_result1203 = _t1683 - if !isnothing(deconstruct_result1203) - unwrapped1204 = deconstruct_result1203 + _t1668 = _t1666(msg) + deconstruct_result1198 = _t1668 + if !isnothing(deconstruct_result1198) + unwrapped1199 = deconstruct_result1198 write(pp, "[") indent!(pp) - for (i1684, elem1205) in enumerate(unwrapped1204) - i1206 = i1684 - 1 - if (i1206 > 0) + for (i1669, elem1200) in enumerate(unwrapped1199) + i1201 = i1669 - 1 + if (i1201 > 0) newline(pp) end - write(pp, format_string(pp, elem1205)) + write(pp, format_string(pp, elem1200)) end dedent!(pp) write(pp, "]") else - throw(ParseError("No matching rule for csv_column_path")) + throw(ParseError("No matching rule for gnf_column_path")) end end end return nothing end -function pretty_csv_column_tail(pp::PrettyPrinter, msg::Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}) - flat1220 = try_flat(pp, msg, pretty_csv_column_tail) - if !isnothing(flat1220) - write(pp, flat1220) - return nothing - else - function _t1685(_dollar_dollar) - if !isnothing(_dollar_dollar[1]) - _t1686 = (_dollar_dollar[1], _dollar_dollar[2],) - else - _t1686 = nothing - end - return _t1686 - end - _t1687 = _t1685(msg) - deconstruct_result1214 = _t1687 - if !isnothing(deconstruct_result1214) - unwrapped1215 = deconstruct_result1214 - field1216 = unwrapped1215[1] - pretty_relation_id(pp, field1216) - write(pp, " ") - write(pp, "[") - field1217 = unwrapped1215[2] - for (i1688, elem1218) in enumerate(field1217) - i1219 = i1688 - 1 - if (i1219 > 0) - newline(pp) - end - pretty_type(pp, elem1218) - end - write(pp, "]") - else - function _t1689(_dollar_dollar) - return _dollar_dollar[2] - end - _t1690 = _t1689(msg) - fields1210 = _t1690 - unwrapped_fields1211 = fields1210 - write(pp, "[") - indent!(pp) - for (i1691, elem1212) in enumerate(unwrapped_fields1211) - i1213 = i1691 - 1 - if (i1213 > 0) - newline(pp) - end - pretty_type(pp, elem1212) - end - dedent!(pp) - write(pp, "]") - end - end - return nothing -end - function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1222 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1222) - write(pp, flat1222) + flat1206 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1206) + write(pp, flat1206) return nothing else - fields1221 = msg + fields1205 = msg write(pp, "(") write(pp, "asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1221)) + write(pp, format_string(pp, fields1205)) dedent!(pp) write(pp, ")") end @@ -4185,22 +4137,22 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1225 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1225) - write(pp, flat1225) + flat1209 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1209) + write(pp, flat1209) return nothing else - function _t1692(_dollar_dollar) + function _t1670(_dollar_dollar) return _dollar_dollar.fragment_id end - _t1693 = _t1692(msg) - fields1223 = _t1693 - unwrapped_fields1224 = fields1223 + _t1671 = _t1670(msg) + fields1207 = _t1671 + unwrapped_fields1208 = fields1207 write(pp, "(") write(pp, "undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1224) + pretty_fragment_id(pp, unwrapped_fields1208) dedent!(pp) write(pp, ")") end @@ -4208,28 +4160,28 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1230 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1230) - write(pp, flat1230) + flat1214 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1214) + write(pp, flat1214) return nothing else - function _t1694(_dollar_dollar) + function _t1672(_dollar_dollar) return _dollar_dollar.relations end - _t1695 = _t1694(msg) - fields1226 = _t1695 - unwrapped_fields1227 = fields1226 + _t1673 = _t1672(msg) + fields1210 = _t1673 + unwrapped_fields1211 = fields1210 write(pp, "(") write(pp, "context") indent_sexp!(pp) - if !isempty(unwrapped_fields1227) + if !isempty(unwrapped_fields1211) newline(pp) - for (i1696, elem1228) in enumerate(unwrapped_fields1227) - i1229 = i1696 - 1 - if (i1229 > 0) + for (i1674, elem1212) in enumerate(unwrapped_fields1211) + i1213 = i1674 - 1 + if (i1213 > 0) newline(pp) end - pretty_relation_id(pp, elem1228) + pretty_relation_id(pp, elem1212) end end dedent!(pp) @@ -4239,26 +4191,26 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1235 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1235) - write(pp, flat1235) + flat1219 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1219) + write(pp, flat1219) return nothing else - function _t1697(_dollar_dollar) + function _t1675(_dollar_dollar) return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) end - _t1698 = _t1697(msg) - fields1231 = _t1698 - unwrapped_fields1232 = fields1231 + _t1676 = _t1675(msg) + fields1215 = _t1676 + unwrapped_fields1216 = fields1215 write(pp, "(") write(pp, "snapshot") indent_sexp!(pp) newline(pp) - field1233 = unwrapped_fields1232[1] - pretty_rel_edb_path(pp, field1233) + field1217 = unwrapped_fields1216[1] + pretty_edb_path(pp, field1217) newline(pp) - field1234 = unwrapped_fields1232[2] - pretty_relation_id(pp, field1234) + field1218 = unwrapped_fields1216[2] + pretty_relation_id(pp, field1218) dedent!(pp) write(pp, ")") end @@ -4266,23 +4218,23 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1239 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1239) - write(pp, flat1239) + flat1223 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1223) + write(pp, flat1223) return nothing else - fields1236 = msg + fields1220 = msg write(pp, "(") write(pp, "reads") indent_sexp!(pp) - if !isempty(fields1236) + if !isempty(fields1220) newline(pp) - for (i1699, elem1237) in enumerate(fields1236) - i1238 = i1699 - 1 - if (i1238 > 0) + for (i1677, elem1221) in enumerate(fields1220) + i1222 = i1677 - 1 + if (i1222 > 0) newline(pp) end - pretty_read(pp, elem1237) + pretty_read(pp, elem1221) end end dedent!(pp) @@ -4292,80 +4244,80 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1250 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1250) - write(pp, flat1250) + flat1234 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1234) + write(pp, flat1234) return nothing else - function _t1700(_dollar_dollar) + function _t1678(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1701 = _get_oneof_field(_dollar_dollar, :demand) + _t1679 = _get_oneof_field(_dollar_dollar, :demand) else - _t1701 = nothing + _t1679 = nothing end - return _t1701 + return _t1679 end - _t1702 = _t1700(msg) - deconstruct_result1248 = _t1702 - if !isnothing(deconstruct_result1248) - unwrapped1249 = deconstruct_result1248 - pretty_demand(pp, unwrapped1249) + _t1680 = _t1678(msg) + deconstruct_result1232 = _t1680 + if !isnothing(deconstruct_result1232) + unwrapped1233 = deconstruct_result1232 + pretty_demand(pp, unwrapped1233) else - function _t1703(_dollar_dollar) + function _t1681(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1704 = _get_oneof_field(_dollar_dollar, :output) + _t1682 = _get_oneof_field(_dollar_dollar, :output) else - _t1704 = nothing + _t1682 = nothing end - return _t1704 + return _t1682 end - _t1705 = _t1703(msg) - deconstruct_result1246 = _t1705 - if !isnothing(deconstruct_result1246) - unwrapped1247 = deconstruct_result1246 - pretty_output(pp, unwrapped1247) + _t1683 = _t1681(msg) + deconstruct_result1230 = _t1683 + if !isnothing(deconstruct_result1230) + unwrapped1231 = deconstruct_result1230 + pretty_output(pp, unwrapped1231) else - function _t1706(_dollar_dollar) + function _t1684(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1707 = _get_oneof_field(_dollar_dollar, :what_if) + _t1685 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1707 = nothing + _t1685 = nothing end - return _t1707 + return _t1685 end - _t1708 = _t1706(msg) - deconstruct_result1244 = _t1708 - if !isnothing(deconstruct_result1244) - unwrapped1245 = deconstruct_result1244 - pretty_what_if(pp, unwrapped1245) + _t1686 = _t1684(msg) + deconstruct_result1228 = _t1686 + if !isnothing(deconstruct_result1228) + unwrapped1229 = deconstruct_result1228 + pretty_what_if(pp, unwrapped1229) else - function _t1709(_dollar_dollar) + function _t1687(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1710 = _get_oneof_field(_dollar_dollar, :abort) + _t1688 = _get_oneof_field(_dollar_dollar, :abort) else - _t1710 = nothing + _t1688 = nothing end - return _t1710 + return _t1688 end - _t1711 = _t1709(msg) - deconstruct_result1242 = _t1711 - if !isnothing(deconstruct_result1242) - unwrapped1243 = deconstruct_result1242 - pretty_abort(pp, unwrapped1243) + _t1689 = _t1687(msg) + deconstruct_result1226 = _t1689 + if !isnothing(deconstruct_result1226) + unwrapped1227 = deconstruct_result1226 + pretty_abort(pp, unwrapped1227) else - function _t1712(_dollar_dollar) + function _t1690(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1713 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1691 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1713 = nothing + _t1691 = nothing end - return _t1713 + return _t1691 end - _t1714 = _t1712(msg) - deconstruct_result1240 = _t1714 - if !isnothing(deconstruct_result1240) - unwrapped1241 = deconstruct_result1240 - pretty_export(pp, unwrapped1241) + _t1692 = _t1690(msg) + deconstruct_result1224 = _t1692 + if !isnothing(deconstruct_result1224) + unwrapped1225 = deconstruct_result1224 + pretty_export(pp, unwrapped1225) else throw(ParseError("No matching rule for read")) end @@ -4378,22 +4330,22 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1253 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1253) - write(pp, flat1253) + flat1237 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1237) + write(pp, flat1237) return nothing else - function _t1715(_dollar_dollar) + function _t1693(_dollar_dollar) return _dollar_dollar.relation_id end - _t1716 = _t1715(msg) - fields1251 = _t1716 - unwrapped_fields1252 = fields1251 + _t1694 = _t1693(msg) + fields1235 = _t1694 + unwrapped_fields1236 = fields1235 write(pp, "(") write(pp, "demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1252) + pretty_relation_id(pp, unwrapped_fields1236) dedent!(pp) write(pp, ")") end @@ -4401,26 +4353,26 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1258 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1258) - write(pp, flat1258) + flat1242 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1242) + write(pp, flat1242) return nothing else - function _t1717(_dollar_dollar) + function _t1695(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.relation_id,) end - _t1718 = _t1717(msg) - fields1254 = _t1718 - unwrapped_fields1255 = fields1254 + _t1696 = _t1695(msg) + fields1238 = _t1696 + unwrapped_fields1239 = fields1238 write(pp, "(") write(pp, "output") indent_sexp!(pp) newline(pp) - field1256 = unwrapped_fields1255[1] - pretty_name(pp, field1256) + field1240 = unwrapped_fields1239[1] + pretty_name(pp, field1240) newline(pp) - field1257 = unwrapped_fields1255[2] - pretty_relation_id(pp, field1257) + field1241 = unwrapped_fields1239[2] + pretty_relation_id(pp, field1241) dedent!(pp) write(pp, ")") end @@ -4428,26 +4380,26 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1263 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1263) - write(pp, flat1263) + flat1247 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1247) + write(pp, flat1247) return nothing else - function _t1719(_dollar_dollar) + function _t1697(_dollar_dollar) return (_dollar_dollar.branch, _dollar_dollar.epoch,) end - _t1720 = _t1719(msg) - fields1259 = _t1720 - unwrapped_fields1260 = fields1259 + _t1698 = _t1697(msg) + fields1243 = _t1698 + unwrapped_fields1244 = fields1243 write(pp, "(") write(pp, "what_if") indent_sexp!(pp) newline(pp) - field1261 = unwrapped_fields1260[1] - pretty_name(pp, field1261) + field1245 = unwrapped_fields1244[1] + pretty_name(pp, field1245) newline(pp) - field1262 = unwrapped_fields1260[2] - pretty_epoch(pp, field1262) + field1246 = unwrapped_fields1244[2] + pretty_epoch(pp, field1246) dedent!(pp) write(pp, ")") end @@ -4455,34 +4407,34 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1269 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1269) - write(pp, flat1269) + flat1253 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1253) + write(pp, flat1253) return nothing else - function _t1721(_dollar_dollar) + function _t1699(_dollar_dollar) if _dollar_dollar.name != "abort" - _t1722 = _dollar_dollar.name + _t1700 = _dollar_dollar.name else - _t1722 = nothing + _t1700 = nothing end - return (_t1722, _dollar_dollar.relation_id,) + return (_t1700, _dollar_dollar.relation_id,) end - _t1723 = _t1721(msg) - fields1264 = _t1723 - unwrapped_fields1265 = fields1264 + _t1701 = _t1699(msg) + fields1248 = _t1701 + unwrapped_fields1249 = fields1248 write(pp, "(") write(pp, "abort") indent_sexp!(pp) - field1266 = unwrapped_fields1265[1] - if !isnothing(field1266) + field1250 = unwrapped_fields1249[1] + if !isnothing(field1250) newline(pp) - opt_val1267 = field1266 - pretty_name(pp, opt_val1267) + opt_val1251 = field1250 + pretty_name(pp, opt_val1251) end newline(pp) - field1268 = unwrapped_fields1265[2] - pretty_relation_id(pp, field1268) + field1252 = unwrapped_fields1249[2] + pretty_relation_id(pp, field1252) dedent!(pp) write(pp, ")") end @@ -4490,22 +4442,22 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1272 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1272) - write(pp, flat1272) + flat1256 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1256) + write(pp, flat1256) return nothing else - function _t1724(_dollar_dollar) + function _t1702(_dollar_dollar) return _get_oneof_field(_dollar_dollar, :csv_config) end - _t1725 = _t1724(msg) - fields1270 = _t1725 - unwrapped_fields1271 = fields1270 + _t1703 = _t1702(msg) + fields1254 = _t1703 + unwrapped_fields1255 = fields1254 write(pp, "(") write(pp, "export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped_fields1271) + pretty_export_csv_config(pp, unwrapped_fields1255) dedent!(pp) write(pp, ")") end @@ -4513,30 +4465,30 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1278 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1278) - write(pp, flat1278) + flat1262 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1262) + write(pp, flat1262) return nothing else - function _t1726(_dollar_dollar) - _t1727 = deconstruct_export_csv_config(pp, _dollar_dollar) - return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1727,) + function _t1704(_dollar_dollar) + _t1705 = deconstruct_export_csv_config(pp, _dollar_dollar) + return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1705,) end - _t1728 = _t1726(msg) - fields1273 = _t1728 - unwrapped_fields1274 = fields1273 + _t1706 = _t1704(msg) + fields1257 = _t1706 + unwrapped_fields1258 = fields1257 write(pp, "(") write(pp, "export_csv_config") indent_sexp!(pp) newline(pp) - field1275 = unwrapped_fields1274[1] - pretty_export_csv_path(pp, field1275) + field1259 = unwrapped_fields1258[1] + pretty_export_csv_path(pp, field1259) newline(pp) - field1276 = unwrapped_fields1274[2] - pretty_export_csv_columns(pp, field1276) + field1260 = unwrapped_fields1258[2] + pretty_export_csv_columns(pp, field1260) newline(pp) - field1277 = unwrapped_fields1274[3] - pretty_config_dict(pp, field1277) + field1261 = unwrapped_fields1258[3] + pretty_config_dict(pp, field1261) dedent!(pp) write(pp, ")") end @@ -4544,17 +4496,17 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1280 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1280) - write(pp, flat1280) + flat1264 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1264) + write(pp, flat1264) return nothing else - fields1279 = msg + fields1263 = msg write(pp, "(") write(pp, "path") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1279)) + write(pp, format_string(pp, fields1263)) dedent!(pp) write(pp, ")") end @@ -4562,23 +4514,23 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1284 = try_flat(pp, msg, pretty_export_csv_columns) - if !isnothing(flat1284) - write(pp, flat1284) + flat1268 = try_flat(pp, msg, pretty_export_csv_columns) + if !isnothing(flat1268) + write(pp, flat1268) return nothing else - fields1281 = msg + fields1265 = msg write(pp, "(") write(pp, "columns") indent_sexp!(pp) - if !isempty(fields1281) + if !isempty(fields1265) newline(pp) - for (i1729, elem1282) in enumerate(fields1281) - i1283 = i1729 - 1 - if (i1283 > 0) + for (i1707, elem1266) in enumerate(fields1265) + i1267 = i1707 - 1 + if (i1267 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1282) + pretty_export_csv_column(pp, elem1266) end end dedent!(pp) @@ -4588,26 +4540,26 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCS end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1289 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1289) - write(pp, flat1289) + flat1273 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1273) + write(pp, flat1273) return nothing else - function _t1730(_dollar_dollar) + function _t1708(_dollar_dollar) return (_dollar_dollar.column_name, _dollar_dollar.column_data,) end - _t1731 = _t1730(msg) - fields1285 = _t1731 - unwrapped_fields1286 = fields1285 + _t1709 = _t1708(msg) + fields1269 = _t1709 + unwrapped_fields1270 = fields1269 write(pp, "(") write(pp, "column") indent_sexp!(pp) newline(pp) - field1287 = unwrapped_fields1286[1] - write(pp, format_string(pp, field1287)) + field1271 = unwrapped_fields1270[1] + write(pp, format_string(pp, field1271)) newline(pp) - field1288 = unwrapped_fields1286[2] - pretty_relation_id(pp, field1288) + field1272 = unwrapped_fields1270[2] + pretty_relation_id(pp, field1272) dedent!(pp) write(pp, ")") end @@ -4620,12 +4572,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1770, _rid) in enumerate(msg.ids) - _idx = i1770 - 1 + for (i1747, _rid) in enumerate(msg.ids) + _idx = i1747 - 1 newline(pp) write(pp, "(") - _t1771 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1771) + _t1748 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1748) write(pp, " ") write(pp, format_string(pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -4698,8 +4650,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe newline(pp) write(pp, ":keys ") write(pp, "(") - for (i1772, _elem) in enumerate(msg.keys) - _idx = i1772 - 1 + for (i1749, _elem) in enumerate(msg.keys) + _idx = i1749 - 1 if (_idx > 0) write(pp, " ") end @@ -4709,8 +4661,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe newline(pp) write(pp, ":values ") write(pp, "(") - for (i1773, _elem) in enumerate(msg.values) - _idx = i1773 - 1 + for (i1750, _elem) in enumerate(msg.values) + _idx = i1750 - 1 if (_idx > 0) write(pp, " ") end @@ -4842,17 +4794,16 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.MonusDef) = pretty_monus_def(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Constraint) = pretty_constraint(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.Var}) = pretty_functional_dependency_keys(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Data) = pretty_data(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Proto.RelEDB) = pretty_rel_edb(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Vector{String}) = pretty_rel_edb_path(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.var"#Type"}) = pretty_rel_edb_types(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Proto.EDB) = pretty_edb(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Vector{String}) = pretty_edb_path(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.var"#Type"}) = pretty_edb_types(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.BeTreeRelation) = pretty_betree_relation(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.BeTreeInfo) = pretty_betree_info(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVData) = pretty_csv_data(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVLocator) = pretty_csvlocator(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVConfig) = pretty_csv_config(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.CSVColumn}) = pretty_csv_columns(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVColumn) = pretty_csv_column(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Tuple{Union{Nothing, Proto.RelationId}, Vector{Proto.var"#Type"}}) = pretty_csv_column_tail(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.GNFColumn}) = pretty_gnf_columns(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Proto.GNFColumn) = pretty_gnf_column(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Undefine) = pretty_undefine(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Context) = pretty_context(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Snapshot) = pretty_snapshot(pp, x) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl b/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl index f11882d0..dd57c823 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl @@ -132,10 +132,10 @@ end function global_ids(data::Data) dt = data.data_type isnothing(dt) && error("Data has no data_type set") - if dt.name == :rel_edb - rel_edb = dt[]::RelEDB - @assert !isnothing(rel_edb.target_id) - return [persistent_id(rel_edb.target_id)] + if dt.name == :edb + edb = dt[]::EDB + @assert !isnothing(edb.target_id) + return [persistent_id(edb.target_id)] elseif dt.name == :betree_relation betree_relation = dt[]::BeTreeRelation @assert !isnothing(betree_relation.name) @@ -156,5 +156,5 @@ end function _is_valid_data(data::Data) dt = data.data_type - return !isnothing(dt) && dt.name in [:rel_edb, :betree_relation, :csv_data] + return !isnothing(dt) && dt.name in [:edb, :betree_relation, :csv_data] end diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index 518de5f7..14fbfd20 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl @@ -1940,8 +1940,8 @@ end @test b1 != b5 end -@testitem "Equality for RelEDB" tags=[:ring1, :unit] begin - using LogicalQueryProtocol: RelEDB, RelationId, var"#Type", IntType +@testitem "Equality for EDB" tags=[:ring1, :unit] begin + using LogicalQueryProtocol: EDB, RelationId, var"#Type", IntType using ProtoBuf: OneOf r1 = RelationId(id_low=1, id_high=0) @@ -1949,11 +1949,11 @@ end r3 = RelationId(id_low=2, id_high=0) t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType())) - e1 = RelEDB(target_id=r1, path=["table", "column"], types=[t1]) - e2 = RelEDB(target_id=r2, path=["table", "column"], types=[t1]) - e3 = RelEDB(target_id=r3, path=["table", "column"], types=[t1]) - e4 = RelEDB(target_id=r1, path=["other", "column"], types=[t1]) - e5 = RelEDB(target_id=r1, path=["table", "column"], types=[t1]) + e1 = EDB(target_id=r1, path=["table", "column"], types=[t1]) + e2 = EDB(target_id=r2, path=["table", "column"], types=[t1]) + e3 = EDB(target_id=r3, path=["table", "column"], types=[t1]) + e4 = EDB(target_id=r1, path=["other", "column"], types=[t1]) + e5 = EDB(target_id=r1, path=["table", "column"], types=[t1]) # Equality and inequality @test e1 == e2 @@ -2013,8 +2013,8 @@ end @test b1 == b2 && b2 == b5 && b1 == b5 end -@testitem "Equality for CSVColumn" tags=[:ring1, :unit] begin - using LogicalQueryProtocol: CSVColumn, RelationId, var"#Type", IntType +@testitem "Equality for GNFColumn" tags=[:ring1, :unit] begin + using LogicalQueryProtocol: GNFColumn, RelationId, var"#Type", IntType using ProtoBuf: OneOf r1 = RelationId(id_low=1, id_high=0) @@ -2022,11 +2022,11 @@ end r3 = RelationId(id_low=2, id_high=0) t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType())) - c1 = CSVColumn(column_path=["age"], target_id=r1, types=[t1]) - c2 = CSVColumn(column_path=["age"], target_id=r2, types=[t1]) - c3 = CSVColumn(column_path=["name"], target_id=r1, types=[t1]) - c4 = CSVColumn(column_path=["age"], target_id=r3, types=[t1]) - c5 = CSVColumn(column_path=["age"], target_id=r1, types=[t1]) + c1 = GNFColumn(column_path=["age"], target_id=r1, types=[t1]) + c2 = GNFColumn(column_path=["age"], target_id=r2, types=[t1]) + c3 = GNFColumn(column_path=["name"], target_id=r1, types=[t1]) + c4 = GNFColumn(column_path=["age"], target_id=r3, types=[t1]) + c5 = GNFColumn(column_path=["age"], target_id=r1, types=[t1]) # Equality and inequality @test c1 == c2 @@ -2086,7 +2086,7 @@ end end @testitem "Equality for CSVData" tags=[:ring1, :unit] begin - using LogicalQueryProtocol: CSVData, CSVLocator, CSVConfig, CSVColumn, RelationId, var"#Type", IntType + using LogicalQueryProtocol: CSVData, CSVLocator, CSVConfig, GNFColumn, RelationId, var"#Type", IntType using ProtoBuf: OneOf loc1 = CSVLocator(paths=["/path/to/file.csv"], inline_data=UInt8[]) @@ -2096,7 +2096,7 @@ end cfg2 = CSVConfig(header_row=1, skip=0, new_line="\n", delimiter=",", quotechar="\"", escapechar="\\", comment="", missing_strings=[], decimal_separator=".", encoding="", compression="") r1 = RelationId(id_low=1, id_high=0) t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType())) - col1 = CSVColumn(column_path=["age"], target_id=r1, types=[t1]) + col1 = GNFColumn(column_path=["age"], target_id=r1, types=[t1]) d1 = CSVData(locator=loc1, config=cfg1, columns=[col1], asof="2024-01-01") d2 = CSVData(locator=loc2, config=cfg2, columns=[col1], asof="2024-01-01") @@ -2127,27 +2127,27 @@ end end @testitem "Equality for Data (OneOf type)" tags=[:ring1, :unit] begin - using LogicalQueryProtocol: Data, RelEDB, BeTreeRelation, CSVData, RelationId, BeTreeInfo, CSVLocator, CSVConfig, CSVColumn, var"#Type", IntType + using LogicalQueryProtocol: Data, EDB, BeTreeRelation, CSVData, RelationId, BeTreeInfo, CSVLocator, CSVConfig, GNFColumn, var"#Type", IntType using ProtoBuf: OneOf r1 = RelationId(id_low=1, id_high=0) t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType())) - edb1 = RelEDB(target_id=r1, path=["table"], types=[t1]) - edb2 = RelEDB(target_id=r1, path=["table"], types=[t1]) + edb1 = EDB(target_id=r1, path=["table"], types=[t1]) + edb2 = EDB(target_id=r1, path=["table"], types=[t1]) info1 = BeTreeInfo(key_types=[t1], value_types=[], storage_config=nothing, relation_locator=nothing) betree1 = BeTreeRelation(name=r1, relation_info=info1) loc1 = CSVLocator(paths=["/file.csv"], inline_data=UInt8[]) cfg1 = CSVConfig(header_row=1, skip=0, new_line="\n", delimiter=",", quotechar="\"", escapechar="\\", comment="", missing_strings=[], decimal_separator=".", encoding="", compression="") - col1 = CSVColumn(column_path=["col"], target_id=r1, types=[t1]) + col1 = GNFColumn(column_path=["col"], target_id=r1, types=[t1]) csv1 = CSVData(locator=loc1, config=cfg1, columns=[col1], asof="") - d1 = Data(data_type=OneOf(:rel_edb, edb1)) - d2 = Data(data_type=OneOf(:rel_edb, edb2)) + d1 = Data(data_type=OneOf(:edb, edb1)) + d2 = Data(data_type=OneOf(:edb, edb2)) d3 = Data(data_type=OneOf(:betree_relation, betree1)) d4 = Data(data_type=OneOf(:csv_data, csv1)) d5 = Data(data_type=nothing) d6 = Data(data_type=nothing) - d7 = Data(data_type=OneOf(:rel_edb, edb1)) + d7 = Data(data_type=OneOf(:edb, edb1)) # Same discriminant, same value @test d1 == d2 diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl index c002fb4e..45f21d45 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl @@ -186,13 +186,13 @@ end using ProtoBuf: OneOf pp = PrettyPrinter() - rel_edb = Proto.RelEDB( + edb = Proto.EDB( target_id=Proto.RelationId(UInt64(1), UInt64(0)), path=["base", "rel"], ) - msg = Proto.Data(OneOf(:rel_edb, rel_edb)) + msg = Proto.Data(OneOf(:edb, edb)) _pprint_dispatch(pp, msg) - @test startswith(get_output(pp), "(rel_edb") + @test startswith(get_output(pp), "(edb") end @testitem "Extra pretty - oneof: Read" setup=[PrettySetup] begin diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index bf5336bf..04f419fb 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -298,177 +298,177 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: Optional[logic_pb2.Value], default: int) -> int: if value is not None: assert value is not None - _t1348 = value.HasField("int_value") + _t1329 = value.HasField("int_value") else: - _t1348 = False - if _t1348: + _t1329 = False + if _t1329: assert value is not None return int(value.int_value) else: - _t1349 = None + _t1330 = None return int(default) def _extract_value_int64(self, value: Optional[logic_pb2.Value], default: int) -> int: if value is not None: assert value is not None - _t1350 = value.HasField("int_value") + _t1331 = value.HasField("int_value") else: - _t1350 = False - if _t1350: + _t1331 = False + if _t1331: assert value is not None return value.int_value else: - _t1351 = None + _t1332 = None return default def _extract_value_string(self, value: Optional[logic_pb2.Value], default: str) -> str: if value is not None: assert value is not None - _t1352 = value.HasField("string_value") + _t1333 = value.HasField("string_value") else: - _t1352 = False - if _t1352: + _t1333 = False + if _t1333: assert value is not None return value.string_value else: - _t1353 = None + _t1334 = None return default def _extract_value_boolean(self, value: Optional[logic_pb2.Value], default: bool) -> bool: if value is not None: assert value is not None - _t1354 = value.HasField("boolean_value") + _t1335 = value.HasField("boolean_value") else: - _t1354 = False - if _t1354: + _t1335 = False + if _t1335: assert value is not None return value.boolean_value else: - _t1355 = None + _t1336 = None return default def _extract_value_string_list(self, value: Optional[logic_pb2.Value], default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t1356 = value.HasField("string_value") + _t1337 = value.HasField("string_value") else: - _t1356 = False - if _t1356: + _t1337 = False + if _t1337: assert value is not None return [value.string_value] else: - _t1357 = None + _t1338 = None return default def _try_extract_value_int64(self, value: Optional[logic_pb2.Value]) -> Optional[int]: if value is not None: assert value is not None - _t1358 = value.HasField("int_value") + _t1339 = value.HasField("int_value") else: - _t1358 = False - if _t1358: + _t1339 = False + if _t1339: assert value is not None return value.int_value else: - _t1359 = None + _t1340 = None return None def _try_extract_value_float64(self, value: Optional[logic_pb2.Value]) -> Optional[float]: if value is not None: assert value is not None - _t1360 = value.HasField("float_value") + _t1341 = value.HasField("float_value") else: - _t1360 = False - if _t1360: + _t1341 = False + if _t1341: assert value is not None return value.float_value else: - _t1361 = None + _t1342 = None return None def _try_extract_value_bytes(self, value: Optional[logic_pb2.Value]) -> Optional[bytes]: if value is not None: assert value is not None - _t1362 = value.HasField("string_value") + _t1343 = value.HasField("string_value") else: - _t1362 = False - if _t1362: + _t1343 = False + if _t1343: assert value is not None return value.string_value.encode() else: - _t1363 = None + _t1344 = None return None def _try_extract_value_uint128(self, value: Optional[logic_pb2.Value]) -> Optional[logic_pb2.UInt128Value]: if value is not None: assert value is not None - _t1364 = value.HasField("uint128_value") + _t1345 = value.HasField("uint128_value") else: - _t1364 = False - if _t1364: + _t1345 = False + if _t1345: assert value is not None return value.uint128_value else: - _t1365 = None + _t1346 = None return None def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t1366 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t1366 - _t1367 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t1367 - _t1368 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t1368 - _t1369 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t1369 - _t1370 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t1370 - _t1371 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t1371 - _t1372 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t1372 - _t1373 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t1373 - _t1374 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t1374 - _t1375 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t1375 - _t1376 = self._extract_value_string(config.get("csv_compression"), "auto") - compression = _t1376 - _t1377 = 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) - return _t1377 + _t1347 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t1347 + _t1348 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t1348 + _t1349 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t1349 + _t1350 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t1350 + _t1351 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t1351 + _t1352 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t1352 + _t1353 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t1353 + _t1354 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t1354 + _t1355 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t1355 + _t1356 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t1356 + _t1357 = self._extract_value_string(config.get("csv_compression"), "auto") + compression = _t1357 + _t1358 = 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) + return _t1358 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) - _t1378 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t1378 - _t1379 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t1379 - _t1380 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t1380 - _t1381 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t1381 - _t1382 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t1382 - _t1383 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t1383 - _t1384 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t1384 - _t1385 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t1385 - _t1386 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t1386 - _t1387 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t1387 - _t1388 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t1388 + _t1359 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t1359 + _t1360 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t1360 + _t1361 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t1361 + _t1362 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t1362 + _t1363 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t1363 + _t1364 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t1364 + _t1365 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t1365 + _t1366 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t1366 + _t1367 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t1367 + _t1368 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t1368 + _t1369 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t1369 def default_configure(self) -> transactions_pb2.Configure: - _t1389 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t1389 - _t1390 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t1390 + _t1370 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t1370 + _t1371 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t1371 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -485,42 +485,31 @@ 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 - _t1391 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t1391 - _t1392 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t1392 - _t1393 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t1393 + _t1372 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t1372 + _t1373 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t1373 + _t1374 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t1374 def 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) - _t1394 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t1394 - _t1395 = self._extract_value_string(config.get("compression"), "") - compression = _t1395 - _t1396 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t1396 - _t1397 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t1397 - _t1398 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t1398 - _t1399 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t1399 - _t1400 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t1400 - _t1401 = 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 _t1401 - - def construct_csv_column(self, path: Sequence[str], tail: Optional[tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]]) -> logic_pb2.CSVColumn: - if tail is not None: - assert tail is not None - t = tail - _t1403 = logic_pb2.CSVColumn(column_path=path, target_id=t[0], types=t[1]) - return _t1403 - else: - _t1402 = None - _t1404 = logic_pb2.CSVColumn(column_path=path, target_id=None, types=[]) - return _t1404 + _t1375 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t1375 + _t1376 = self._extract_value_string(config.get("compression"), "") + compression = _t1376 + _t1377 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t1377 + _t1378 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t1378 + _t1379 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t1379 + _t1380 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t1380 + _t1381 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t1381 + _t1382 = 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 _t1382 # --- Parse methods --- @@ -528,2407 +517,2371 @@ def parse_transaction(self) -> transactions_pb2.Transaction: self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t737 = self.parse_configure() - _t736 = _t737 + _t725 = self.parse_configure() + _t724 = _t725 else: - _t736 = None - configure368 = _t736 + _t724 = None + configure362 = _t724 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t739 = self.parse_sync() - _t738 = _t739 - else: - _t738 = None - sync369 = _t738 - xs370 = [] - cond371 = self.match_lookahead_literal("(", 0) - while cond371: - _t740 = self.parse_epoch() - item372 = _t740 - xs370.append(item372) - cond371 = self.match_lookahead_literal("(", 0) - epochs373 = xs370 - self.consume_literal(")") - _t741 = self.default_configure() - _t742 = transactions_pb2.Transaction(epochs=epochs373, configure=(configure368 if configure368 is not None else _t741), sync=sync369) - return _t742 + _t727 = self.parse_sync() + _t726 = _t727 + else: + _t726 = None + sync363 = _t726 + xs364 = [] + cond365 = self.match_lookahead_literal("(", 0) + while cond365: + _t728 = self.parse_epoch() + item366 = _t728 + xs364.append(item366) + cond365 = self.match_lookahead_literal("(", 0) + epochs367 = xs364 + self.consume_literal(")") + _t729 = self.default_configure() + _t730 = transactions_pb2.Transaction(epochs=epochs367, configure=(configure362 if configure362 is not None else _t729), sync=sync363) + return _t730 def parse_configure(self) -> transactions_pb2.Configure: self.consume_literal("(") self.consume_literal("configure") - _t743 = self.parse_config_dict() - config_dict374 = _t743 + _t731 = self.parse_config_dict() + config_dict368 = _t731 self.consume_literal(")") - _t744 = self.construct_configure(config_dict374) - return _t744 + _t732 = self.construct_configure(config_dict368) + return _t732 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs375 = [] - cond376 = self.match_lookahead_literal(":", 0) - while cond376: - _t745 = self.parse_config_key_value() - item377 = _t745 - xs375.append(item377) - cond376 = self.match_lookahead_literal(":", 0) - config_key_values378 = xs375 + xs369 = [] + cond370 = self.match_lookahead_literal(":", 0) + while cond370: + _t733 = self.parse_config_key_value() + item371 = _t733 + xs369.append(item371) + cond370 = self.match_lookahead_literal(":", 0) + config_key_values372 = xs369 self.consume_literal("}") - return config_key_values378 + return config_key_values372 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol379 = self.consume_terminal("SYMBOL") - _t746 = self.parse_value() - value380 = _t746 - return (symbol379, value380,) + symbol373 = self.consume_terminal("SYMBOL") + _t734 = self.parse_value() + value374 = _t734 + return (symbol373, value374,) def parse_value(self) -> logic_pb2.Value: if self.match_lookahead_literal("true", 0): - _t747 = 9 + _t735 = 9 else: if self.match_lookahead_literal("missing", 0): - _t748 = 8 + _t736 = 8 else: if self.match_lookahead_literal("false", 0): - _t749 = 9 + _t737 = 9 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t751 = 1 + _t739 = 1 else: if self.match_lookahead_literal("date", 1): - _t752 = 0 + _t740 = 0 else: - _t752 = -1 - _t751 = _t752 - _t750 = _t751 + _t740 = -1 + _t739 = _t740 + _t738 = _t739 else: if self.match_lookahead_terminal("UINT128", 0): - _t753 = 5 + _t741 = 5 else: if self.match_lookahead_terminal("STRING", 0): - _t754 = 2 + _t742 = 2 else: if self.match_lookahead_terminal("INT128", 0): - _t755 = 6 + _t743 = 6 else: if self.match_lookahead_terminal("INT", 0): - _t756 = 3 + _t744 = 3 else: if self.match_lookahead_terminal("FLOAT", 0): - _t757 = 4 + _t745 = 4 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t758 = 7 + _t746 = 7 else: - _t758 = -1 - _t757 = _t758 - _t756 = _t757 - _t755 = _t756 - _t754 = _t755 - _t753 = _t754 - _t750 = _t753 - _t749 = _t750 - _t748 = _t749 - _t747 = _t748 - prediction381 = _t747 - if prediction381 == 9: - _t760 = self.parse_boolean_value() - boolean_value390 = _t760 - _t761 = logic_pb2.Value(boolean_value=boolean_value390) - _t759 = _t761 - else: - if prediction381 == 8: + _t746 = -1 + _t745 = _t746 + _t744 = _t745 + _t743 = _t744 + _t742 = _t743 + _t741 = _t742 + _t738 = _t741 + _t737 = _t738 + _t736 = _t737 + _t735 = _t736 + prediction375 = _t735 + if prediction375 == 9: + _t748 = self.parse_boolean_value() + boolean_value384 = _t748 + _t749 = logic_pb2.Value(boolean_value=boolean_value384) + _t747 = _t749 + else: + if prediction375 == 8: self.consume_literal("missing") - _t763 = logic_pb2.MissingValue() - _t764 = logic_pb2.Value(missing_value=_t763) - _t762 = _t764 + _t751 = logic_pb2.MissingValue() + _t752 = logic_pb2.Value(missing_value=_t751) + _t750 = _t752 else: - if prediction381 == 7: - decimal389 = self.consume_terminal("DECIMAL") - _t766 = logic_pb2.Value(decimal_value=decimal389) - _t765 = _t766 + if prediction375 == 7: + decimal383 = self.consume_terminal("DECIMAL") + _t754 = logic_pb2.Value(decimal_value=decimal383) + _t753 = _t754 else: - if prediction381 == 6: - int128388 = self.consume_terminal("INT128") - _t768 = logic_pb2.Value(int128_value=int128388) - _t767 = _t768 + if prediction375 == 6: + int128382 = self.consume_terminal("INT128") + _t756 = logic_pb2.Value(int128_value=int128382) + _t755 = _t756 else: - if prediction381 == 5: - uint128387 = self.consume_terminal("UINT128") - _t770 = logic_pb2.Value(uint128_value=uint128387) - _t769 = _t770 + if prediction375 == 5: + uint128381 = self.consume_terminal("UINT128") + _t758 = logic_pb2.Value(uint128_value=uint128381) + _t757 = _t758 else: - if prediction381 == 4: - float386 = self.consume_terminal("FLOAT") - _t772 = logic_pb2.Value(float_value=float386) - _t771 = _t772 + if prediction375 == 4: + float380 = self.consume_terminal("FLOAT") + _t760 = logic_pb2.Value(float_value=float380) + _t759 = _t760 else: - if prediction381 == 3: - int385 = self.consume_terminal("INT") - _t774 = logic_pb2.Value(int_value=int385) - _t773 = _t774 + if prediction375 == 3: + int379 = self.consume_terminal("INT") + _t762 = logic_pb2.Value(int_value=int379) + _t761 = _t762 else: - if prediction381 == 2: - string384 = self.consume_terminal("STRING") - _t776 = logic_pb2.Value(string_value=string384) - _t775 = _t776 + if prediction375 == 2: + string378 = self.consume_terminal("STRING") + _t764 = logic_pb2.Value(string_value=string378) + _t763 = _t764 else: - if prediction381 == 1: - _t778 = self.parse_datetime() - datetime383 = _t778 - _t779 = logic_pb2.Value(datetime_value=datetime383) - _t777 = _t779 + if prediction375 == 1: + _t766 = self.parse_datetime() + datetime377 = _t766 + _t767 = logic_pb2.Value(datetime_value=datetime377) + _t765 = _t767 else: - if prediction381 == 0: - _t781 = self.parse_date() - date382 = _t781 - _t782 = logic_pb2.Value(date_value=date382) - _t780 = _t782 + if prediction375 == 0: + _t769 = self.parse_date() + date376 = _t769 + _t770 = logic_pb2.Value(date_value=date376) + _t768 = _t770 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t777 = _t780 - _t775 = _t777 - _t773 = _t775 - _t771 = _t773 - _t769 = _t771 - _t767 = _t769 - _t765 = _t767 - _t762 = _t765 - _t759 = _t762 - return _t759 + _t765 = _t768 + _t763 = _t765 + _t761 = _t763 + _t759 = _t761 + _t757 = _t759 + _t755 = _t757 + _t753 = _t755 + _t750 = _t753 + _t747 = _t750 + return _t747 def parse_date(self) -> logic_pb2.DateValue: self.consume_literal("(") self.consume_literal("date") - int391 = self.consume_terminal("INT") - int_3392 = self.consume_terminal("INT") - int_4393 = self.consume_terminal("INT") + int385 = self.consume_terminal("INT") + int_3386 = self.consume_terminal("INT") + int_4387 = self.consume_terminal("INT") self.consume_literal(")") - _t783 = logic_pb2.DateValue(year=int(int391), month=int(int_3392), day=int(int_4393)) - return _t783 + _t771 = logic_pb2.DateValue(year=int(int385), month=int(int_3386), day=int(int_4387)) + return _t771 def parse_datetime(self) -> logic_pb2.DateTimeValue: self.consume_literal("(") self.consume_literal("datetime") - int394 = self.consume_terminal("INT") - int_3395 = self.consume_terminal("INT") - int_4396 = self.consume_terminal("INT") - int_5397 = self.consume_terminal("INT") - int_6398 = self.consume_terminal("INT") - int_7399 = self.consume_terminal("INT") + int388 = self.consume_terminal("INT") + int_3389 = self.consume_terminal("INT") + int_4390 = self.consume_terminal("INT") + int_5391 = self.consume_terminal("INT") + int_6392 = self.consume_terminal("INT") + int_7393 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t784 = self.consume_terminal("INT") + _t772 = self.consume_terminal("INT") else: - _t784 = None - int_8400 = _t784 + _t772 = None + int_8394 = _t772 self.consume_literal(")") - _t785 = logic_pb2.DateTimeValue(year=int(int394), month=int(int_3395), day=int(int_4396), hour=int(int_5397), minute=int(int_6398), second=int(int_7399), microsecond=int((int_8400 if int_8400 is not None else 0))) - return _t785 + _t773 = logic_pb2.DateTimeValue(year=int(int388), month=int(int_3389), day=int(int_4390), hour=int(int_5391), minute=int(int_6392), second=int(int_7393), microsecond=int((int_8394 if int_8394 is not None else 0))) + return _t773 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t786 = 0 + _t774 = 0 else: if self.match_lookahead_literal("false", 0): - _t787 = 1 + _t775 = 1 else: - _t787 = -1 - _t786 = _t787 - prediction401 = _t786 - if prediction401 == 1: + _t775 = -1 + _t774 = _t775 + prediction395 = _t774 + if prediction395 == 1: self.consume_literal("false") - _t788 = False + _t776 = False else: - if prediction401 == 0: + if prediction395 == 0: self.consume_literal("true") - _t789 = True + _t777 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t788 = _t789 - return _t788 + _t776 = _t777 + return _t776 def parse_sync(self) -> transactions_pb2.Sync: self.consume_literal("(") self.consume_literal("sync") - xs402 = [] - cond403 = self.match_lookahead_literal(":", 0) - while cond403: - _t790 = self.parse_fragment_id() - item404 = _t790 - xs402.append(item404) - cond403 = self.match_lookahead_literal(":", 0) - fragment_ids405 = xs402 - self.consume_literal(")") - _t791 = transactions_pb2.Sync(fragments=fragment_ids405) - return _t791 + xs396 = [] + cond397 = self.match_lookahead_literal(":", 0) + while cond397: + _t778 = self.parse_fragment_id() + item398 = _t778 + xs396.append(item398) + cond397 = self.match_lookahead_literal(":", 0) + fragment_ids399 = xs396 + self.consume_literal(")") + _t779 = transactions_pb2.Sync(fragments=fragment_ids399) + return _t779 def parse_fragment_id(self) -> fragments_pb2.FragmentId: self.consume_literal(":") - symbol406 = self.consume_terminal("SYMBOL") - return fragments_pb2.FragmentId(id=symbol406.encode()) + symbol400 = self.consume_terminal("SYMBOL") + return fragments_pb2.FragmentId(id=symbol400.encode()) def parse_epoch(self) -> transactions_pb2.Epoch: self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t793 = self.parse_epoch_writes() - _t792 = _t793 + _t781 = self.parse_epoch_writes() + _t780 = _t781 else: - _t792 = None - epoch_writes407 = _t792 + _t780 = None + epoch_writes401 = _t780 if self.match_lookahead_literal("(", 0): - _t795 = self.parse_epoch_reads() - _t794 = _t795 + _t783 = self.parse_epoch_reads() + _t782 = _t783 else: - _t794 = None - epoch_reads408 = _t794 + _t782 = None + epoch_reads402 = _t782 self.consume_literal(")") - _t796 = transactions_pb2.Epoch(writes=(epoch_writes407 if epoch_writes407 is not None else []), reads=(epoch_reads408 if epoch_reads408 is not None else [])) - return _t796 + _t784 = transactions_pb2.Epoch(writes=(epoch_writes401 if epoch_writes401 is not None else []), reads=(epoch_reads402 if epoch_reads402 is not None else [])) + return _t784 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs409 = [] - cond410 = self.match_lookahead_literal("(", 0) - while cond410: - _t797 = self.parse_write() - item411 = _t797 - xs409.append(item411) - cond410 = self.match_lookahead_literal("(", 0) - writes412 = xs409 + xs403 = [] + cond404 = self.match_lookahead_literal("(", 0) + while cond404: + _t785 = self.parse_write() + item405 = _t785 + xs403.append(item405) + cond404 = self.match_lookahead_literal("(", 0) + writes406 = xs403 self.consume_literal(")") - return writes412 + return writes406 def parse_write(self) -> transactions_pb2.Write: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t799 = 1 + _t787 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t800 = 3 + _t788 = 3 else: if self.match_lookahead_literal("define", 1): - _t801 = 0 + _t789 = 0 else: if self.match_lookahead_literal("context", 1): - _t802 = 2 + _t790 = 2 else: - _t802 = -1 - _t801 = _t802 - _t800 = _t801 - _t799 = _t800 - _t798 = _t799 - else: - _t798 = -1 - prediction413 = _t798 - if prediction413 == 3: - _t804 = self.parse_snapshot() - snapshot417 = _t804 - _t805 = transactions_pb2.Write(snapshot=snapshot417) - _t803 = _t805 - else: - if prediction413 == 2: - _t807 = self.parse_context() - context416 = _t807 - _t808 = transactions_pb2.Write(context=context416) - _t806 = _t808 + _t790 = -1 + _t789 = _t790 + _t788 = _t789 + _t787 = _t788 + _t786 = _t787 + else: + _t786 = -1 + prediction407 = _t786 + if prediction407 == 3: + _t792 = self.parse_snapshot() + snapshot411 = _t792 + _t793 = transactions_pb2.Write(snapshot=snapshot411) + _t791 = _t793 + else: + if prediction407 == 2: + _t795 = self.parse_context() + context410 = _t795 + _t796 = transactions_pb2.Write(context=context410) + _t794 = _t796 else: - if prediction413 == 1: - _t810 = self.parse_undefine() - undefine415 = _t810 - _t811 = transactions_pb2.Write(undefine=undefine415) - _t809 = _t811 + if prediction407 == 1: + _t798 = self.parse_undefine() + undefine409 = _t798 + _t799 = transactions_pb2.Write(undefine=undefine409) + _t797 = _t799 else: - if prediction413 == 0: - _t813 = self.parse_define() - define414 = _t813 - _t814 = transactions_pb2.Write(define=define414) - _t812 = _t814 + if prediction407 == 0: + _t801 = self.parse_define() + define408 = _t801 + _t802 = transactions_pb2.Write(define=define408) + _t800 = _t802 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t809 = _t812 - _t806 = _t809 - _t803 = _t806 - return _t803 + _t797 = _t800 + _t794 = _t797 + _t791 = _t794 + return _t791 def parse_define(self) -> transactions_pb2.Define: self.consume_literal("(") self.consume_literal("define") - _t815 = self.parse_fragment() - fragment418 = _t815 + _t803 = self.parse_fragment() + fragment412 = _t803 self.consume_literal(")") - _t816 = transactions_pb2.Define(fragment=fragment418) - return _t816 + _t804 = transactions_pb2.Define(fragment=fragment412) + return _t804 def parse_fragment(self) -> fragments_pb2.Fragment: self.consume_literal("(") self.consume_literal("fragment") - _t817 = self.parse_new_fragment_id() - new_fragment_id419 = _t817 - xs420 = [] - cond421 = self.match_lookahead_literal("(", 0) - while cond421: - _t818 = self.parse_declaration() - item422 = _t818 - xs420.append(item422) - cond421 = self.match_lookahead_literal("(", 0) - declarations423 = xs420 - self.consume_literal(")") - return self.construct_fragment(new_fragment_id419, declarations423) + _t805 = self.parse_new_fragment_id() + new_fragment_id413 = _t805 + xs414 = [] + cond415 = self.match_lookahead_literal("(", 0) + while cond415: + _t806 = self.parse_declaration() + item416 = _t806 + xs414.append(item416) + cond415 = self.match_lookahead_literal("(", 0) + declarations417 = xs414 + self.consume_literal(")") + return self.construct_fragment(new_fragment_id413, declarations417) def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - _t819 = self.parse_fragment_id() - fragment_id424 = _t819 - self.start_fragment(fragment_id424) - return fragment_id424 + _t807 = self.parse_fragment_id() + fragment_id418 = _t807 + self.start_fragment(fragment_id418) + return fragment_id418 def parse_declaration(self) -> logic_pb2.Declaration: if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("rel_edb", 1): - _t821 = 3 + if self.match_lookahead_literal("functional_dependency", 1): + _t809 = 2 else: - if self.match_lookahead_literal("functional_dependency", 1): - _t822 = 2 + if self.match_lookahead_literal("edb", 1): + _t810 = 3 else: if self.match_lookahead_literal("def", 1): - _t823 = 0 + _t811 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t824 = 3 + _t812 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t825 = 3 + _t813 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t826 = 1 + _t814 = 1 else: - _t826 = -1 - _t825 = _t826 - _t824 = _t825 - _t823 = _t824 - _t822 = _t823 - _t821 = _t822 - _t820 = _t821 - else: - _t820 = -1 - prediction425 = _t820 - if prediction425 == 3: - _t828 = self.parse_data() - data429 = _t828 - _t829 = logic_pb2.Declaration(data=data429) - _t827 = _t829 - else: - if prediction425 == 2: - _t831 = self.parse_constraint() - constraint428 = _t831 - _t832 = logic_pb2.Declaration(constraint=constraint428) - _t830 = _t832 + _t814 = -1 + _t813 = _t814 + _t812 = _t813 + _t811 = _t812 + _t810 = _t811 + _t809 = _t810 + _t808 = _t809 + else: + _t808 = -1 + prediction419 = _t808 + if prediction419 == 3: + _t816 = self.parse_data() + data423 = _t816 + _t817 = logic_pb2.Declaration(data=data423) + _t815 = _t817 + else: + if prediction419 == 2: + _t819 = self.parse_constraint() + constraint422 = _t819 + _t820 = logic_pb2.Declaration(constraint=constraint422) + _t818 = _t820 else: - if prediction425 == 1: - _t834 = self.parse_algorithm() - algorithm427 = _t834 - _t835 = logic_pb2.Declaration(algorithm=algorithm427) - _t833 = _t835 + if prediction419 == 1: + _t822 = self.parse_algorithm() + algorithm421 = _t822 + _t823 = logic_pb2.Declaration(algorithm=algorithm421) + _t821 = _t823 else: - if prediction425 == 0: - _t837 = self.parse_def() - def426 = _t837 - _t838 = logic_pb2.Declaration() - getattr(_t838, 'def').CopyFrom(def426) - _t836 = _t838 + if prediction419 == 0: + _t825 = self.parse_def() + def420 = _t825 + _t826 = logic_pb2.Declaration() + getattr(_t826, 'def').CopyFrom(def420) + _t824 = _t826 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t833 = _t836 - _t830 = _t833 - _t827 = _t830 - return _t827 + _t821 = _t824 + _t818 = _t821 + _t815 = _t818 + return _t815 def parse_def(self) -> logic_pb2.Def: self.consume_literal("(") self.consume_literal("def") - _t839 = self.parse_relation_id() - relation_id430 = _t839 - _t840 = self.parse_abstraction() - abstraction431 = _t840 + _t827 = self.parse_relation_id() + relation_id424 = _t827 + _t828 = self.parse_abstraction() + abstraction425 = _t828 if self.match_lookahead_literal("(", 0): - _t842 = self.parse_attrs() - _t841 = _t842 + _t830 = self.parse_attrs() + _t829 = _t830 else: - _t841 = None - attrs432 = _t841 + _t829 = None + attrs426 = _t829 self.consume_literal(")") - _t843 = logic_pb2.Def(name=relation_id430, body=abstraction431, attrs=(attrs432 if attrs432 is not None else [])) - return _t843 + _t831 = logic_pb2.Def(name=relation_id424, body=abstraction425, attrs=(attrs426 if attrs426 is not None else [])) + return _t831 def parse_relation_id(self) -> logic_pb2.RelationId: if self.match_lookahead_literal(":", 0): - _t844 = 0 + _t832 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t845 = 1 + _t833 = 1 else: - _t845 = -1 - _t844 = _t845 - prediction433 = _t844 - if prediction433 == 1: - uint128435 = self.consume_terminal("UINT128") - _t846 = logic_pb2.RelationId(id_low=uint128435.low, id_high=uint128435.high) - else: - if prediction433 == 0: + _t833 = -1 + _t832 = _t833 + prediction427 = _t832 + if prediction427 == 1: + uint128429 = self.consume_terminal("UINT128") + _t834 = logic_pb2.RelationId(id_low=uint128429.low, id_high=uint128429.high) + else: + if prediction427 == 0: self.consume_literal(":") - symbol434 = self.consume_terminal("SYMBOL") - _t847 = self.relation_id_from_string(symbol434) + symbol428 = self.consume_terminal("SYMBOL") + _t835 = self.relation_id_from_string(symbol428) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t846 = _t847 - return _t846 + _t834 = _t835 + return _t834 def parse_abstraction(self) -> logic_pb2.Abstraction: self.consume_literal("(") - _t848 = self.parse_bindings() - bindings436 = _t848 - _t849 = self.parse_formula() - formula437 = _t849 + _t836 = self.parse_bindings() + bindings430 = _t836 + _t837 = self.parse_formula() + formula431 = _t837 self.consume_literal(")") - _t850 = logic_pb2.Abstraction(vars=(list(bindings436[0]) + list(bindings436[1] if bindings436[1] is not None else [])), value=formula437) - return _t850 + _t838 = logic_pb2.Abstraction(vars=(list(bindings430[0]) + list(bindings430[1] if bindings430[1] is not None else [])), value=formula431) + return _t838 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs438 = [] - cond439 = self.match_lookahead_terminal("SYMBOL", 0) - while cond439: - _t851 = self.parse_binding() - item440 = _t851 - xs438.append(item440) - cond439 = self.match_lookahead_terminal("SYMBOL", 0) - bindings441 = xs438 + xs432 = [] + cond433 = self.match_lookahead_terminal("SYMBOL", 0) + while cond433: + _t839 = self.parse_binding() + item434 = _t839 + xs432.append(item434) + cond433 = self.match_lookahead_terminal("SYMBOL", 0) + bindings435 = xs432 if self.match_lookahead_literal("|", 0): - _t853 = self.parse_value_bindings() - _t852 = _t853 + _t841 = self.parse_value_bindings() + _t840 = _t841 else: - _t852 = None - value_bindings442 = _t852 + _t840 = None + value_bindings436 = _t840 self.consume_literal("]") - return (bindings441, (value_bindings442 if value_bindings442 is not None else []),) + return (bindings435, (value_bindings436 if value_bindings436 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - symbol443 = self.consume_terminal("SYMBOL") + symbol437 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t854 = self.parse_type() - type444 = _t854 - _t855 = logic_pb2.Var(name=symbol443) - _t856 = logic_pb2.Binding(var=_t855, type=type444) - return _t856 + _t842 = self.parse_type() + type438 = _t842 + _t843 = logic_pb2.Var(name=symbol437) + _t844 = logic_pb2.Binding(var=_t843, type=type438) + return _t844 def parse_type(self) -> logic_pb2.Type: if self.match_lookahead_literal("UNKNOWN", 0): - _t857 = 0 + _t845 = 0 else: if self.match_lookahead_literal("UINT128", 0): - _t858 = 4 + _t846 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t859 = 1 + _t847 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t860 = 8 + _t848 = 8 else: if self.match_lookahead_literal("INT128", 0): - _t861 = 5 + _t849 = 5 else: if self.match_lookahead_literal("INT", 0): - _t862 = 2 + _t850 = 2 else: if self.match_lookahead_literal("FLOAT", 0): - _t863 = 3 + _t851 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t864 = 7 + _t852 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t865 = 6 + _t853 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t866 = 10 + _t854 = 10 else: if self.match_lookahead_literal("(", 0): - _t867 = 9 + _t855 = 9 else: - _t867 = -1 - _t866 = _t867 - _t865 = _t866 - _t864 = _t865 - _t863 = _t864 - _t862 = _t863 - _t861 = _t862 - _t860 = _t861 - _t859 = _t860 - _t858 = _t859 - _t857 = _t858 - prediction445 = _t857 - if prediction445 == 10: - _t869 = self.parse_boolean_type() - boolean_type456 = _t869 - _t870 = logic_pb2.Type(boolean_type=boolean_type456) - _t868 = _t870 - else: - if prediction445 == 9: - _t872 = self.parse_decimal_type() - decimal_type455 = _t872 - _t873 = logic_pb2.Type(decimal_type=decimal_type455) - _t871 = _t873 + _t855 = -1 + _t854 = _t855 + _t853 = _t854 + _t852 = _t853 + _t851 = _t852 + _t850 = _t851 + _t849 = _t850 + _t848 = _t849 + _t847 = _t848 + _t846 = _t847 + _t845 = _t846 + prediction439 = _t845 + if prediction439 == 10: + _t857 = self.parse_boolean_type() + boolean_type450 = _t857 + _t858 = logic_pb2.Type(boolean_type=boolean_type450) + _t856 = _t858 + else: + if prediction439 == 9: + _t860 = self.parse_decimal_type() + decimal_type449 = _t860 + _t861 = logic_pb2.Type(decimal_type=decimal_type449) + _t859 = _t861 else: - if prediction445 == 8: - _t875 = self.parse_missing_type() - missing_type454 = _t875 - _t876 = logic_pb2.Type(missing_type=missing_type454) - _t874 = _t876 + if prediction439 == 8: + _t863 = self.parse_missing_type() + missing_type448 = _t863 + _t864 = logic_pb2.Type(missing_type=missing_type448) + _t862 = _t864 else: - if prediction445 == 7: - _t878 = self.parse_datetime_type() - datetime_type453 = _t878 - _t879 = logic_pb2.Type(datetime_type=datetime_type453) - _t877 = _t879 + if prediction439 == 7: + _t866 = self.parse_datetime_type() + datetime_type447 = _t866 + _t867 = logic_pb2.Type(datetime_type=datetime_type447) + _t865 = _t867 else: - if prediction445 == 6: - _t881 = self.parse_date_type() - date_type452 = _t881 - _t882 = logic_pb2.Type(date_type=date_type452) - _t880 = _t882 + if prediction439 == 6: + _t869 = self.parse_date_type() + date_type446 = _t869 + _t870 = logic_pb2.Type(date_type=date_type446) + _t868 = _t870 else: - if prediction445 == 5: - _t884 = self.parse_int128_type() - int128_type451 = _t884 - _t885 = logic_pb2.Type(int128_type=int128_type451) - _t883 = _t885 + if prediction439 == 5: + _t872 = self.parse_int128_type() + int128_type445 = _t872 + _t873 = logic_pb2.Type(int128_type=int128_type445) + _t871 = _t873 else: - if prediction445 == 4: - _t887 = self.parse_uint128_type() - uint128_type450 = _t887 - _t888 = logic_pb2.Type(uint128_type=uint128_type450) - _t886 = _t888 + if prediction439 == 4: + _t875 = self.parse_uint128_type() + uint128_type444 = _t875 + _t876 = logic_pb2.Type(uint128_type=uint128_type444) + _t874 = _t876 else: - if prediction445 == 3: - _t890 = self.parse_float_type() - float_type449 = _t890 - _t891 = logic_pb2.Type(float_type=float_type449) - _t889 = _t891 + if prediction439 == 3: + _t878 = self.parse_float_type() + float_type443 = _t878 + _t879 = logic_pb2.Type(float_type=float_type443) + _t877 = _t879 else: - if prediction445 == 2: - _t893 = self.parse_int_type() - int_type448 = _t893 - _t894 = logic_pb2.Type(int_type=int_type448) - _t892 = _t894 + if prediction439 == 2: + _t881 = self.parse_int_type() + int_type442 = _t881 + _t882 = logic_pb2.Type(int_type=int_type442) + _t880 = _t882 else: - if prediction445 == 1: - _t896 = self.parse_string_type() - string_type447 = _t896 - _t897 = logic_pb2.Type(string_type=string_type447) - _t895 = _t897 + if prediction439 == 1: + _t884 = self.parse_string_type() + string_type441 = _t884 + _t885 = logic_pb2.Type(string_type=string_type441) + _t883 = _t885 else: - if prediction445 == 0: - _t899 = self.parse_unspecified_type() - unspecified_type446 = _t899 - _t900 = logic_pb2.Type(unspecified_type=unspecified_type446) - _t898 = _t900 + if prediction439 == 0: + _t887 = self.parse_unspecified_type() + unspecified_type440 = _t887 + _t888 = logic_pb2.Type(unspecified_type=unspecified_type440) + _t886 = _t888 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t895 = _t898 - _t892 = _t895 - _t889 = _t892 - _t886 = _t889 - _t883 = _t886 - _t880 = _t883 - _t877 = _t880 - _t874 = _t877 - _t871 = _t874 - _t868 = _t871 - return _t868 + _t883 = _t886 + _t880 = _t883 + _t877 = _t880 + _t874 = _t877 + _t871 = _t874 + _t868 = _t871 + _t865 = _t868 + _t862 = _t865 + _t859 = _t862 + _t856 = _t859 + return _t856 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: self.consume_literal("UNKNOWN") - _t901 = logic_pb2.UnspecifiedType() - return _t901 + _t889 = logic_pb2.UnspecifiedType() + return _t889 def parse_string_type(self) -> logic_pb2.StringType: self.consume_literal("STRING") - _t902 = logic_pb2.StringType() - return _t902 + _t890 = logic_pb2.StringType() + return _t890 def parse_int_type(self) -> logic_pb2.IntType: self.consume_literal("INT") - _t903 = logic_pb2.IntType() - return _t903 + _t891 = logic_pb2.IntType() + return _t891 def parse_float_type(self) -> logic_pb2.FloatType: self.consume_literal("FLOAT") - _t904 = logic_pb2.FloatType() - return _t904 + _t892 = logic_pb2.FloatType() + return _t892 def parse_uint128_type(self) -> logic_pb2.UInt128Type: self.consume_literal("UINT128") - _t905 = logic_pb2.UInt128Type() - return _t905 + _t893 = logic_pb2.UInt128Type() + return _t893 def parse_int128_type(self) -> logic_pb2.Int128Type: self.consume_literal("INT128") - _t906 = logic_pb2.Int128Type() - return _t906 + _t894 = logic_pb2.Int128Type() + return _t894 def parse_date_type(self) -> logic_pb2.DateType: self.consume_literal("DATE") - _t907 = logic_pb2.DateType() - return _t907 + _t895 = logic_pb2.DateType() + return _t895 def parse_datetime_type(self) -> logic_pb2.DateTimeType: self.consume_literal("DATETIME") - _t908 = logic_pb2.DateTimeType() - return _t908 + _t896 = logic_pb2.DateTimeType() + return _t896 def parse_missing_type(self) -> logic_pb2.MissingType: self.consume_literal("MISSING") - _t909 = logic_pb2.MissingType() - return _t909 + _t897 = logic_pb2.MissingType() + return _t897 def parse_decimal_type(self) -> logic_pb2.DecimalType: self.consume_literal("(") self.consume_literal("DECIMAL") - int457 = self.consume_terminal("INT") - int_3458 = self.consume_terminal("INT") + int451 = self.consume_terminal("INT") + int_3452 = self.consume_terminal("INT") self.consume_literal(")") - _t910 = logic_pb2.DecimalType(precision=int(int457), scale=int(int_3458)) - return _t910 + _t898 = logic_pb2.DecimalType(precision=int(int451), scale=int(int_3452)) + return _t898 def parse_boolean_type(self) -> logic_pb2.BooleanType: self.consume_literal("BOOLEAN") - _t911 = logic_pb2.BooleanType() - return _t911 + _t899 = logic_pb2.BooleanType() + return _t899 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs459 = [] - cond460 = self.match_lookahead_terminal("SYMBOL", 0) - while cond460: - _t912 = self.parse_binding() - item461 = _t912 - xs459.append(item461) - cond460 = self.match_lookahead_terminal("SYMBOL", 0) - bindings462 = xs459 - return bindings462 + xs453 = [] + cond454 = self.match_lookahead_terminal("SYMBOL", 0) + while cond454: + _t900 = self.parse_binding() + item455 = _t900 + xs453.append(item455) + cond454 = self.match_lookahead_terminal("SYMBOL", 0) + bindings456 = xs453 + return bindings456 def parse_formula(self) -> logic_pb2.Formula: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t914 = 0 + _t902 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t915 = 11 + _t903 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t916 = 3 + _t904 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t917 = 10 + _t905 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t918 = 9 + _t906 = 9 else: if self.match_lookahead_literal("or", 1): - _t919 = 5 + _t907 = 5 else: if self.match_lookahead_literal("not", 1): - _t920 = 6 + _t908 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t921 = 7 + _t909 = 7 else: if self.match_lookahead_literal("false", 1): - _t922 = 1 + _t910 = 1 else: if self.match_lookahead_literal("exists", 1): - _t923 = 2 + _t911 = 2 else: if self.match_lookahead_literal("cast", 1): - _t924 = 12 + _t912 = 12 else: if self.match_lookahead_literal("atom", 1): - _t925 = 8 + _t913 = 8 else: if self.match_lookahead_literal("and", 1): - _t926 = 4 + _t914 = 4 else: if self.match_lookahead_literal(">=", 1): - _t927 = 10 + _t915 = 10 else: if self.match_lookahead_literal(">", 1): - _t928 = 10 + _t916 = 10 else: if self.match_lookahead_literal("=", 1): - _t929 = 10 + _t917 = 10 else: if self.match_lookahead_literal("<=", 1): - _t930 = 10 + _t918 = 10 else: if self.match_lookahead_literal("<", 1): - _t931 = 10 + _t919 = 10 else: if self.match_lookahead_literal("/", 1): - _t932 = 10 + _t920 = 10 else: if self.match_lookahead_literal("-", 1): - _t933 = 10 + _t921 = 10 else: if self.match_lookahead_literal("+", 1): - _t934 = 10 + _t922 = 10 else: if self.match_lookahead_literal("*", 1): - _t935 = 10 + _t923 = 10 else: - _t935 = -1 - _t934 = _t935 - _t933 = _t934 - _t932 = _t933 - _t931 = _t932 - _t930 = _t931 - _t929 = _t930 - _t928 = _t929 - _t927 = _t928 - _t926 = _t927 - _t925 = _t926 - _t924 = _t925 - _t923 = _t924 - _t922 = _t923 - _t921 = _t922 - _t920 = _t921 - _t919 = _t920 - _t918 = _t919 - _t917 = _t918 - _t916 = _t917 - _t915 = _t916 - _t914 = _t915 - _t913 = _t914 - else: - _t913 = -1 - prediction463 = _t913 - if prediction463 == 12: - _t937 = self.parse_cast() - cast476 = _t937 - _t938 = logic_pb2.Formula(cast=cast476) - _t936 = _t938 - else: - if prediction463 == 11: - _t940 = self.parse_rel_atom() - rel_atom475 = _t940 - _t941 = logic_pb2.Formula(rel_atom=rel_atom475) - _t939 = _t941 + _t923 = -1 + _t922 = _t923 + _t921 = _t922 + _t920 = _t921 + _t919 = _t920 + _t918 = _t919 + _t917 = _t918 + _t916 = _t917 + _t915 = _t916 + _t914 = _t915 + _t913 = _t914 + _t912 = _t913 + _t911 = _t912 + _t910 = _t911 + _t909 = _t910 + _t908 = _t909 + _t907 = _t908 + _t906 = _t907 + _t905 = _t906 + _t904 = _t905 + _t903 = _t904 + _t902 = _t903 + _t901 = _t902 + else: + _t901 = -1 + prediction457 = _t901 + if prediction457 == 12: + _t925 = self.parse_cast() + cast470 = _t925 + _t926 = logic_pb2.Formula(cast=cast470) + _t924 = _t926 + else: + if prediction457 == 11: + _t928 = self.parse_rel_atom() + rel_atom469 = _t928 + _t929 = logic_pb2.Formula(rel_atom=rel_atom469) + _t927 = _t929 else: - if prediction463 == 10: - _t943 = self.parse_primitive() - primitive474 = _t943 - _t944 = logic_pb2.Formula(primitive=primitive474) - _t942 = _t944 + if prediction457 == 10: + _t931 = self.parse_primitive() + primitive468 = _t931 + _t932 = logic_pb2.Formula(primitive=primitive468) + _t930 = _t932 else: - if prediction463 == 9: - _t946 = self.parse_pragma() - pragma473 = _t946 - _t947 = logic_pb2.Formula(pragma=pragma473) - _t945 = _t947 + if prediction457 == 9: + _t934 = self.parse_pragma() + pragma467 = _t934 + _t935 = logic_pb2.Formula(pragma=pragma467) + _t933 = _t935 else: - if prediction463 == 8: - _t949 = self.parse_atom() - atom472 = _t949 - _t950 = logic_pb2.Formula(atom=atom472) - _t948 = _t950 + if prediction457 == 8: + _t937 = self.parse_atom() + atom466 = _t937 + _t938 = logic_pb2.Formula(atom=atom466) + _t936 = _t938 else: - if prediction463 == 7: - _t952 = self.parse_ffi() - ffi471 = _t952 - _t953 = logic_pb2.Formula(ffi=ffi471) - _t951 = _t953 + if prediction457 == 7: + _t940 = self.parse_ffi() + ffi465 = _t940 + _t941 = logic_pb2.Formula(ffi=ffi465) + _t939 = _t941 else: - if prediction463 == 6: - _t955 = self.parse_not() - not470 = _t955 - _t956 = logic_pb2.Formula() - getattr(_t956, 'not').CopyFrom(not470) - _t954 = _t956 + if prediction457 == 6: + _t943 = self.parse_not() + not464 = _t943 + _t944 = logic_pb2.Formula() + getattr(_t944, 'not').CopyFrom(not464) + _t942 = _t944 else: - if prediction463 == 5: - _t958 = self.parse_disjunction() - disjunction469 = _t958 - _t959 = logic_pb2.Formula(disjunction=disjunction469) - _t957 = _t959 + if prediction457 == 5: + _t946 = self.parse_disjunction() + disjunction463 = _t946 + _t947 = logic_pb2.Formula(disjunction=disjunction463) + _t945 = _t947 else: - if prediction463 == 4: - _t961 = self.parse_conjunction() - conjunction468 = _t961 - _t962 = logic_pb2.Formula(conjunction=conjunction468) - _t960 = _t962 + if prediction457 == 4: + _t949 = self.parse_conjunction() + conjunction462 = _t949 + _t950 = logic_pb2.Formula(conjunction=conjunction462) + _t948 = _t950 else: - if prediction463 == 3: - _t964 = self.parse_reduce() - reduce467 = _t964 - _t965 = logic_pb2.Formula(reduce=reduce467) - _t963 = _t965 + if prediction457 == 3: + _t952 = self.parse_reduce() + reduce461 = _t952 + _t953 = logic_pb2.Formula(reduce=reduce461) + _t951 = _t953 else: - if prediction463 == 2: - _t967 = self.parse_exists() - exists466 = _t967 - _t968 = logic_pb2.Formula(exists=exists466) - _t966 = _t968 + if prediction457 == 2: + _t955 = self.parse_exists() + exists460 = _t955 + _t956 = logic_pb2.Formula(exists=exists460) + _t954 = _t956 else: - if prediction463 == 1: - _t970 = self.parse_false() - false465 = _t970 - _t971 = logic_pb2.Formula(disjunction=false465) - _t969 = _t971 + if prediction457 == 1: + _t958 = self.parse_false() + false459 = _t958 + _t959 = logic_pb2.Formula(disjunction=false459) + _t957 = _t959 else: - if prediction463 == 0: - _t973 = self.parse_true() - true464 = _t973 - _t974 = logic_pb2.Formula(conjunction=true464) - _t972 = _t974 + if prediction457 == 0: + _t961 = self.parse_true() + true458 = _t961 + _t962 = logic_pb2.Formula(conjunction=true458) + _t960 = _t962 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t969 = _t972 - _t966 = _t969 - _t963 = _t966 - _t960 = _t963 - _t957 = _t960 - _t954 = _t957 - _t951 = _t954 - _t948 = _t951 - _t945 = _t948 - _t942 = _t945 - _t939 = _t942 - _t936 = _t939 - return _t936 + _t957 = _t960 + _t954 = _t957 + _t951 = _t954 + _t948 = _t951 + _t945 = _t948 + _t942 = _t945 + _t939 = _t942 + _t936 = _t939 + _t933 = _t936 + _t930 = _t933 + _t927 = _t930 + _t924 = _t927 + return _t924 def parse_true(self) -> logic_pb2.Conjunction: self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t975 = logic_pb2.Conjunction(args=[]) - return _t975 + _t963 = logic_pb2.Conjunction(args=[]) + return _t963 def parse_false(self) -> logic_pb2.Disjunction: self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t976 = logic_pb2.Disjunction(args=[]) - return _t976 + _t964 = logic_pb2.Disjunction(args=[]) + return _t964 def parse_exists(self) -> logic_pb2.Exists: self.consume_literal("(") self.consume_literal("exists") - _t977 = self.parse_bindings() - bindings477 = _t977 - _t978 = self.parse_formula() - formula478 = _t978 + _t965 = self.parse_bindings() + bindings471 = _t965 + _t966 = self.parse_formula() + formula472 = _t966 self.consume_literal(")") - _t979 = logic_pb2.Abstraction(vars=(list(bindings477[0]) + list(bindings477[1] if bindings477[1] is not None else [])), value=formula478) - _t980 = logic_pb2.Exists(body=_t979) - return _t980 + _t967 = logic_pb2.Abstraction(vars=(list(bindings471[0]) + list(bindings471[1] if bindings471[1] is not None else [])), value=formula472) + _t968 = logic_pb2.Exists(body=_t967) + return _t968 def parse_reduce(self) -> logic_pb2.Reduce: self.consume_literal("(") self.consume_literal("reduce") - _t981 = self.parse_abstraction() - abstraction479 = _t981 - _t982 = self.parse_abstraction() - abstraction_3480 = _t982 - _t983 = self.parse_terms() - terms481 = _t983 + _t969 = self.parse_abstraction() + abstraction473 = _t969 + _t970 = self.parse_abstraction() + abstraction_3474 = _t970 + _t971 = self.parse_terms() + terms475 = _t971 self.consume_literal(")") - _t984 = logic_pb2.Reduce(op=abstraction479, body=abstraction_3480, terms=terms481) - return _t984 + _t972 = logic_pb2.Reduce(op=abstraction473, body=abstraction_3474, terms=terms475) + return _t972 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs482 = [] - cond483 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond483: - _t985 = self.parse_term() - item484 = _t985 - xs482.append(item484) - cond483 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms485 = xs482 + xs476 = [] + cond477 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond477: + _t973 = self.parse_term() + item478 = _t973 + xs476.append(item478) + cond477 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms479 = xs476 self.consume_literal(")") - return terms485 + return terms479 def parse_term(self) -> logic_pb2.Term: if self.match_lookahead_literal("true", 0): - _t986 = 1 + _t974 = 1 else: if self.match_lookahead_literal("missing", 0): - _t987 = 1 + _t975 = 1 else: if self.match_lookahead_literal("false", 0): - _t988 = 1 + _t976 = 1 else: if self.match_lookahead_literal("(", 0): - _t989 = 1 + _t977 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t990 = 1 + _t978 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t991 = 0 + _t979 = 0 else: if self.match_lookahead_terminal("STRING", 0): - _t992 = 1 + _t980 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t993 = 1 + _t981 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t994 = 1 + _t982 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t995 = 1 + _t983 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t996 = 1 + _t984 = 1 else: - _t996 = -1 - _t995 = _t996 - _t994 = _t995 - _t993 = _t994 - _t992 = _t993 - _t991 = _t992 - _t990 = _t991 - _t989 = _t990 - _t988 = _t989 - _t987 = _t988 - _t986 = _t987 - prediction486 = _t986 - if prediction486 == 1: - _t998 = self.parse_constant() - constant488 = _t998 - _t999 = logic_pb2.Term(constant=constant488) - _t997 = _t999 - else: - if prediction486 == 0: - _t1001 = self.parse_var() - var487 = _t1001 - _t1002 = logic_pb2.Term(var=var487) - _t1000 = _t1002 + _t984 = -1 + _t983 = _t984 + _t982 = _t983 + _t981 = _t982 + _t980 = _t981 + _t979 = _t980 + _t978 = _t979 + _t977 = _t978 + _t976 = _t977 + _t975 = _t976 + _t974 = _t975 + prediction480 = _t974 + if prediction480 == 1: + _t986 = self.parse_constant() + constant482 = _t986 + _t987 = logic_pb2.Term(constant=constant482) + _t985 = _t987 + else: + if prediction480 == 0: + _t989 = self.parse_var() + var481 = _t989 + _t990 = logic_pb2.Term(var=var481) + _t988 = _t990 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t997 = _t1000 - return _t997 + _t985 = _t988 + return _t985 def parse_var(self) -> logic_pb2.Var: - symbol489 = self.consume_terminal("SYMBOL") - _t1003 = logic_pb2.Var(name=symbol489) - return _t1003 + symbol483 = self.consume_terminal("SYMBOL") + _t991 = logic_pb2.Var(name=symbol483) + return _t991 def parse_constant(self) -> logic_pb2.Value: - _t1004 = self.parse_value() - value490 = _t1004 - return value490 + _t992 = self.parse_value() + value484 = _t992 + return value484 def parse_conjunction(self) -> logic_pb2.Conjunction: self.consume_literal("(") self.consume_literal("and") - xs491 = [] - cond492 = self.match_lookahead_literal("(", 0) - while cond492: - _t1005 = self.parse_formula() - item493 = _t1005 - xs491.append(item493) - cond492 = self.match_lookahead_literal("(", 0) - formulas494 = xs491 - self.consume_literal(")") - _t1006 = logic_pb2.Conjunction(args=formulas494) - return _t1006 + xs485 = [] + cond486 = self.match_lookahead_literal("(", 0) + while cond486: + _t993 = self.parse_formula() + item487 = _t993 + xs485.append(item487) + cond486 = self.match_lookahead_literal("(", 0) + formulas488 = xs485 + self.consume_literal(")") + _t994 = logic_pb2.Conjunction(args=formulas488) + return _t994 def parse_disjunction(self) -> logic_pb2.Disjunction: self.consume_literal("(") self.consume_literal("or") - xs495 = [] - cond496 = self.match_lookahead_literal("(", 0) - while cond496: - _t1007 = self.parse_formula() - item497 = _t1007 - xs495.append(item497) - cond496 = self.match_lookahead_literal("(", 0) - formulas498 = xs495 - self.consume_literal(")") - _t1008 = logic_pb2.Disjunction(args=formulas498) - return _t1008 + xs489 = [] + cond490 = self.match_lookahead_literal("(", 0) + while cond490: + _t995 = self.parse_formula() + item491 = _t995 + xs489.append(item491) + cond490 = self.match_lookahead_literal("(", 0) + formulas492 = xs489 + self.consume_literal(")") + _t996 = logic_pb2.Disjunction(args=formulas492) + return _t996 def parse_not(self) -> logic_pb2.Not: self.consume_literal("(") self.consume_literal("not") - _t1009 = self.parse_formula() - formula499 = _t1009 + _t997 = self.parse_formula() + formula493 = _t997 self.consume_literal(")") - _t1010 = logic_pb2.Not(arg=formula499) - return _t1010 + _t998 = logic_pb2.Not(arg=formula493) + return _t998 def parse_ffi(self) -> logic_pb2.FFI: self.consume_literal("(") self.consume_literal("ffi") - _t1011 = self.parse_name() - name500 = _t1011 - _t1012 = self.parse_ffi_args() - ffi_args501 = _t1012 - _t1013 = self.parse_terms() - terms502 = _t1013 + _t999 = self.parse_name() + name494 = _t999 + _t1000 = self.parse_ffi_args() + ffi_args495 = _t1000 + _t1001 = self.parse_terms() + terms496 = _t1001 self.consume_literal(")") - _t1014 = logic_pb2.FFI(name=name500, args=ffi_args501, terms=terms502) - return _t1014 + _t1002 = logic_pb2.FFI(name=name494, args=ffi_args495, terms=terms496) + return _t1002 def parse_name(self) -> str: self.consume_literal(":") - symbol503 = self.consume_terminal("SYMBOL") - return symbol503 + symbol497 = self.consume_terminal("SYMBOL") + return symbol497 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs504 = [] - cond505 = self.match_lookahead_literal("(", 0) - while cond505: - _t1015 = self.parse_abstraction() - item506 = _t1015 - xs504.append(item506) - cond505 = self.match_lookahead_literal("(", 0) - abstractions507 = xs504 + xs498 = [] + cond499 = self.match_lookahead_literal("(", 0) + while cond499: + _t1003 = self.parse_abstraction() + item500 = _t1003 + xs498.append(item500) + cond499 = self.match_lookahead_literal("(", 0) + abstractions501 = xs498 self.consume_literal(")") - return abstractions507 + return abstractions501 def parse_atom(self) -> logic_pb2.Atom: self.consume_literal("(") self.consume_literal("atom") - _t1016 = self.parse_relation_id() - relation_id508 = _t1016 - xs509 = [] - cond510 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond510: - _t1017 = self.parse_term() - item511 = _t1017 - xs509.append(item511) - cond510 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms512 = xs509 - self.consume_literal(")") - _t1018 = logic_pb2.Atom(name=relation_id508, terms=terms512) - return _t1018 + _t1004 = self.parse_relation_id() + relation_id502 = _t1004 + xs503 = [] + cond504 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond504: + _t1005 = self.parse_term() + item505 = _t1005 + xs503.append(item505) + cond504 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms506 = xs503 + self.consume_literal(")") + _t1006 = logic_pb2.Atom(name=relation_id502, terms=terms506) + return _t1006 def parse_pragma(self) -> logic_pb2.Pragma: self.consume_literal("(") self.consume_literal("pragma") - _t1019 = self.parse_name() - name513 = _t1019 - xs514 = [] - cond515 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond515: - _t1020 = self.parse_term() - item516 = _t1020 - xs514.append(item516) - cond515 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms517 = xs514 - self.consume_literal(")") - _t1021 = logic_pb2.Pragma(name=name513, terms=terms517) - return _t1021 + _t1007 = self.parse_name() + name507 = _t1007 + xs508 = [] + cond509 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond509: + _t1008 = self.parse_term() + item510 = _t1008 + xs508.append(item510) + cond509 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms511 = xs508 + self.consume_literal(")") + _t1009 = logic_pb2.Pragma(name=name507, terms=terms511) + return _t1009 def parse_primitive(self) -> logic_pb2.Primitive: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1023 = 9 + _t1011 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1024 = 4 + _t1012 = 4 else: if self.match_lookahead_literal(">", 1): - _t1025 = 3 + _t1013 = 3 else: if self.match_lookahead_literal("=", 1): - _t1026 = 0 + _t1014 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1027 = 2 + _t1015 = 2 else: if self.match_lookahead_literal("<", 1): - _t1028 = 1 + _t1016 = 1 else: if self.match_lookahead_literal("/", 1): - _t1029 = 8 + _t1017 = 8 else: if self.match_lookahead_literal("-", 1): - _t1030 = 6 + _t1018 = 6 else: if self.match_lookahead_literal("+", 1): - _t1031 = 5 + _t1019 = 5 else: if self.match_lookahead_literal("*", 1): - _t1032 = 7 + _t1020 = 7 else: - _t1032 = -1 - _t1031 = _t1032 - _t1030 = _t1031 - _t1029 = _t1030 - _t1028 = _t1029 - _t1027 = _t1028 - _t1026 = _t1027 - _t1025 = _t1026 - _t1024 = _t1025 - _t1023 = _t1024 - _t1022 = _t1023 - else: - _t1022 = -1 - prediction518 = _t1022 - if prediction518 == 9: + _t1020 = -1 + _t1019 = _t1020 + _t1018 = _t1019 + _t1017 = _t1018 + _t1016 = _t1017 + _t1015 = _t1016 + _t1014 = _t1015 + _t1013 = _t1014 + _t1012 = _t1013 + _t1011 = _t1012 + _t1010 = _t1011 + else: + _t1010 = -1 + prediction512 = _t1010 + if prediction512 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1034 = self.parse_name() - name528 = _t1034 - xs529 = [] - cond530 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond530: - _t1035 = self.parse_rel_term() - item531 = _t1035 - xs529.append(item531) - cond530 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - rel_terms532 = xs529 + _t1022 = self.parse_name() + name522 = _t1022 + xs523 = [] + cond524 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond524: + _t1023 = self.parse_rel_term() + item525 = _t1023 + xs523.append(item525) + cond524 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + rel_terms526 = xs523 self.consume_literal(")") - _t1036 = logic_pb2.Primitive(name=name528, terms=rel_terms532) - _t1033 = _t1036 + _t1024 = logic_pb2.Primitive(name=name522, terms=rel_terms526) + _t1021 = _t1024 else: - if prediction518 == 8: - _t1038 = self.parse_divide() - divide527 = _t1038 - _t1037 = divide527 + if prediction512 == 8: + _t1026 = self.parse_divide() + divide521 = _t1026 + _t1025 = divide521 else: - if prediction518 == 7: - _t1040 = self.parse_multiply() - multiply526 = _t1040 - _t1039 = multiply526 + if prediction512 == 7: + _t1028 = self.parse_multiply() + multiply520 = _t1028 + _t1027 = multiply520 else: - if prediction518 == 6: - _t1042 = self.parse_minus() - minus525 = _t1042 - _t1041 = minus525 + if prediction512 == 6: + _t1030 = self.parse_minus() + minus519 = _t1030 + _t1029 = minus519 else: - if prediction518 == 5: - _t1044 = self.parse_add() - add524 = _t1044 - _t1043 = add524 + if prediction512 == 5: + _t1032 = self.parse_add() + add518 = _t1032 + _t1031 = add518 else: - if prediction518 == 4: - _t1046 = self.parse_gt_eq() - gt_eq523 = _t1046 - _t1045 = gt_eq523 + if prediction512 == 4: + _t1034 = self.parse_gt_eq() + gt_eq517 = _t1034 + _t1033 = gt_eq517 else: - if prediction518 == 3: - _t1048 = self.parse_gt() - gt522 = _t1048 - _t1047 = gt522 + if prediction512 == 3: + _t1036 = self.parse_gt() + gt516 = _t1036 + _t1035 = gt516 else: - if prediction518 == 2: - _t1050 = self.parse_lt_eq() - lt_eq521 = _t1050 - _t1049 = lt_eq521 + if prediction512 == 2: + _t1038 = self.parse_lt_eq() + lt_eq515 = _t1038 + _t1037 = lt_eq515 else: - if prediction518 == 1: - _t1052 = self.parse_lt() - lt520 = _t1052 - _t1051 = lt520 + if prediction512 == 1: + _t1040 = self.parse_lt() + lt514 = _t1040 + _t1039 = lt514 else: - if prediction518 == 0: - _t1054 = self.parse_eq() - eq519 = _t1054 - _t1053 = eq519 + if prediction512 == 0: + _t1042 = self.parse_eq() + eq513 = _t1042 + _t1041 = eq513 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1051 = _t1053 - _t1049 = _t1051 - _t1047 = _t1049 - _t1045 = _t1047 - _t1043 = _t1045 - _t1041 = _t1043 - _t1039 = _t1041 - _t1037 = _t1039 - _t1033 = _t1037 - return _t1033 + _t1039 = _t1041 + _t1037 = _t1039 + _t1035 = _t1037 + _t1033 = _t1035 + _t1031 = _t1033 + _t1029 = _t1031 + _t1027 = _t1029 + _t1025 = _t1027 + _t1021 = _t1025 + return _t1021 def parse_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("=") - _t1055 = self.parse_term() - term533 = _t1055 - _t1056 = self.parse_term() - term_3534 = _t1056 + _t1043 = self.parse_term() + term527 = _t1043 + _t1044 = self.parse_term() + term_3528 = _t1044 self.consume_literal(")") - _t1057 = logic_pb2.RelTerm(term=term533) - _t1058 = logic_pb2.RelTerm(term=term_3534) - _t1059 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1057, _t1058]) - return _t1059 + _t1045 = logic_pb2.RelTerm(term=term527) + _t1046 = logic_pb2.RelTerm(term=term_3528) + _t1047 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1045, _t1046]) + return _t1047 def parse_lt(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("<") - _t1060 = self.parse_term() - term535 = _t1060 - _t1061 = self.parse_term() - term_3536 = _t1061 + _t1048 = self.parse_term() + term529 = _t1048 + _t1049 = self.parse_term() + term_3530 = _t1049 self.consume_literal(")") - _t1062 = logic_pb2.RelTerm(term=term535) - _t1063 = logic_pb2.RelTerm(term=term_3536) - _t1064 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1062, _t1063]) - return _t1064 + _t1050 = logic_pb2.RelTerm(term=term529) + _t1051 = logic_pb2.RelTerm(term=term_3530) + _t1052 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1050, _t1051]) + return _t1052 def parse_lt_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("<=") - _t1065 = self.parse_term() - term537 = _t1065 - _t1066 = self.parse_term() - term_3538 = _t1066 + _t1053 = self.parse_term() + term531 = _t1053 + _t1054 = self.parse_term() + term_3532 = _t1054 self.consume_literal(")") - _t1067 = logic_pb2.RelTerm(term=term537) - _t1068 = logic_pb2.RelTerm(term=term_3538) - _t1069 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1067, _t1068]) - return _t1069 + _t1055 = logic_pb2.RelTerm(term=term531) + _t1056 = logic_pb2.RelTerm(term=term_3532) + _t1057 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1055, _t1056]) + return _t1057 def parse_gt(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal(">") - _t1070 = self.parse_term() - term539 = _t1070 - _t1071 = self.parse_term() - term_3540 = _t1071 + _t1058 = self.parse_term() + term533 = _t1058 + _t1059 = self.parse_term() + term_3534 = _t1059 self.consume_literal(")") - _t1072 = logic_pb2.RelTerm(term=term539) - _t1073 = logic_pb2.RelTerm(term=term_3540) - _t1074 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1072, _t1073]) - return _t1074 + _t1060 = logic_pb2.RelTerm(term=term533) + _t1061 = logic_pb2.RelTerm(term=term_3534) + _t1062 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1060, _t1061]) + return _t1062 def parse_gt_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal(">=") - _t1075 = self.parse_term() - term541 = _t1075 - _t1076 = self.parse_term() - term_3542 = _t1076 + _t1063 = self.parse_term() + term535 = _t1063 + _t1064 = self.parse_term() + term_3536 = _t1064 self.consume_literal(")") - _t1077 = logic_pb2.RelTerm(term=term541) - _t1078 = logic_pb2.RelTerm(term=term_3542) - _t1079 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1077, _t1078]) - return _t1079 + _t1065 = logic_pb2.RelTerm(term=term535) + _t1066 = logic_pb2.RelTerm(term=term_3536) + _t1067 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1065, _t1066]) + return _t1067 def parse_add(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("+") - _t1080 = self.parse_term() - term543 = _t1080 - _t1081 = self.parse_term() - term_3544 = _t1081 - _t1082 = self.parse_term() - term_4545 = _t1082 + _t1068 = self.parse_term() + term537 = _t1068 + _t1069 = self.parse_term() + term_3538 = _t1069 + _t1070 = self.parse_term() + term_4539 = _t1070 self.consume_literal(")") - _t1083 = logic_pb2.RelTerm(term=term543) - _t1084 = logic_pb2.RelTerm(term=term_3544) - _t1085 = logic_pb2.RelTerm(term=term_4545) - _t1086 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1083, _t1084, _t1085]) - return _t1086 + _t1071 = logic_pb2.RelTerm(term=term537) + _t1072 = logic_pb2.RelTerm(term=term_3538) + _t1073 = logic_pb2.RelTerm(term=term_4539) + _t1074 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1071, _t1072, _t1073]) + return _t1074 def parse_minus(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("-") - _t1087 = self.parse_term() - term546 = _t1087 - _t1088 = self.parse_term() - term_3547 = _t1088 - _t1089 = self.parse_term() - term_4548 = _t1089 + _t1075 = self.parse_term() + term540 = _t1075 + _t1076 = self.parse_term() + term_3541 = _t1076 + _t1077 = self.parse_term() + term_4542 = _t1077 self.consume_literal(")") - _t1090 = logic_pb2.RelTerm(term=term546) - _t1091 = logic_pb2.RelTerm(term=term_3547) - _t1092 = logic_pb2.RelTerm(term=term_4548) - _t1093 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1090, _t1091, _t1092]) - return _t1093 + _t1078 = logic_pb2.RelTerm(term=term540) + _t1079 = logic_pb2.RelTerm(term=term_3541) + _t1080 = logic_pb2.RelTerm(term=term_4542) + _t1081 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1078, _t1079, _t1080]) + return _t1081 def parse_multiply(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("*") - _t1094 = self.parse_term() - term549 = _t1094 - _t1095 = self.parse_term() - term_3550 = _t1095 - _t1096 = self.parse_term() - term_4551 = _t1096 - self.consume_literal(")") - _t1097 = logic_pb2.RelTerm(term=term549) - _t1098 = logic_pb2.RelTerm(term=term_3550) - _t1099 = logic_pb2.RelTerm(term=term_4551) - _t1100 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1097, _t1098, _t1099]) - return _t1100 + _t1082 = self.parse_term() + term543 = _t1082 + _t1083 = self.parse_term() + term_3544 = _t1083 + _t1084 = self.parse_term() + term_4545 = _t1084 + self.consume_literal(")") + _t1085 = logic_pb2.RelTerm(term=term543) + _t1086 = logic_pb2.RelTerm(term=term_3544) + _t1087 = logic_pb2.RelTerm(term=term_4545) + _t1088 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1085, _t1086, _t1087]) + return _t1088 def parse_divide(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("/") - _t1101 = self.parse_term() - term552 = _t1101 - _t1102 = self.parse_term() - term_3553 = _t1102 - _t1103 = self.parse_term() - term_4554 = _t1103 - self.consume_literal(")") - _t1104 = logic_pb2.RelTerm(term=term552) - _t1105 = logic_pb2.RelTerm(term=term_3553) - _t1106 = logic_pb2.RelTerm(term=term_4554) - _t1107 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1104, _t1105, _t1106]) - return _t1107 + _t1089 = self.parse_term() + term546 = _t1089 + _t1090 = self.parse_term() + term_3547 = _t1090 + _t1091 = self.parse_term() + term_4548 = _t1091 + self.consume_literal(")") + _t1092 = logic_pb2.RelTerm(term=term546) + _t1093 = logic_pb2.RelTerm(term=term_3547) + _t1094 = logic_pb2.RelTerm(term=term_4548) + _t1095 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1092, _t1093, _t1094]) + return _t1095 def parse_rel_term(self) -> logic_pb2.RelTerm: if self.match_lookahead_literal("true", 0): - _t1108 = 1 + _t1096 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1109 = 1 + _t1097 = 1 else: if self.match_lookahead_literal("false", 0): - _t1110 = 1 + _t1098 = 1 else: if self.match_lookahead_literal("(", 0): - _t1111 = 1 + _t1099 = 1 else: if self.match_lookahead_literal("#", 0): - _t1112 = 0 + _t1100 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1113 = 1 + _t1101 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1114 = 1 + _t1102 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1115 = 1 + _t1103 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1116 = 1 + _t1104 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1117 = 1 + _t1105 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1118 = 1 + _t1106 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1119 = 1 + _t1107 = 1 else: - _t1119 = -1 - _t1118 = _t1119 - _t1117 = _t1118 - _t1116 = _t1117 - _t1115 = _t1116 - _t1114 = _t1115 - _t1113 = _t1114 - _t1112 = _t1113 - _t1111 = _t1112 - _t1110 = _t1111 - _t1109 = _t1110 - _t1108 = _t1109 - prediction555 = _t1108 - if prediction555 == 1: - _t1121 = self.parse_term() - term557 = _t1121 - _t1122 = logic_pb2.RelTerm(term=term557) - _t1120 = _t1122 - else: - if prediction555 == 0: - _t1124 = self.parse_specialized_value() - specialized_value556 = _t1124 - _t1125 = logic_pb2.RelTerm(specialized_value=specialized_value556) - _t1123 = _t1125 + _t1107 = -1 + _t1106 = _t1107 + _t1105 = _t1106 + _t1104 = _t1105 + _t1103 = _t1104 + _t1102 = _t1103 + _t1101 = _t1102 + _t1100 = _t1101 + _t1099 = _t1100 + _t1098 = _t1099 + _t1097 = _t1098 + _t1096 = _t1097 + prediction549 = _t1096 + if prediction549 == 1: + _t1109 = self.parse_term() + term551 = _t1109 + _t1110 = logic_pb2.RelTerm(term=term551) + _t1108 = _t1110 + else: + if prediction549 == 0: + _t1112 = self.parse_specialized_value() + specialized_value550 = _t1112 + _t1113 = logic_pb2.RelTerm(specialized_value=specialized_value550) + _t1111 = _t1113 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1120 = _t1123 - return _t1120 + _t1108 = _t1111 + return _t1108 def parse_specialized_value(self) -> logic_pb2.Value: self.consume_literal("#") - _t1126 = self.parse_value() - value558 = _t1126 - return value558 + _t1114 = self.parse_value() + value552 = _t1114 + return value552 def parse_rel_atom(self) -> logic_pb2.RelAtom: self.consume_literal("(") self.consume_literal("relatom") - _t1127 = self.parse_name() - name559 = _t1127 - xs560 = [] - cond561 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond561: - _t1128 = self.parse_rel_term() - item562 = _t1128 - xs560.append(item562) - cond561 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - rel_terms563 = xs560 - self.consume_literal(")") - _t1129 = logic_pb2.RelAtom(name=name559, terms=rel_terms563) - return _t1129 + _t1115 = self.parse_name() + name553 = _t1115 + xs554 = [] + cond555 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond555: + _t1116 = self.parse_rel_term() + item556 = _t1116 + xs554.append(item556) + cond555 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + rel_terms557 = xs554 + self.consume_literal(")") + _t1117 = logic_pb2.RelAtom(name=name553, terms=rel_terms557) + return _t1117 def parse_cast(self) -> logic_pb2.Cast: self.consume_literal("(") self.consume_literal("cast") - _t1130 = self.parse_term() - term564 = _t1130 - _t1131 = self.parse_term() - term_3565 = _t1131 + _t1118 = self.parse_term() + term558 = _t1118 + _t1119 = self.parse_term() + term_3559 = _t1119 self.consume_literal(")") - _t1132 = logic_pb2.Cast(input=term564, result=term_3565) - return _t1132 + _t1120 = logic_pb2.Cast(input=term558, result=term_3559) + return _t1120 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs566 = [] - cond567 = self.match_lookahead_literal("(", 0) - while cond567: - _t1133 = self.parse_attribute() - item568 = _t1133 - xs566.append(item568) - cond567 = self.match_lookahead_literal("(", 0) - attributes569 = xs566 + xs560 = [] + cond561 = self.match_lookahead_literal("(", 0) + while cond561: + _t1121 = self.parse_attribute() + item562 = _t1121 + xs560.append(item562) + cond561 = self.match_lookahead_literal("(", 0) + attributes563 = xs560 self.consume_literal(")") - return attributes569 + return attributes563 def parse_attribute(self) -> logic_pb2.Attribute: self.consume_literal("(") self.consume_literal("attribute") - _t1134 = self.parse_name() - name570 = _t1134 - xs571 = [] - cond572 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond572: - _t1135 = self.parse_value() - item573 = _t1135 - xs571.append(item573) - cond572 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) - values574 = xs571 - self.consume_literal(")") - _t1136 = logic_pb2.Attribute(name=name570, args=values574) - return _t1136 + _t1122 = self.parse_name() + name564 = _t1122 + xs565 = [] + cond566 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond566: + _t1123 = self.parse_value() + item567 = _t1123 + xs565.append(item567) + cond566 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) + values568 = xs565 + self.consume_literal(")") + _t1124 = logic_pb2.Attribute(name=name564, args=values568) + return _t1124 def parse_algorithm(self) -> logic_pb2.Algorithm: self.consume_literal("(") self.consume_literal("algorithm") - xs575 = [] - cond576 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond576: - _t1137 = self.parse_relation_id() - item577 = _t1137 - xs575.append(item577) - cond576 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids578 = xs575 - _t1138 = self.parse_script() - script579 = _t1138 - self.consume_literal(")") - _t1139 = logic_pb2.Algorithm(body=script579) - getattr(_t1139, 'global').extend(relation_ids578) - return _t1139 + xs569 = [] + cond570 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond570: + _t1125 = self.parse_relation_id() + item571 = _t1125 + xs569.append(item571) + cond570 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids572 = xs569 + _t1126 = self.parse_script() + script573 = _t1126 + self.consume_literal(")") + _t1127 = logic_pb2.Algorithm(body=script573) + getattr(_t1127, 'global').extend(relation_ids572) + return _t1127 def parse_script(self) -> logic_pb2.Script: self.consume_literal("(") self.consume_literal("script") - xs580 = [] - cond581 = self.match_lookahead_literal("(", 0) - while cond581: - _t1140 = self.parse_construct() - item582 = _t1140 - xs580.append(item582) - cond581 = self.match_lookahead_literal("(", 0) - constructs583 = xs580 - self.consume_literal(")") - _t1141 = logic_pb2.Script(constructs=constructs583) - return _t1141 + xs574 = [] + cond575 = self.match_lookahead_literal("(", 0) + while cond575: + _t1128 = self.parse_construct() + item576 = _t1128 + xs574.append(item576) + cond575 = self.match_lookahead_literal("(", 0) + constructs577 = xs574 + self.consume_literal(")") + _t1129 = logic_pb2.Script(constructs=constructs577) + return _t1129 def parse_construct(self) -> logic_pb2.Construct: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1143 = 1 + _t1131 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1144 = 1 + _t1132 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1145 = 1 + _t1133 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1146 = 0 + _t1134 = 0 else: if self.match_lookahead_literal("break", 1): - _t1147 = 1 + _t1135 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1148 = 1 + _t1136 = 1 else: - _t1148 = -1 - _t1147 = _t1148 - _t1146 = _t1147 - _t1145 = _t1146 - _t1144 = _t1145 - _t1143 = _t1144 - _t1142 = _t1143 - else: - _t1142 = -1 - prediction584 = _t1142 - if prediction584 == 1: - _t1150 = self.parse_instruction() - instruction586 = _t1150 - _t1151 = logic_pb2.Construct(instruction=instruction586) - _t1149 = _t1151 - else: - if prediction584 == 0: - _t1153 = self.parse_loop() - loop585 = _t1153 - _t1154 = logic_pb2.Construct(loop=loop585) - _t1152 = _t1154 + _t1136 = -1 + _t1135 = _t1136 + _t1134 = _t1135 + _t1133 = _t1134 + _t1132 = _t1133 + _t1131 = _t1132 + _t1130 = _t1131 + else: + _t1130 = -1 + prediction578 = _t1130 + if prediction578 == 1: + _t1138 = self.parse_instruction() + instruction580 = _t1138 + _t1139 = logic_pb2.Construct(instruction=instruction580) + _t1137 = _t1139 + else: + if prediction578 == 0: + _t1141 = self.parse_loop() + loop579 = _t1141 + _t1142 = logic_pb2.Construct(loop=loop579) + _t1140 = _t1142 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1149 = _t1152 - return _t1149 + _t1137 = _t1140 + return _t1137 def parse_loop(self) -> logic_pb2.Loop: self.consume_literal("(") self.consume_literal("loop") - _t1155 = self.parse_init() - init587 = _t1155 - _t1156 = self.parse_script() - script588 = _t1156 + _t1143 = self.parse_init() + init581 = _t1143 + _t1144 = self.parse_script() + script582 = _t1144 self.consume_literal(")") - _t1157 = logic_pb2.Loop(init=init587, body=script588) - return _t1157 + _t1145 = logic_pb2.Loop(init=init581, body=script582) + return _t1145 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs589 = [] - cond590 = self.match_lookahead_literal("(", 0) - while cond590: - _t1158 = self.parse_instruction() - item591 = _t1158 - xs589.append(item591) - cond590 = self.match_lookahead_literal("(", 0) - instructions592 = xs589 + xs583 = [] + cond584 = self.match_lookahead_literal("(", 0) + while cond584: + _t1146 = self.parse_instruction() + item585 = _t1146 + xs583.append(item585) + cond584 = self.match_lookahead_literal("(", 0) + instructions586 = xs583 self.consume_literal(")") - return instructions592 + return instructions586 def parse_instruction(self) -> logic_pb2.Instruction: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1160 = 1 + _t1148 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1161 = 4 + _t1149 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1162 = 3 + _t1150 = 3 else: if self.match_lookahead_literal("break", 1): - _t1163 = 2 + _t1151 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1164 = 0 + _t1152 = 0 else: - _t1164 = -1 - _t1163 = _t1164 - _t1162 = _t1163 - _t1161 = _t1162 - _t1160 = _t1161 - _t1159 = _t1160 - else: - _t1159 = -1 - prediction593 = _t1159 - if prediction593 == 4: - _t1166 = self.parse_monus_def() - monus_def598 = _t1166 - _t1167 = logic_pb2.Instruction(monus_def=monus_def598) - _t1165 = _t1167 - else: - if prediction593 == 3: - _t1169 = self.parse_monoid_def() - monoid_def597 = _t1169 - _t1170 = logic_pb2.Instruction(monoid_def=monoid_def597) - _t1168 = _t1170 + _t1152 = -1 + _t1151 = _t1152 + _t1150 = _t1151 + _t1149 = _t1150 + _t1148 = _t1149 + _t1147 = _t1148 + else: + _t1147 = -1 + prediction587 = _t1147 + if prediction587 == 4: + _t1154 = self.parse_monus_def() + monus_def592 = _t1154 + _t1155 = logic_pb2.Instruction(monus_def=monus_def592) + _t1153 = _t1155 + else: + if prediction587 == 3: + _t1157 = self.parse_monoid_def() + monoid_def591 = _t1157 + _t1158 = logic_pb2.Instruction(monoid_def=monoid_def591) + _t1156 = _t1158 else: - if prediction593 == 2: - _t1172 = self.parse_break() - break596 = _t1172 - _t1173 = logic_pb2.Instruction() - getattr(_t1173, 'break').CopyFrom(break596) - _t1171 = _t1173 + if prediction587 == 2: + _t1160 = self.parse_break() + break590 = _t1160 + _t1161 = logic_pb2.Instruction() + getattr(_t1161, 'break').CopyFrom(break590) + _t1159 = _t1161 else: - if prediction593 == 1: - _t1175 = self.parse_upsert() - upsert595 = _t1175 - _t1176 = logic_pb2.Instruction(upsert=upsert595) - _t1174 = _t1176 + if prediction587 == 1: + _t1163 = self.parse_upsert() + upsert589 = _t1163 + _t1164 = logic_pb2.Instruction(upsert=upsert589) + _t1162 = _t1164 else: - if prediction593 == 0: - _t1178 = self.parse_assign() - assign594 = _t1178 - _t1179 = logic_pb2.Instruction(assign=assign594) - _t1177 = _t1179 + if prediction587 == 0: + _t1166 = self.parse_assign() + assign588 = _t1166 + _t1167 = logic_pb2.Instruction(assign=assign588) + _t1165 = _t1167 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1174 = _t1177 - _t1171 = _t1174 - _t1168 = _t1171 - _t1165 = _t1168 - return _t1165 + _t1162 = _t1165 + _t1159 = _t1162 + _t1156 = _t1159 + _t1153 = _t1156 + return _t1153 def parse_assign(self) -> logic_pb2.Assign: self.consume_literal("(") self.consume_literal("assign") - _t1180 = self.parse_relation_id() - relation_id599 = _t1180 - _t1181 = self.parse_abstraction() - abstraction600 = _t1181 + _t1168 = self.parse_relation_id() + relation_id593 = _t1168 + _t1169 = self.parse_abstraction() + abstraction594 = _t1169 if self.match_lookahead_literal("(", 0): - _t1183 = self.parse_attrs() - _t1182 = _t1183 + _t1171 = self.parse_attrs() + _t1170 = _t1171 else: - _t1182 = None - attrs601 = _t1182 + _t1170 = None + attrs595 = _t1170 self.consume_literal(")") - _t1184 = logic_pb2.Assign(name=relation_id599, body=abstraction600, attrs=(attrs601 if attrs601 is not None else [])) - return _t1184 + _t1172 = logic_pb2.Assign(name=relation_id593, body=abstraction594, attrs=(attrs595 if attrs595 is not None else [])) + return _t1172 def parse_upsert(self) -> logic_pb2.Upsert: self.consume_literal("(") self.consume_literal("upsert") - _t1185 = self.parse_relation_id() - relation_id602 = _t1185 - _t1186 = self.parse_abstraction_with_arity() - abstraction_with_arity603 = _t1186 + _t1173 = self.parse_relation_id() + relation_id596 = _t1173 + _t1174 = self.parse_abstraction_with_arity() + abstraction_with_arity597 = _t1174 if self.match_lookahead_literal("(", 0): - _t1188 = self.parse_attrs() - _t1187 = _t1188 + _t1176 = self.parse_attrs() + _t1175 = _t1176 else: - _t1187 = None - attrs604 = _t1187 + _t1175 = None + attrs598 = _t1175 self.consume_literal(")") - _t1189 = logic_pb2.Upsert(name=relation_id602, body=abstraction_with_arity603[0], attrs=(attrs604 if attrs604 is not None else []), value_arity=abstraction_with_arity603[1]) - return _t1189 + _t1177 = logic_pb2.Upsert(name=relation_id596, body=abstraction_with_arity597[0], attrs=(attrs598 if attrs598 is not None else []), value_arity=abstraction_with_arity597[1]) + return _t1177 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1190 = self.parse_bindings() - bindings605 = _t1190 - _t1191 = self.parse_formula() - formula606 = _t1191 + _t1178 = self.parse_bindings() + bindings599 = _t1178 + _t1179 = self.parse_formula() + formula600 = _t1179 self.consume_literal(")") - _t1192 = logic_pb2.Abstraction(vars=(list(bindings605[0]) + list(bindings605[1] if bindings605[1] is not None else [])), value=formula606) - return (_t1192, len(bindings605[1]),) + _t1180 = logic_pb2.Abstraction(vars=(list(bindings599[0]) + list(bindings599[1] if bindings599[1] is not None else [])), value=formula600) + return (_t1180, len(bindings599[1]),) def parse_break(self) -> logic_pb2.Break: self.consume_literal("(") self.consume_literal("break") - _t1193 = self.parse_relation_id() - relation_id607 = _t1193 - _t1194 = self.parse_abstraction() - abstraction608 = _t1194 + _t1181 = self.parse_relation_id() + relation_id601 = _t1181 + _t1182 = self.parse_abstraction() + abstraction602 = _t1182 if self.match_lookahead_literal("(", 0): - _t1196 = self.parse_attrs() - _t1195 = _t1196 + _t1184 = self.parse_attrs() + _t1183 = _t1184 else: - _t1195 = None - attrs609 = _t1195 + _t1183 = None + attrs603 = _t1183 self.consume_literal(")") - _t1197 = logic_pb2.Break(name=relation_id607, body=abstraction608, attrs=(attrs609 if attrs609 is not None else [])) - return _t1197 + _t1185 = logic_pb2.Break(name=relation_id601, body=abstraction602, attrs=(attrs603 if attrs603 is not None else [])) + return _t1185 def parse_monoid_def(self) -> logic_pb2.MonoidDef: self.consume_literal("(") self.consume_literal("monoid") - _t1198 = self.parse_monoid() - monoid610 = _t1198 - _t1199 = self.parse_relation_id() - relation_id611 = _t1199 - _t1200 = self.parse_abstraction_with_arity() - abstraction_with_arity612 = _t1200 + _t1186 = self.parse_monoid() + monoid604 = _t1186 + _t1187 = self.parse_relation_id() + relation_id605 = _t1187 + _t1188 = self.parse_abstraction_with_arity() + abstraction_with_arity606 = _t1188 if self.match_lookahead_literal("(", 0): - _t1202 = self.parse_attrs() - _t1201 = _t1202 + _t1190 = self.parse_attrs() + _t1189 = _t1190 else: - _t1201 = None - attrs613 = _t1201 + _t1189 = None + attrs607 = _t1189 self.consume_literal(")") - _t1203 = logic_pb2.MonoidDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[0], attrs=(attrs613 if attrs613 is not None else []), value_arity=abstraction_with_arity612[1]) - return _t1203 + _t1191 = logic_pb2.MonoidDef(monoid=monoid604, name=relation_id605, body=abstraction_with_arity606[0], attrs=(attrs607 if attrs607 is not None else []), value_arity=abstraction_with_arity606[1]) + return _t1191 def parse_monoid(self) -> logic_pb2.Monoid: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1205 = 3 + _t1193 = 3 else: if self.match_lookahead_literal("or", 1): - _t1206 = 0 + _t1194 = 0 else: if self.match_lookahead_literal("min", 1): - _t1207 = 1 + _t1195 = 1 else: if self.match_lookahead_literal("max", 1): - _t1208 = 2 + _t1196 = 2 else: - _t1208 = -1 - _t1207 = _t1208 - _t1206 = _t1207 - _t1205 = _t1206 - _t1204 = _t1205 - else: - _t1204 = -1 - prediction614 = _t1204 - if prediction614 == 3: - _t1210 = self.parse_sum_monoid() - sum_monoid618 = _t1210 - _t1211 = logic_pb2.Monoid(sum_monoid=sum_monoid618) - _t1209 = _t1211 - else: - if prediction614 == 2: - _t1213 = self.parse_max_monoid() - max_monoid617 = _t1213 - _t1214 = logic_pb2.Monoid(max_monoid=max_monoid617) - _t1212 = _t1214 + _t1196 = -1 + _t1195 = _t1196 + _t1194 = _t1195 + _t1193 = _t1194 + _t1192 = _t1193 + else: + _t1192 = -1 + prediction608 = _t1192 + if prediction608 == 3: + _t1198 = self.parse_sum_monoid() + sum_monoid612 = _t1198 + _t1199 = logic_pb2.Monoid(sum_monoid=sum_monoid612) + _t1197 = _t1199 + else: + if prediction608 == 2: + _t1201 = self.parse_max_monoid() + max_monoid611 = _t1201 + _t1202 = logic_pb2.Monoid(max_monoid=max_monoid611) + _t1200 = _t1202 else: - if prediction614 == 1: - _t1216 = self.parse_min_monoid() - min_monoid616 = _t1216 - _t1217 = logic_pb2.Monoid(min_monoid=min_monoid616) - _t1215 = _t1217 + if prediction608 == 1: + _t1204 = self.parse_min_monoid() + min_monoid610 = _t1204 + _t1205 = logic_pb2.Monoid(min_monoid=min_monoid610) + _t1203 = _t1205 else: - if prediction614 == 0: - _t1219 = self.parse_or_monoid() - or_monoid615 = _t1219 - _t1220 = logic_pb2.Monoid(or_monoid=or_monoid615) - _t1218 = _t1220 + if prediction608 == 0: + _t1207 = self.parse_or_monoid() + or_monoid609 = _t1207 + _t1208 = logic_pb2.Monoid(or_monoid=or_monoid609) + _t1206 = _t1208 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1215 = _t1218 - _t1212 = _t1215 - _t1209 = _t1212 - return _t1209 + _t1203 = _t1206 + _t1200 = _t1203 + _t1197 = _t1200 + return _t1197 def parse_or_monoid(self) -> logic_pb2.OrMonoid: self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1221 = logic_pb2.OrMonoid() - return _t1221 + _t1209 = logic_pb2.OrMonoid() + return _t1209 def parse_min_monoid(self) -> logic_pb2.MinMonoid: self.consume_literal("(") self.consume_literal("min") - _t1222 = self.parse_type() - type619 = _t1222 + _t1210 = self.parse_type() + type613 = _t1210 self.consume_literal(")") - _t1223 = logic_pb2.MinMonoid(type=type619) - return _t1223 + _t1211 = logic_pb2.MinMonoid(type=type613) + return _t1211 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: self.consume_literal("(") self.consume_literal("max") - _t1224 = self.parse_type() - type620 = _t1224 + _t1212 = self.parse_type() + type614 = _t1212 self.consume_literal(")") - _t1225 = logic_pb2.MaxMonoid(type=type620) - return _t1225 + _t1213 = logic_pb2.MaxMonoid(type=type614) + return _t1213 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: self.consume_literal("(") self.consume_literal("sum") - _t1226 = self.parse_type() - type621 = _t1226 + _t1214 = self.parse_type() + type615 = _t1214 self.consume_literal(")") - _t1227 = logic_pb2.SumMonoid(type=type621) - return _t1227 + _t1215 = logic_pb2.SumMonoid(type=type615) + return _t1215 def parse_monus_def(self) -> logic_pb2.MonusDef: self.consume_literal("(") self.consume_literal("monus") - _t1228 = self.parse_monoid() - monoid622 = _t1228 - _t1229 = self.parse_relation_id() - relation_id623 = _t1229 - _t1230 = self.parse_abstraction_with_arity() - abstraction_with_arity624 = _t1230 + _t1216 = self.parse_monoid() + monoid616 = _t1216 + _t1217 = self.parse_relation_id() + relation_id617 = _t1217 + _t1218 = self.parse_abstraction_with_arity() + abstraction_with_arity618 = _t1218 if self.match_lookahead_literal("(", 0): - _t1232 = self.parse_attrs() - _t1231 = _t1232 + _t1220 = self.parse_attrs() + _t1219 = _t1220 else: - _t1231 = None - attrs625 = _t1231 + _t1219 = None + attrs619 = _t1219 self.consume_literal(")") - _t1233 = logic_pb2.MonusDef(monoid=monoid622, name=relation_id623, body=abstraction_with_arity624[0], attrs=(attrs625 if attrs625 is not None else []), value_arity=abstraction_with_arity624[1]) - return _t1233 + _t1221 = logic_pb2.MonusDef(monoid=monoid616, name=relation_id617, body=abstraction_with_arity618[0], attrs=(attrs619 if attrs619 is not None else []), value_arity=abstraction_with_arity618[1]) + return _t1221 def parse_constraint(self) -> logic_pb2.Constraint: self.consume_literal("(") self.consume_literal("functional_dependency") - _t1234 = self.parse_relation_id() - relation_id626 = _t1234 - _t1235 = self.parse_abstraction() - abstraction627 = _t1235 - _t1236 = self.parse_functional_dependency_keys() - functional_dependency_keys628 = _t1236 - _t1237 = self.parse_functional_dependency_values() - functional_dependency_values629 = _t1237 - self.consume_literal(")") - _t1238 = logic_pb2.FunctionalDependency(guard=abstraction627, keys=functional_dependency_keys628, values=functional_dependency_values629) - _t1239 = logic_pb2.Constraint(name=relation_id626, functional_dependency=_t1238) - return _t1239 + _t1222 = self.parse_relation_id() + relation_id620 = _t1222 + _t1223 = self.parse_abstraction() + abstraction621 = _t1223 + _t1224 = self.parse_functional_dependency_keys() + functional_dependency_keys622 = _t1224 + _t1225 = self.parse_functional_dependency_values() + functional_dependency_values623 = _t1225 + self.consume_literal(")") + _t1226 = logic_pb2.FunctionalDependency(guard=abstraction621, keys=functional_dependency_keys622, values=functional_dependency_values623) + _t1227 = logic_pb2.Constraint(name=relation_id620, functional_dependency=_t1226) + return _t1227 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs630 = [] - cond631 = self.match_lookahead_terminal("SYMBOL", 0) - while cond631: - _t1240 = self.parse_var() - item632 = _t1240 - xs630.append(item632) - cond631 = self.match_lookahead_terminal("SYMBOL", 0) - vars633 = xs630 + xs624 = [] + cond625 = self.match_lookahead_terminal("SYMBOL", 0) + while cond625: + _t1228 = self.parse_var() + item626 = _t1228 + xs624.append(item626) + cond625 = self.match_lookahead_terminal("SYMBOL", 0) + vars627 = xs624 self.consume_literal(")") - return vars633 + return vars627 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs634 = [] - cond635 = self.match_lookahead_terminal("SYMBOL", 0) - while cond635: - _t1241 = self.parse_var() - item636 = _t1241 - xs634.append(item636) - cond635 = self.match_lookahead_terminal("SYMBOL", 0) - vars637 = xs634 + xs628 = [] + cond629 = self.match_lookahead_terminal("SYMBOL", 0) + while cond629: + _t1229 = self.parse_var() + item630 = _t1229 + xs628.append(item630) + cond629 = self.match_lookahead_terminal("SYMBOL", 0) + vars631 = xs628 self.consume_literal(")") - return vars637 + return vars631 def parse_data(self) -> logic_pb2.Data: if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("rel_edb", 1): - _t1243 = 0 + if self.match_lookahead_literal("edb", 1): + _t1231 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1244 = 2 + _t1232 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1245 = 1 + _t1233 = 1 else: - _t1245 = -1 - _t1244 = _t1245 - _t1243 = _t1244 - _t1242 = _t1243 - else: - _t1242 = -1 - prediction638 = _t1242 - if prediction638 == 2: - _t1247 = self.parse_csv_data() - csv_data641 = _t1247 - _t1248 = logic_pb2.Data(csv_data=csv_data641) - _t1246 = _t1248 - else: - if prediction638 == 1: - _t1250 = self.parse_betree_relation() - betree_relation640 = _t1250 - _t1251 = logic_pb2.Data(betree_relation=betree_relation640) - _t1249 = _t1251 + _t1233 = -1 + _t1232 = _t1233 + _t1231 = _t1232 + _t1230 = _t1231 + else: + _t1230 = -1 + prediction632 = _t1230 + if prediction632 == 2: + _t1235 = self.parse_csv_data() + csv_data635 = _t1235 + _t1236 = logic_pb2.Data(csv_data=csv_data635) + _t1234 = _t1236 + else: + if prediction632 == 1: + _t1238 = self.parse_betree_relation() + betree_relation634 = _t1238 + _t1239 = logic_pb2.Data(betree_relation=betree_relation634) + _t1237 = _t1239 else: - if prediction638 == 0: - _t1253 = self.parse_rel_edb() - rel_edb639 = _t1253 - _t1254 = logic_pb2.Data(rel_edb=rel_edb639) - _t1252 = _t1254 + if prediction632 == 0: + _t1241 = self.parse_edb() + edb633 = _t1241 + _t1242 = logic_pb2.Data(edb=edb633) + _t1240 = _t1242 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1249 = _t1252 - _t1246 = _t1249 - return _t1246 + _t1237 = _t1240 + _t1234 = _t1237 + return _t1234 - def parse_rel_edb(self) -> logic_pb2.RelEDB: + def parse_edb(self) -> logic_pb2.EDB: self.consume_literal("(") - self.consume_literal("rel_edb") - _t1255 = self.parse_relation_id() - relation_id642 = _t1255 - _t1256 = self.parse_rel_edb_path() - rel_edb_path643 = _t1256 - _t1257 = self.parse_rel_edb_types() - rel_edb_types644 = _t1257 + self.consume_literal("edb") + _t1243 = self.parse_relation_id() + relation_id636 = _t1243 + _t1244 = self.parse_edb_path() + edb_path637 = _t1244 + _t1245 = self.parse_edb_types() + edb_types638 = _t1245 self.consume_literal(")") - _t1258 = logic_pb2.RelEDB(target_id=relation_id642, path=rel_edb_path643, types=rel_edb_types644) - return _t1258 + _t1246 = logic_pb2.EDB(target_id=relation_id636, path=edb_path637, types=edb_types638) + return _t1246 - def parse_rel_edb_path(self) -> Sequence[str]: + def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs645 = [] - cond646 = self.match_lookahead_terminal("STRING", 0) - while cond646: - item647 = self.consume_terminal("STRING") - xs645.append(item647) - cond646 = self.match_lookahead_terminal("STRING", 0) - strings648 = xs645 + xs639 = [] + cond640 = self.match_lookahead_terminal("STRING", 0) + while cond640: + item641 = self.consume_terminal("STRING") + xs639.append(item641) + cond640 = self.match_lookahead_terminal("STRING", 0) + strings642 = xs639 self.consume_literal("]") - return strings648 + return strings642 - def parse_rel_edb_types(self) -> Sequence[logic_pb2.Type]: + def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs649 = [] - cond650 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond650: - _t1259 = self.parse_type() - item651 = _t1259 - xs649.append(item651) - cond650 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types652 = xs649 + xs643 = [] + cond644 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond644: + _t1247 = self.parse_type() + item645 = _t1247 + xs643.append(item645) + cond644 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types646 = xs643 self.consume_literal("]") - return types652 + return types646 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: self.consume_literal("(") self.consume_literal("betree_relation") - _t1260 = self.parse_relation_id() - relation_id653 = _t1260 - _t1261 = self.parse_betree_info() - betree_info654 = _t1261 + _t1248 = self.parse_relation_id() + relation_id647 = _t1248 + _t1249 = self.parse_betree_info() + betree_info648 = _t1249 self.consume_literal(")") - _t1262 = logic_pb2.BeTreeRelation(name=relation_id653, relation_info=betree_info654) - return _t1262 + _t1250 = logic_pb2.BeTreeRelation(name=relation_id647, relation_info=betree_info648) + return _t1250 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: self.consume_literal("(") self.consume_literal("betree_info") - _t1263 = self.parse_betree_info_key_types() - betree_info_key_types655 = _t1263 - _t1264 = self.parse_betree_info_value_types() - betree_info_value_types656 = _t1264 - _t1265 = self.parse_config_dict() - config_dict657 = _t1265 - self.consume_literal(")") - _t1266 = self.construct_betree_info(betree_info_key_types655, betree_info_value_types656, config_dict657) - return _t1266 + _t1251 = self.parse_betree_info_key_types() + betree_info_key_types649 = _t1251 + _t1252 = self.parse_betree_info_value_types() + betree_info_value_types650 = _t1252 + _t1253 = self.parse_config_dict() + config_dict651 = _t1253 + self.consume_literal(")") + _t1254 = self.construct_betree_info(betree_info_key_types649, betree_info_value_types650, config_dict651) + return _t1254 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs658 = [] - cond659 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond659: - _t1267 = self.parse_type() - item660 = _t1267 - xs658.append(item660) - cond659 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types661 = xs658 + xs652 = [] + cond653 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond653: + _t1255 = self.parse_type() + item654 = _t1255 + xs652.append(item654) + cond653 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types655 = xs652 self.consume_literal(")") - return types661 + return types655 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs662 = [] - cond663 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond663: - _t1268 = self.parse_type() - item664 = _t1268 - xs662.append(item664) - cond663 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types665 = xs662 + xs656 = [] + cond657 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond657: + _t1256 = self.parse_type() + item658 = _t1256 + xs656.append(item658) + cond657 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types659 = xs656 self.consume_literal(")") - return types665 + return types659 def parse_csv_data(self) -> logic_pb2.CSVData: self.consume_literal("(") self.consume_literal("csv_data") - _t1269 = self.parse_csvlocator() - csvlocator666 = _t1269 - _t1270 = self.parse_csv_config() - csv_config667 = _t1270 - _t1271 = self.parse_csv_columns() - csv_columns668 = _t1271 - _t1272 = self.parse_csv_asof() - csv_asof669 = _t1272 - self.consume_literal(")") - _t1273 = logic_pb2.CSVData(locator=csvlocator666, config=csv_config667, columns=csv_columns668, asof=csv_asof669) - return _t1273 + _t1257 = self.parse_csvlocator() + csvlocator660 = _t1257 + _t1258 = self.parse_csv_config() + csv_config661 = _t1258 + _t1259 = self.parse_gnf_columns() + gnf_columns662 = _t1259 + _t1260 = self.parse_csv_asof() + csv_asof663 = _t1260 + self.consume_literal(")") + _t1261 = logic_pb2.CSVData(locator=csvlocator660, config=csv_config661, columns=gnf_columns662, asof=csv_asof663) + return _t1261 def parse_csvlocator(self) -> logic_pb2.CSVLocator: self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1275 = self.parse_csv_locator_paths() - _t1274 = _t1275 + _t1263 = self.parse_csv_locator_paths() + _t1262 = _t1263 else: - _t1274 = None - csv_locator_paths670 = _t1274 + _t1262 = None + csv_locator_paths664 = _t1262 if self.match_lookahead_literal("(", 0): - _t1277 = self.parse_csv_locator_inline_data() - _t1276 = _t1277 + _t1265 = self.parse_csv_locator_inline_data() + _t1264 = _t1265 else: - _t1276 = None - csv_locator_inline_data671 = _t1276 + _t1264 = None + csv_locator_inline_data665 = _t1264 self.consume_literal(")") - _t1278 = logic_pb2.CSVLocator(paths=(csv_locator_paths670 if csv_locator_paths670 is not None else []), inline_data=(csv_locator_inline_data671 if csv_locator_inline_data671 is not None else "").encode()) - return _t1278 + _t1266 = logic_pb2.CSVLocator(paths=(csv_locator_paths664 if csv_locator_paths664 is not None else []), inline_data=(csv_locator_inline_data665 if csv_locator_inline_data665 is not None else "").encode()) + return _t1266 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs672 = [] - cond673 = self.match_lookahead_terminal("STRING", 0) - while cond673: - item674 = self.consume_terminal("STRING") - xs672.append(item674) - cond673 = self.match_lookahead_terminal("STRING", 0) - strings675 = xs672 + xs666 = [] + cond667 = self.match_lookahead_terminal("STRING", 0) + while cond667: + item668 = self.consume_terminal("STRING") + xs666.append(item668) + cond667 = self.match_lookahead_terminal("STRING", 0) + strings669 = xs666 self.consume_literal(")") - return strings675 + return strings669 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - string676 = self.consume_terminal("STRING") + string670 = self.consume_terminal("STRING") self.consume_literal(")") - return string676 + return string670 def parse_csv_config(self) -> logic_pb2.CSVConfig: self.consume_literal("(") self.consume_literal("csv_config") - _t1279 = self.parse_config_dict() - config_dict677 = _t1279 + _t1267 = self.parse_config_dict() + config_dict671 = _t1267 self.consume_literal(")") - _t1280 = self.construct_csv_config(config_dict677) - return _t1280 + _t1268 = self.construct_csv_config(config_dict671) + return _t1268 - def parse_csv_columns(self) -> Sequence[logic_pb2.CSVColumn]: + def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs678 = [] - cond679 = self.match_lookahead_literal("(", 0) - while cond679: - _t1281 = self.parse_csv_column() - item680 = _t1281 - xs678.append(item680) - cond679 = self.match_lookahead_literal("(", 0) - csv_columns681 = xs678 + xs672 = [] + cond673 = self.match_lookahead_literal("(", 0) + while cond673: + _t1269 = self.parse_gnf_column() + item674 = _t1269 + xs672.append(item674) + cond673 = self.match_lookahead_literal("(", 0) + gnf_columns675 = xs672 self.consume_literal(")") - return csv_columns681 + return gnf_columns675 - def parse_csv_column(self) -> logic_pb2.CSVColumn: + def parse_gnf_column(self) -> logic_pb2.GNFColumn: self.consume_literal("(") self.consume_literal("column") - _t1282 = self.parse_csv_column_path() - csv_column_path682 = _t1282 - if ((self.match_lookahead_literal(":", 0) or self.match_lookahead_literal("[", 0)) or self.match_lookahead_terminal("UINT128", 0)): - _t1284 = self.parse_csv_column_tail() - _t1283 = _t1284 - else: - _t1283 = None - csv_column_tail683 = _t1283 + _t1270 = self.parse_gnf_column_path() + gnf_column_path676 = _t1270 + if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): + _t1272 = self.parse_relation_id() + _t1271 = _t1272 + else: + _t1271 = None + relation_id677 = _t1271 + self.consume_literal("[") + xs678 = [] + cond679 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond679: + _t1273 = self.parse_type() + item680 = _t1273 + xs678.append(item680) + cond679 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types681 = xs678 + self.consume_literal("]") self.consume_literal(")") - _t1285 = self.construct_csv_column(csv_column_path682, csv_column_tail683) - return _t1285 + _t1274 = logic_pb2.GNFColumn(column_path=gnf_column_path676, target_id=relation_id677, types=types681) + return _t1274 - def parse_csv_column_path(self) -> Sequence[str]: + def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t1286 = 1 + _t1275 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1287 = 0 + _t1276 = 0 else: - _t1287 = -1 - _t1286 = _t1287 - prediction684 = _t1286 - if prediction684 == 1: + _t1276 = -1 + _t1275 = _t1276 + prediction682 = _t1275 + if prediction682 == 1: self.consume_literal("[") - xs686 = [] - cond687 = self.match_lookahead_terminal("STRING", 0) - while cond687: - item688 = self.consume_terminal("STRING") - xs686.append(item688) - cond687 = self.match_lookahead_terminal("STRING", 0) - strings689 = xs686 + xs684 = [] + cond685 = self.match_lookahead_terminal("STRING", 0) + while cond685: + item686 = self.consume_terminal("STRING") + xs684.append(item686) + cond685 = self.match_lookahead_terminal("STRING", 0) + strings687 = xs684 self.consume_literal("]") - _t1288 = strings689 - else: - if prediction684 == 0: - string685 = self.consume_terminal("STRING") - _t1289 = [string685] - else: - raise ParseError("Unexpected token in csv_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1288 = _t1289 - return _t1288 - - def parse_csv_column_tail(self) -> tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]: - if self.match_lookahead_literal("[", 0): - _t1290 = 1 + _t1277 = strings687 else: - if self.match_lookahead_literal(":", 0): - _t1291 = 0 + if prediction682 == 0: + string683 = self.consume_terminal("STRING") + _t1278 = [string683] else: - if self.match_lookahead_terminal("UINT128", 0): - _t1292 = 0 - else: - _t1292 = -1 - _t1291 = _t1292 - _t1290 = _t1291 - prediction690 = _t1290 - if prediction690 == 1: - self.consume_literal("[") - xs696 = [] - cond697 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond697: - _t1294 = self.parse_type() - item698 = _t1294 - xs696.append(item698) - cond697 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types699 = xs696 - self.consume_literal("]") - _t1293 = (None, types699,) - else: - if prediction690 == 0: - _t1296 = self.parse_relation_id() - relation_id691 = _t1296 - self.consume_literal("[") - xs692 = [] - cond693 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond693: - _t1297 = self.parse_type() - item694 = _t1297 - xs692.append(item694) - cond693 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types695 = xs692 - self.consume_literal("]") - _t1295 = (relation_id691, types695,) - else: - raise ParseError("Unexpected token in csv_column_tail" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1293 = _t1295 - return _t1293 + raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t1277 = _t1278 + return _t1277 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string700 = self.consume_terminal("STRING") + string688 = self.consume_terminal("STRING") self.consume_literal(")") - return string700 + return string688 def parse_undefine(self) -> transactions_pb2.Undefine: self.consume_literal("(") self.consume_literal("undefine") - _t1298 = self.parse_fragment_id() - fragment_id701 = _t1298 + _t1279 = self.parse_fragment_id() + fragment_id689 = _t1279 self.consume_literal(")") - _t1299 = transactions_pb2.Undefine(fragment_id=fragment_id701) - return _t1299 + _t1280 = transactions_pb2.Undefine(fragment_id=fragment_id689) + return _t1280 def parse_context(self) -> transactions_pb2.Context: self.consume_literal("(") self.consume_literal("context") - xs702 = [] - cond703 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond703: - _t1300 = self.parse_relation_id() - item704 = _t1300 - xs702.append(item704) - cond703 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids705 = xs702 - self.consume_literal(")") - _t1301 = transactions_pb2.Context(relations=relation_ids705) - return _t1301 + xs690 = [] + cond691 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond691: + _t1281 = self.parse_relation_id() + item692 = _t1281 + xs690.append(item692) + cond691 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids693 = xs690 + self.consume_literal(")") + _t1282 = transactions_pb2.Context(relations=relation_ids693) + return _t1282 def parse_snapshot(self) -> transactions_pb2.Snapshot: self.consume_literal("(") self.consume_literal("snapshot") - _t1302 = self.parse_rel_edb_path() - rel_edb_path706 = _t1302 - _t1303 = self.parse_relation_id() - relation_id707 = _t1303 + _t1283 = self.parse_edb_path() + edb_path694 = _t1283 + _t1284 = self.parse_relation_id() + relation_id695 = _t1284 self.consume_literal(")") - _t1304 = transactions_pb2.Snapshot(destination_path=rel_edb_path706, source_relation=relation_id707) - return _t1304 + _t1285 = transactions_pb2.Snapshot(destination_path=edb_path694, source_relation=relation_id695) + return _t1285 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs708 = [] - cond709 = self.match_lookahead_literal("(", 0) - while cond709: - _t1305 = self.parse_read() - item710 = _t1305 - xs708.append(item710) - cond709 = self.match_lookahead_literal("(", 0) - reads711 = xs708 + xs696 = [] + cond697 = self.match_lookahead_literal("(", 0) + while cond697: + _t1286 = self.parse_read() + item698 = _t1286 + xs696.append(item698) + cond697 = self.match_lookahead_literal("(", 0) + reads699 = xs696 self.consume_literal(")") - return reads711 + return reads699 def parse_read(self) -> transactions_pb2.Read: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t1307 = 2 + _t1288 = 2 else: if self.match_lookahead_literal("output", 1): - _t1308 = 1 + _t1289 = 1 else: if self.match_lookahead_literal("export", 1): - _t1309 = 4 + _t1290 = 4 else: if self.match_lookahead_literal("demand", 1): - _t1310 = 0 + _t1291 = 0 else: if self.match_lookahead_literal("abort", 1): - _t1311 = 3 + _t1292 = 3 else: - _t1311 = -1 - _t1310 = _t1311 - _t1309 = _t1310 - _t1308 = _t1309 - _t1307 = _t1308 - _t1306 = _t1307 - else: - _t1306 = -1 - prediction712 = _t1306 - if prediction712 == 4: - _t1313 = self.parse_export() - export717 = _t1313 - _t1314 = transactions_pb2.Read(export=export717) - _t1312 = _t1314 - else: - if prediction712 == 3: - _t1316 = self.parse_abort() - abort716 = _t1316 - _t1317 = transactions_pb2.Read(abort=abort716) - _t1315 = _t1317 + _t1292 = -1 + _t1291 = _t1292 + _t1290 = _t1291 + _t1289 = _t1290 + _t1288 = _t1289 + _t1287 = _t1288 + else: + _t1287 = -1 + prediction700 = _t1287 + if prediction700 == 4: + _t1294 = self.parse_export() + export705 = _t1294 + _t1295 = transactions_pb2.Read(export=export705) + _t1293 = _t1295 + else: + if prediction700 == 3: + _t1297 = self.parse_abort() + abort704 = _t1297 + _t1298 = transactions_pb2.Read(abort=abort704) + _t1296 = _t1298 else: - if prediction712 == 2: - _t1319 = self.parse_what_if() - what_if715 = _t1319 - _t1320 = transactions_pb2.Read(what_if=what_if715) - _t1318 = _t1320 + if prediction700 == 2: + _t1300 = self.parse_what_if() + what_if703 = _t1300 + _t1301 = transactions_pb2.Read(what_if=what_if703) + _t1299 = _t1301 else: - if prediction712 == 1: - _t1322 = self.parse_output() - output714 = _t1322 - _t1323 = transactions_pb2.Read(output=output714) - _t1321 = _t1323 + if prediction700 == 1: + _t1303 = self.parse_output() + output702 = _t1303 + _t1304 = transactions_pb2.Read(output=output702) + _t1302 = _t1304 else: - if prediction712 == 0: - _t1325 = self.parse_demand() - demand713 = _t1325 - _t1326 = transactions_pb2.Read(demand=demand713) - _t1324 = _t1326 + if prediction700 == 0: + _t1306 = self.parse_demand() + demand701 = _t1306 + _t1307 = transactions_pb2.Read(demand=demand701) + _t1305 = _t1307 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1321 = _t1324 - _t1318 = _t1321 - _t1315 = _t1318 - _t1312 = _t1315 - return _t1312 + _t1302 = _t1305 + _t1299 = _t1302 + _t1296 = _t1299 + _t1293 = _t1296 + return _t1293 def parse_demand(self) -> transactions_pb2.Demand: self.consume_literal("(") self.consume_literal("demand") - _t1327 = self.parse_relation_id() - relation_id718 = _t1327 + _t1308 = self.parse_relation_id() + relation_id706 = _t1308 self.consume_literal(")") - _t1328 = transactions_pb2.Demand(relation_id=relation_id718) - return _t1328 + _t1309 = transactions_pb2.Demand(relation_id=relation_id706) + return _t1309 def parse_output(self) -> transactions_pb2.Output: self.consume_literal("(") self.consume_literal("output") - _t1329 = self.parse_name() - name719 = _t1329 - _t1330 = self.parse_relation_id() - relation_id720 = _t1330 + _t1310 = self.parse_name() + name707 = _t1310 + _t1311 = self.parse_relation_id() + relation_id708 = _t1311 self.consume_literal(")") - _t1331 = transactions_pb2.Output(name=name719, relation_id=relation_id720) - return _t1331 + _t1312 = transactions_pb2.Output(name=name707, relation_id=relation_id708) + return _t1312 def parse_what_if(self) -> transactions_pb2.WhatIf: self.consume_literal("(") self.consume_literal("what_if") - _t1332 = self.parse_name() - name721 = _t1332 - _t1333 = self.parse_epoch() - epoch722 = _t1333 + _t1313 = self.parse_name() + name709 = _t1313 + _t1314 = self.parse_epoch() + epoch710 = _t1314 self.consume_literal(")") - _t1334 = transactions_pb2.WhatIf(branch=name721, epoch=epoch722) - return _t1334 + _t1315 = transactions_pb2.WhatIf(branch=name709, epoch=epoch710) + return _t1315 def parse_abort(self) -> transactions_pb2.Abort: self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t1336 = self.parse_name() - _t1335 = _t1336 + _t1317 = self.parse_name() + _t1316 = _t1317 else: - _t1335 = None - name723 = _t1335 - _t1337 = self.parse_relation_id() - relation_id724 = _t1337 + _t1316 = None + name711 = _t1316 + _t1318 = self.parse_relation_id() + relation_id712 = _t1318 self.consume_literal(")") - _t1338 = transactions_pb2.Abort(name=(name723 if name723 is not None else "abort"), relation_id=relation_id724) - return _t1338 + _t1319 = transactions_pb2.Abort(name=(name711 if name711 is not None else "abort"), relation_id=relation_id712) + return _t1319 def parse_export(self) -> transactions_pb2.Export: self.consume_literal("(") self.consume_literal("export") - _t1339 = self.parse_export_csv_config() - export_csv_config725 = _t1339 + _t1320 = self.parse_export_csv_config() + export_csv_config713 = _t1320 self.consume_literal(")") - _t1340 = transactions_pb2.Export(csv_config=export_csv_config725) - return _t1340 + _t1321 = transactions_pb2.Export(csv_config=export_csv_config713) + return _t1321 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: self.consume_literal("(") self.consume_literal("export_csv_config") - _t1341 = self.parse_export_csv_path() - export_csv_path726 = _t1341 - _t1342 = self.parse_export_csv_columns() - export_csv_columns727 = _t1342 - _t1343 = self.parse_config_dict() - config_dict728 = _t1343 + _t1322 = self.parse_export_csv_path() + export_csv_path714 = _t1322 + _t1323 = self.parse_export_csv_columns() + export_csv_columns715 = _t1323 + _t1324 = self.parse_config_dict() + config_dict716 = _t1324 self.consume_literal(")") - _t1344 = self.export_csv_config(export_csv_path726, export_csv_columns727, config_dict728) - return _t1344 + _t1325 = self.export_csv_config(export_csv_path714, export_csv_columns715, config_dict716) + return _t1325 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string729 = self.consume_terminal("STRING") + string717 = self.consume_terminal("STRING") self.consume_literal(")") - return string729 + return string717 def parse_export_csv_columns(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs730 = [] - cond731 = self.match_lookahead_literal("(", 0) - while cond731: - _t1345 = self.parse_export_csv_column() - item732 = _t1345 - xs730.append(item732) - cond731 = self.match_lookahead_literal("(", 0) - export_csv_columns733 = xs730 + xs718 = [] + cond719 = self.match_lookahead_literal("(", 0) + while cond719: + _t1326 = self.parse_export_csv_column() + item720 = _t1326 + xs718.append(item720) + cond719 = self.match_lookahead_literal("(", 0) + export_csv_columns721 = xs718 self.consume_literal(")") - return export_csv_columns733 + return export_csv_columns721 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: self.consume_literal("(") self.consume_literal("column") - string734 = self.consume_terminal("STRING") - _t1346 = self.parse_relation_id() - relation_id735 = _t1346 + string722 = self.consume_terminal("STRING") + _t1327 = self.parse_relation_id() + relation_id723 = _t1327 self.consume_literal(")") - _t1347 = transactions_pb2.ExportCSVColumn(column_name=string734, column_data=relation_id735) - return _t1347 + _t1328 = transactions_pb2.ExportCSVColumn(column_name=string722, column_data=relation_id723) + return _t1328 def parse(input_str: str) -> Any: diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index 0a04c46e..1a00f0c1 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -193,140 +193,133 @@ def write_debug_info(self) -> None: # --- Helper functions --- def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1698 = logic_pb2.Value(int_value=int(v)) - return _t1698 + _t1677 = logic_pb2.Value(int_value=int(v)) + return _t1677 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1699 = logic_pb2.Value(int_value=v) - return _t1699 + _t1678 = logic_pb2.Value(int_value=v) + return _t1678 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1700 = logic_pb2.Value(float_value=v) - return _t1700 + _t1679 = logic_pb2.Value(float_value=v) + return _t1679 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1701 = logic_pb2.Value(string_value=v) - return _t1701 + _t1680 = logic_pb2.Value(string_value=v) + return _t1680 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1702 = logic_pb2.Value(boolean_value=v) - return _t1702 + _t1681 = logic_pb2.Value(boolean_value=v) + return _t1681 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1703 = logic_pb2.Value(uint128_value=v) - return _t1703 + _t1682 = logic_pb2.Value(uint128_value=v) + return _t1682 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: - _t1704 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1704,)) + _t1683 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1683,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1705 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1705,)) + _t1684 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1684,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1706 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1706,)) - _t1707 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1707,)) + _t1685 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1685,)) + _t1686 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1686,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1708 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1708,)) - _t1709 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1709,)) + _t1687 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1687,)) + _t1688 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1688,)) if msg.new_line != "": - _t1710 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1710,)) - _t1711 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1711,)) - _t1712 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1712,)) - _t1713 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1713,)) + _t1689 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1689,)) + _t1690 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1690,)) + _t1691 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1691,)) + _t1692 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1692,)) if msg.comment != "": - _t1714 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1714,)) + _t1693 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1693,)) for missing_string in msg.missing_strings: - _t1715 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1715,)) - _t1716 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1716,)) - _t1717 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1717,)) - _t1718 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1718,)) + _t1694 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1694,)) + _t1695 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1695,)) + _t1696 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1696,)) + _t1697 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1697,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1719 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1719,)) - _t1720 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1720,)) - _t1721 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1721,)) - _t1722 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1722,)) + _t1698 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1698,)) + _t1699 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1699,)) + _t1700 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1700,)) + _t1701 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1701,)) 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 - _t1723 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1723,)) + _t1702 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1702,)) 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 - _t1724 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1724,)) - _t1725 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1725,)) - _t1726 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1726,)) + _t1703 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1703,)) + _t1704 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1704,)) + _t1705 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1705,)) 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 - _t1727 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1727,)) + _t1706 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1706,)) if msg.compression is not None: assert msg.compression is not None - _t1728 = self._make_value_string(msg.compression) - result.append(("compression", _t1728,)) + _t1707 = self._make_value_string(msg.compression) + result.append(("compression", _t1707,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1729 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1729,)) + _t1708 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1708,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1730 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1730,)) + _t1709 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1709,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1731 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1731,)) + _t1710 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1710,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1732 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1732,)) + _t1711 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1711,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1733 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1733,)) + _t1712 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1712,)) return sorted(result) - def deconstruct_csv_column_tail(self, col: logic_pb2.CSVColumn) -> Optional[tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]]: - if (col.HasField("target_id") or not len(col.types) == 0): - return (col.target_id, col.types,) - else: - _t1734 = None - return None - def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: name = self.relation_id_to_string(msg) assert name is not None @@ -337,7 +330,7 @@ def deconstruct_relation_id_uint128(self, msg: logic_pb2.RelationId) -> Optional if name is None: return self.relation_id_to_uint128(msg) else: - _t1735 = None + _t1713 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -352,3535 +345,3502 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat654 = self._try_flat(msg, self.pretty_transaction) - if flat654 is not None: - assert flat654 is not None - self.write(flat654) + flat646 = self._try_flat(msg, self.pretty_transaction) + if flat646 is not None: + assert flat646 is not None + self.write(flat646) return None else: - def _t1290(_dollar_dollar): + def _t1274(_dollar_dollar): if _dollar_dollar.HasField("configure"): - _t1291 = _dollar_dollar.configure + _t1275 = _dollar_dollar.configure else: - _t1291 = None + _t1275 = None if _dollar_dollar.HasField("sync"): - _t1292 = _dollar_dollar.sync + _t1276 = _dollar_dollar.sync else: - _t1292 = None - return (_t1291, _t1292, _dollar_dollar.epochs,) - _t1293 = _t1290(msg) - fields645 = _t1293 - assert fields645 is not None - unwrapped_fields646 = fields645 + _t1276 = None + return (_t1275, _t1276, _dollar_dollar.epochs,) + _t1277 = _t1274(msg) + fields637 = _t1277 + assert fields637 is not None + unwrapped_fields638 = fields637 self.write("(") self.write("transaction") self.indent_sexp() - field647 = unwrapped_fields646[0] - if field647 is not None: + field639 = unwrapped_fields638[0] + if field639 is not None: self.newline() - assert field647 is not None - opt_val648 = field647 - self.pretty_configure(opt_val648) - field649 = unwrapped_fields646[1] - if field649 is not None: + assert field639 is not None + opt_val640 = field639 + self.pretty_configure(opt_val640) + field641 = unwrapped_fields638[1] + if field641 is not None: self.newline() - assert field649 is not None - opt_val650 = field649 - self.pretty_sync(opt_val650) - field651 = unwrapped_fields646[2] - if not len(field651) == 0: + assert field641 is not None + opt_val642 = field641 + self.pretty_sync(opt_val642) + field643 = unwrapped_fields638[2] + if not len(field643) == 0: self.newline() - for i653, elem652 in enumerate(field651): - if (i653 > 0): + for i645, elem644 in enumerate(field643): + if (i645 > 0): self.newline() - self.pretty_epoch(elem652) + self.pretty_epoch(elem644) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat657 = self._try_flat(msg, self.pretty_configure) - if flat657 is not None: - assert flat657 is not None - self.write(flat657) + flat649 = self._try_flat(msg, self.pretty_configure) + if flat649 is not None: + assert flat649 is not None + self.write(flat649) return None else: - def _t1294(_dollar_dollar): - _t1295 = self.deconstruct_configure(_dollar_dollar) - return _t1295 - _t1296 = _t1294(msg) - fields655 = _t1296 - assert fields655 is not None - unwrapped_fields656 = fields655 + def _t1278(_dollar_dollar): + _t1279 = self.deconstruct_configure(_dollar_dollar) + return _t1279 + _t1280 = _t1278(msg) + fields647 = _t1280 + assert fields647 is not None + unwrapped_fields648 = fields647 self.write("(") self.write("configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields656) + self.pretty_config_dict(unwrapped_fields648) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat661 = self._try_flat(msg, self.pretty_config_dict) - if flat661 is not None: - assert flat661 is not None - self.write(flat661) + flat653 = self._try_flat(msg, self.pretty_config_dict) + if flat653 is not None: + assert flat653 is not None + self.write(flat653) return None else: - fields658 = msg + fields650 = msg self.write("{") self.indent() - if not len(fields658) == 0: + if not len(fields650) == 0: self.newline() - for i660, elem659 in enumerate(fields658): - if (i660 > 0): + for i652, elem651 in enumerate(fields650): + if (i652 > 0): self.newline() - self.pretty_config_key_value(elem659) + self.pretty_config_key_value(elem651) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat666 = self._try_flat(msg, self.pretty_config_key_value) - if flat666 is not None: - assert flat666 is not None - self.write(flat666) + flat658 = self._try_flat(msg, self.pretty_config_key_value) + if flat658 is not None: + assert flat658 is not None + self.write(flat658) return None else: - def _t1297(_dollar_dollar): + def _t1281(_dollar_dollar): return (_dollar_dollar[0], _dollar_dollar[1],) - _t1298 = _t1297(msg) - fields662 = _t1298 - assert fields662 is not None - unwrapped_fields663 = fields662 + _t1282 = _t1281(msg) + fields654 = _t1282 + assert fields654 is not None + unwrapped_fields655 = fields654 self.write(":") - field664 = unwrapped_fields663[0] - self.write(field664) + field656 = unwrapped_fields655[0] + self.write(field656) self.write(" ") - field665 = unwrapped_fields663[1] - self.pretty_value(field665) + field657 = unwrapped_fields655[1] + self.pretty_value(field657) def pretty_value(self, msg: logic_pb2.Value): - flat686 = self._try_flat(msg, self.pretty_value) - if flat686 is not None: - assert flat686 is not None - self.write(flat686) + flat678 = self._try_flat(msg, self.pretty_value) + if flat678 is not None: + assert flat678 is not None + self.write(flat678) return None else: - def _t1299(_dollar_dollar): + def _t1283(_dollar_dollar): if _dollar_dollar.HasField("date_value"): - _t1300 = _dollar_dollar.date_value + _t1284 = _dollar_dollar.date_value else: - _t1300 = None - return _t1300 - _t1301 = _t1299(msg) - deconstruct_result684 = _t1301 - if deconstruct_result684 is not None: - assert deconstruct_result684 is not None - unwrapped685 = deconstruct_result684 - self.pretty_date(unwrapped685) + _t1284 = None + return _t1284 + _t1285 = _t1283(msg) + deconstruct_result676 = _t1285 + if deconstruct_result676 is not None: + assert deconstruct_result676 is not None + unwrapped677 = deconstruct_result676 + self.pretty_date(unwrapped677) else: - def _t1302(_dollar_dollar): + def _t1286(_dollar_dollar): if _dollar_dollar.HasField("datetime_value"): - _t1303 = _dollar_dollar.datetime_value + _t1287 = _dollar_dollar.datetime_value else: - _t1303 = None - return _t1303 - _t1304 = _t1302(msg) - deconstruct_result682 = _t1304 - if deconstruct_result682 is not None: - assert deconstruct_result682 is not None - unwrapped683 = deconstruct_result682 - self.pretty_datetime(unwrapped683) + _t1287 = None + return _t1287 + _t1288 = _t1286(msg) + deconstruct_result674 = _t1288 + if deconstruct_result674 is not None: + assert deconstruct_result674 is not None + unwrapped675 = deconstruct_result674 + self.pretty_datetime(unwrapped675) else: - def _t1305(_dollar_dollar): + def _t1289(_dollar_dollar): if _dollar_dollar.HasField("string_value"): - _t1306 = _dollar_dollar.string_value + _t1290 = _dollar_dollar.string_value else: - _t1306 = None - return _t1306 - _t1307 = _t1305(msg) - deconstruct_result680 = _t1307 - if deconstruct_result680 is not None: - assert deconstruct_result680 is not None - unwrapped681 = deconstruct_result680 - self.write(self.format_string_value(unwrapped681)) + _t1290 = None + return _t1290 + _t1291 = _t1289(msg) + deconstruct_result672 = _t1291 + if deconstruct_result672 is not None: + assert deconstruct_result672 is not None + unwrapped673 = deconstruct_result672 + self.write(self.format_string_value(unwrapped673)) else: - def _t1308(_dollar_dollar): + def _t1292(_dollar_dollar): if _dollar_dollar.HasField("int_value"): - _t1309 = _dollar_dollar.int_value + _t1293 = _dollar_dollar.int_value else: - _t1309 = None - return _t1309 - _t1310 = _t1308(msg) - deconstruct_result678 = _t1310 - if deconstruct_result678 is not None: - assert deconstruct_result678 is not None - unwrapped679 = deconstruct_result678 - self.write(str(unwrapped679)) + _t1293 = None + return _t1293 + _t1294 = _t1292(msg) + deconstruct_result670 = _t1294 + if deconstruct_result670 is not None: + assert deconstruct_result670 is not None + unwrapped671 = deconstruct_result670 + self.write(str(unwrapped671)) else: - def _t1311(_dollar_dollar): + def _t1295(_dollar_dollar): if _dollar_dollar.HasField("float_value"): - _t1312 = _dollar_dollar.float_value + _t1296 = _dollar_dollar.float_value else: - _t1312 = None - return _t1312 - _t1313 = _t1311(msg) - deconstruct_result676 = _t1313 - if deconstruct_result676 is not None: - assert deconstruct_result676 is not None - unwrapped677 = deconstruct_result676 - self.write(str(unwrapped677)) + _t1296 = None + return _t1296 + _t1297 = _t1295(msg) + deconstruct_result668 = _t1297 + if deconstruct_result668 is not None: + assert deconstruct_result668 is not None + unwrapped669 = deconstruct_result668 + self.write(str(unwrapped669)) else: - def _t1314(_dollar_dollar): + def _t1298(_dollar_dollar): if _dollar_dollar.HasField("uint128_value"): - _t1315 = _dollar_dollar.uint128_value + _t1299 = _dollar_dollar.uint128_value else: - _t1315 = None - return _t1315 - _t1316 = _t1314(msg) - deconstruct_result674 = _t1316 - if deconstruct_result674 is not None: - assert deconstruct_result674 is not None - unwrapped675 = deconstruct_result674 - self.write(self.format_uint128(unwrapped675)) + _t1299 = None + return _t1299 + _t1300 = _t1298(msg) + deconstruct_result666 = _t1300 + if deconstruct_result666 is not None: + assert deconstruct_result666 is not None + unwrapped667 = deconstruct_result666 + self.write(self.format_uint128(unwrapped667)) else: - def _t1317(_dollar_dollar): + def _t1301(_dollar_dollar): if _dollar_dollar.HasField("int128_value"): - _t1318 = _dollar_dollar.int128_value + _t1302 = _dollar_dollar.int128_value else: - _t1318 = None - return _t1318 - _t1319 = _t1317(msg) - deconstruct_result672 = _t1319 - if deconstruct_result672 is not None: - assert deconstruct_result672 is not None - unwrapped673 = deconstruct_result672 - self.write(self.format_int128(unwrapped673)) + _t1302 = None + return _t1302 + _t1303 = _t1301(msg) + deconstruct_result664 = _t1303 + if deconstruct_result664 is not None: + assert deconstruct_result664 is not None + unwrapped665 = deconstruct_result664 + self.write(self.format_int128(unwrapped665)) else: - def _t1320(_dollar_dollar): + def _t1304(_dollar_dollar): if _dollar_dollar.HasField("decimal_value"): - _t1321 = _dollar_dollar.decimal_value + _t1305 = _dollar_dollar.decimal_value else: - _t1321 = None - return _t1321 - _t1322 = _t1320(msg) - deconstruct_result670 = _t1322 - if deconstruct_result670 is not None: - assert deconstruct_result670 is not None - unwrapped671 = deconstruct_result670 - self.write(self.format_decimal(unwrapped671)) + _t1305 = None + return _t1305 + _t1306 = _t1304(msg) + deconstruct_result662 = _t1306 + if deconstruct_result662 is not None: + assert deconstruct_result662 is not None + unwrapped663 = deconstruct_result662 + self.write(self.format_decimal(unwrapped663)) else: - def _t1323(_dollar_dollar): + def _t1307(_dollar_dollar): if _dollar_dollar.HasField("boolean_value"): - _t1324 = _dollar_dollar.boolean_value + _t1308 = _dollar_dollar.boolean_value else: - _t1324 = None - return _t1324 - _t1325 = _t1323(msg) - deconstruct_result668 = _t1325 - if deconstruct_result668 is not None: - assert deconstruct_result668 is not None - unwrapped669 = deconstruct_result668 - self.pretty_boolean_value(unwrapped669) + _t1308 = None + return _t1308 + _t1309 = _t1307(msg) + deconstruct_result660 = _t1309 + if deconstruct_result660 is not None: + assert deconstruct_result660 is not None + unwrapped661 = deconstruct_result660 + self.pretty_boolean_value(unwrapped661) else: - fields667 = msg + fields659 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat692 = self._try_flat(msg, self.pretty_date) - if flat692 is not None: - assert flat692 is not None - self.write(flat692) + flat684 = self._try_flat(msg, self.pretty_date) + if flat684 is not None: + assert flat684 is not None + self.write(flat684) return None else: - def _t1326(_dollar_dollar): + def _t1310(_dollar_dollar): return (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - _t1327 = _t1326(msg) - fields687 = _t1327 - assert fields687 is not None - unwrapped_fields688 = fields687 + _t1311 = _t1310(msg) + fields679 = _t1311 + assert fields679 is not None + unwrapped_fields680 = fields679 self.write("(") self.write("date") self.indent_sexp() self.newline() - field689 = unwrapped_fields688[0] - self.write(str(field689)) + field681 = unwrapped_fields680[0] + self.write(str(field681)) self.newline() - field690 = unwrapped_fields688[1] - self.write(str(field690)) + field682 = unwrapped_fields680[1] + self.write(str(field682)) self.newline() - field691 = unwrapped_fields688[2] - self.write(str(field691)) + field683 = unwrapped_fields680[2] + self.write(str(field683)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat703 = self._try_flat(msg, self.pretty_datetime) - if flat703 is not None: - assert flat703 is not None - self.write(flat703) + flat695 = self._try_flat(msg, self.pretty_datetime) + if flat695 is not None: + assert flat695 is not None + self.write(flat695) return None else: - def _t1328(_dollar_dollar): + def _t1312(_dollar_dollar): return (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),) - _t1329 = _t1328(msg) - fields693 = _t1329 - assert fields693 is not None - unwrapped_fields694 = fields693 + _t1313 = _t1312(msg) + fields685 = _t1313 + assert fields685 is not None + unwrapped_fields686 = fields685 self.write("(") self.write("datetime") self.indent_sexp() self.newline() - field695 = unwrapped_fields694[0] - self.write(str(field695)) + field687 = unwrapped_fields686[0] + self.write(str(field687)) self.newline() - field696 = unwrapped_fields694[1] - self.write(str(field696)) + field688 = unwrapped_fields686[1] + self.write(str(field688)) self.newline() - field697 = unwrapped_fields694[2] - self.write(str(field697)) + field689 = unwrapped_fields686[2] + self.write(str(field689)) self.newline() - field698 = unwrapped_fields694[3] - self.write(str(field698)) + field690 = unwrapped_fields686[3] + self.write(str(field690)) self.newline() - field699 = unwrapped_fields694[4] - self.write(str(field699)) + field691 = unwrapped_fields686[4] + self.write(str(field691)) self.newline() - field700 = unwrapped_fields694[5] - self.write(str(field700)) - field701 = unwrapped_fields694[6] - if field701 is not None: + field692 = unwrapped_fields686[5] + self.write(str(field692)) + field693 = unwrapped_fields686[6] + if field693 is not None: self.newline() - assert field701 is not None - opt_val702 = field701 - self.write(str(opt_val702)) + assert field693 is not None + opt_val694 = field693 + self.write(str(opt_val694)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): - def _t1330(_dollar_dollar): + def _t1314(_dollar_dollar): if _dollar_dollar: - _t1331 = () + _t1315 = () else: - _t1331 = None - return _t1331 - _t1332 = _t1330(msg) - deconstruct_result706 = _t1332 - if deconstruct_result706 is not None: - assert deconstruct_result706 is not None - unwrapped707 = deconstruct_result706 + _t1315 = None + return _t1315 + _t1316 = _t1314(msg) + deconstruct_result698 = _t1316 + if deconstruct_result698 is not None: + assert deconstruct_result698 is not None + unwrapped699 = deconstruct_result698 self.write("true") else: - def _t1333(_dollar_dollar): + def _t1317(_dollar_dollar): if not _dollar_dollar: - _t1334 = () + _t1318 = () else: - _t1334 = None - return _t1334 - _t1335 = _t1333(msg) - deconstruct_result704 = _t1335 - if deconstruct_result704 is not None: - assert deconstruct_result704 is not None - unwrapped705 = deconstruct_result704 + _t1318 = None + return _t1318 + _t1319 = _t1317(msg) + deconstruct_result696 = _t1319 + if deconstruct_result696 is not None: + assert deconstruct_result696 is not None + unwrapped697 = deconstruct_result696 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat712 = self._try_flat(msg, self.pretty_sync) - if flat712 is not None: - assert flat712 is not None - self.write(flat712) + flat704 = self._try_flat(msg, self.pretty_sync) + if flat704 is not None: + assert flat704 is not None + self.write(flat704) return None else: - def _t1336(_dollar_dollar): + def _t1320(_dollar_dollar): return _dollar_dollar.fragments - _t1337 = _t1336(msg) - fields708 = _t1337 - assert fields708 is not None - unwrapped_fields709 = fields708 + _t1321 = _t1320(msg) + fields700 = _t1321 + assert fields700 is not None + unwrapped_fields701 = fields700 self.write("(") self.write("sync") self.indent_sexp() - if not len(unwrapped_fields709) == 0: + if not len(unwrapped_fields701) == 0: self.newline() - for i711, elem710 in enumerate(unwrapped_fields709): - if (i711 > 0): + for i703, elem702 in enumerate(unwrapped_fields701): + if (i703 > 0): self.newline() - self.pretty_fragment_id(elem710) + self.pretty_fragment_id(elem702) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat715 = self._try_flat(msg, self.pretty_fragment_id) - if flat715 is not None: - assert flat715 is not None - self.write(flat715) + flat707 = self._try_flat(msg, self.pretty_fragment_id) + if flat707 is not None: + assert flat707 is not None + self.write(flat707) return None else: - def _t1338(_dollar_dollar): + def _t1322(_dollar_dollar): return self.fragment_id_to_string(_dollar_dollar) - _t1339 = _t1338(msg) - fields713 = _t1339 - assert fields713 is not None - unwrapped_fields714 = fields713 + _t1323 = _t1322(msg) + fields705 = _t1323 + assert fields705 is not None + unwrapped_fields706 = fields705 self.write(":") - self.write(unwrapped_fields714) + self.write(unwrapped_fields706) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat722 = self._try_flat(msg, self.pretty_epoch) - if flat722 is not None: - assert flat722 is not None - self.write(flat722) + flat714 = self._try_flat(msg, self.pretty_epoch) + if flat714 is not None: + assert flat714 is not None + self.write(flat714) return None else: - def _t1340(_dollar_dollar): + def _t1324(_dollar_dollar): if not len(_dollar_dollar.writes) == 0: - _t1341 = _dollar_dollar.writes + _t1325 = _dollar_dollar.writes else: - _t1341 = None + _t1325 = None if not len(_dollar_dollar.reads) == 0: - _t1342 = _dollar_dollar.reads + _t1326 = _dollar_dollar.reads else: - _t1342 = None - return (_t1341, _t1342,) - _t1343 = _t1340(msg) - fields716 = _t1343 - assert fields716 is not None - unwrapped_fields717 = fields716 + _t1326 = None + return (_t1325, _t1326,) + _t1327 = _t1324(msg) + fields708 = _t1327 + assert fields708 is not None + unwrapped_fields709 = fields708 self.write("(") self.write("epoch") self.indent_sexp() - field718 = unwrapped_fields717[0] - if field718 is not None: + field710 = unwrapped_fields709[0] + if field710 is not None: self.newline() - assert field718 is not None - opt_val719 = field718 - self.pretty_epoch_writes(opt_val719) - field720 = unwrapped_fields717[1] - if field720 is not None: + assert field710 is not None + opt_val711 = field710 + self.pretty_epoch_writes(opt_val711) + field712 = unwrapped_fields709[1] + if field712 is not None: self.newline() - assert field720 is not None - opt_val721 = field720 - self.pretty_epoch_reads(opt_val721) + assert field712 is not None + opt_val713 = field712 + self.pretty_epoch_reads(opt_val713) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat726 = self._try_flat(msg, self.pretty_epoch_writes) - if flat726 is not None: - assert flat726 is not None - self.write(flat726) + flat718 = self._try_flat(msg, self.pretty_epoch_writes) + if flat718 is not None: + assert flat718 is not None + self.write(flat718) return None else: - fields723 = msg + fields715 = msg self.write("(") self.write("writes") self.indent_sexp() - if not len(fields723) == 0: + if not len(fields715) == 0: self.newline() - for i725, elem724 in enumerate(fields723): - if (i725 > 0): + for i717, elem716 in enumerate(fields715): + if (i717 > 0): self.newline() - self.pretty_write(elem724) + self.pretty_write(elem716) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat735 = self._try_flat(msg, self.pretty_write) - if flat735 is not None: - assert flat735 is not None - self.write(flat735) + flat727 = self._try_flat(msg, self.pretty_write) + if flat727 is not None: + assert flat727 is not None + self.write(flat727) return None else: - def _t1344(_dollar_dollar): + def _t1328(_dollar_dollar): if _dollar_dollar.HasField("define"): - _t1345 = _dollar_dollar.define + _t1329 = _dollar_dollar.define else: - _t1345 = None - return _t1345 - _t1346 = _t1344(msg) - deconstruct_result733 = _t1346 - if deconstruct_result733 is not None: - assert deconstruct_result733 is not None - unwrapped734 = deconstruct_result733 - self.pretty_define(unwrapped734) + _t1329 = None + return _t1329 + _t1330 = _t1328(msg) + deconstruct_result725 = _t1330 + if deconstruct_result725 is not None: + assert deconstruct_result725 is not None + unwrapped726 = deconstruct_result725 + self.pretty_define(unwrapped726) else: - def _t1347(_dollar_dollar): + def _t1331(_dollar_dollar): if _dollar_dollar.HasField("undefine"): - _t1348 = _dollar_dollar.undefine + _t1332 = _dollar_dollar.undefine else: - _t1348 = None - return _t1348 - _t1349 = _t1347(msg) - deconstruct_result731 = _t1349 - if deconstruct_result731 is not None: - assert deconstruct_result731 is not None - unwrapped732 = deconstruct_result731 - self.pretty_undefine(unwrapped732) + _t1332 = None + return _t1332 + _t1333 = _t1331(msg) + deconstruct_result723 = _t1333 + if deconstruct_result723 is not None: + assert deconstruct_result723 is not None + unwrapped724 = deconstruct_result723 + self.pretty_undefine(unwrapped724) else: - def _t1350(_dollar_dollar): + def _t1334(_dollar_dollar): if _dollar_dollar.HasField("context"): - _t1351 = _dollar_dollar.context + _t1335 = _dollar_dollar.context else: - _t1351 = None - return _t1351 - _t1352 = _t1350(msg) - deconstruct_result729 = _t1352 - if deconstruct_result729 is not None: - assert deconstruct_result729 is not None - unwrapped730 = deconstruct_result729 - self.pretty_context(unwrapped730) + _t1335 = None + return _t1335 + _t1336 = _t1334(msg) + deconstruct_result721 = _t1336 + if deconstruct_result721 is not None: + assert deconstruct_result721 is not None + unwrapped722 = deconstruct_result721 + self.pretty_context(unwrapped722) else: - def _t1353(_dollar_dollar): + def _t1337(_dollar_dollar): if _dollar_dollar.HasField("snapshot"): - _t1354 = _dollar_dollar.snapshot + _t1338 = _dollar_dollar.snapshot else: - _t1354 = None - return _t1354 - _t1355 = _t1353(msg) - deconstruct_result727 = _t1355 - if deconstruct_result727 is not None: - assert deconstruct_result727 is not None - unwrapped728 = deconstruct_result727 - self.pretty_snapshot(unwrapped728) + _t1338 = None + return _t1338 + _t1339 = _t1337(msg) + deconstruct_result719 = _t1339 + if deconstruct_result719 is not None: + assert deconstruct_result719 is not None + unwrapped720 = deconstruct_result719 + self.pretty_snapshot(unwrapped720) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat738 = self._try_flat(msg, self.pretty_define) - if flat738 is not None: - assert flat738 is not None - self.write(flat738) + flat730 = self._try_flat(msg, self.pretty_define) + if flat730 is not None: + assert flat730 is not None + self.write(flat730) return None else: - def _t1356(_dollar_dollar): + def _t1340(_dollar_dollar): return _dollar_dollar.fragment - _t1357 = _t1356(msg) - fields736 = _t1357 - assert fields736 is not None - unwrapped_fields737 = fields736 + _t1341 = _t1340(msg) + fields728 = _t1341 + assert fields728 is not None + unwrapped_fields729 = fields728 self.write("(") self.write("define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields737) + self.pretty_fragment(unwrapped_fields729) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat745 = self._try_flat(msg, self.pretty_fragment) - if flat745 is not None: - assert flat745 is not None - self.write(flat745) + flat737 = self._try_flat(msg, self.pretty_fragment) + if flat737 is not None: + assert flat737 is not None + self.write(flat737) return None else: - def _t1358(_dollar_dollar): + def _t1342(_dollar_dollar): self.start_pretty_fragment(_dollar_dollar) return (_dollar_dollar.id, _dollar_dollar.declarations,) - _t1359 = _t1358(msg) - fields739 = _t1359 - assert fields739 is not None - unwrapped_fields740 = fields739 + _t1343 = _t1342(msg) + fields731 = _t1343 + assert fields731 is not None + unwrapped_fields732 = fields731 self.write("(") self.write("fragment") self.indent_sexp() self.newline() - field741 = unwrapped_fields740[0] - self.pretty_new_fragment_id(field741) - field742 = unwrapped_fields740[1] - if not len(field742) == 0: + field733 = unwrapped_fields732[0] + self.pretty_new_fragment_id(field733) + field734 = unwrapped_fields732[1] + if not len(field734) == 0: self.newline() - for i744, elem743 in enumerate(field742): - if (i744 > 0): + for i736, elem735 in enumerate(field734): + if (i736 > 0): self.newline() - self.pretty_declaration(elem743) + self.pretty_declaration(elem735) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat747 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat747 is not None: - assert flat747 is not None - self.write(flat747) + flat739 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat739 is not None: + assert flat739 is not None + self.write(flat739) return None else: - fields746 = msg - self.pretty_fragment_id(fields746) + fields738 = msg + self.pretty_fragment_id(fields738) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat756 = self._try_flat(msg, self.pretty_declaration) - if flat756 is not None: - assert flat756 is not None - self.write(flat756) + flat748 = self._try_flat(msg, self.pretty_declaration) + if flat748 is not None: + assert flat748 is not None + self.write(flat748) return None else: - def _t1360(_dollar_dollar): + def _t1344(_dollar_dollar): if _dollar_dollar.HasField("def"): - _t1361 = getattr(_dollar_dollar, 'def') + _t1345 = getattr(_dollar_dollar, 'def') else: - _t1361 = None - return _t1361 - _t1362 = _t1360(msg) - deconstruct_result754 = _t1362 - if deconstruct_result754 is not None: - assert deconstruct_result754 is not None - unwrapped755 = deconstruct_result754 - self.pretty_def(unwrapped755) + _t1345 = None + return _t1345 + _t1346 = _t1344(msg) + deconstruct_result746 = _t1346 + if deconstruct_result746 is not None: + assert deconstruct_result746 is not None + unwrapped747 = deconstruct_result746 + self.pretty_def(unwrapped747) else: - def _t1363(_dollar_dollar): + def _t1347(_dollar_dollar): if _dollar_dollar.HasField("algorithm"): - _t1364 = _dollar_dollar.algorithm + _t1348 = _dollar_dollar.algorithm else: - _t1364 = None - return _t1364 - _t1365 = _t1363(msg) - deconstruct_result752 = _t1365 - if deconstruct_result752 is not None: - assert deconstruct_result752 is not None - unwrapped753 = deconstruct_result752 - self.pretty_algorithm(unwrapped753) + _t1348 = None + return _t1348 + _t1349 = _t1347(msg) + deconstruct_result744 = _t1349 + if deconstruct_result744 is not None: + assert deconstruct_result744 is not None + unwrapped745 = deconstruct_result744 + self.pretty_algorithm(unwrapped745) else: - def _t1366(_dollar_dollar): + def _t1350(_dollar_dollar): if _dollar_dollar.HasField("constraint"): - _t1367 = _dollar_dollar.constraint + _t1351 = _dollar_dollar.constraint else: - _t1367 = None - return _t1367 - _t1368 = _t1366(msg) - deconstruct_result750 = _t1368 - if deconstruct_result750 is not None: - assert deconstruct_result750 is not None - unwrapped751 = deconstruct_result750 - self.pretty_constraint(unwrapped751) + _t1351 = None + return _t1351 + _t1352 = _t1350(msg) + deconstruct_result742 = _t1352 + if deconstruct_result742 is not None: + assert deconstruct_result742 is not None + unwrapped743 = deconstruct_result742 + self.pretty_constraint(unwrapped743) else: - def _t1369(_dollar_dollar): + def _t1353(_dollar_dollar): if _dollar_dollar.HasField("data"): - _t1370 = _dollar_dollar.data + _t1354 = _dollar_dollar.data else: - _t1370 = None - return _t1370 - _t1371 = _t1369(msg) - deconstruct_result748 = _t1371 - if deconstruct_result748 is not None: - assert deconstruct_result748 is not None - unwrapped749 = deconstruct_result748 - self.pretty_data(unwrapped749) + _t1354 = None + return _t1354 + _t1355 = _t1353(msg) + deconstruct_result740 = _t1355 + if deconstruct_result740 is not None: + assert deconstruct_result740 is not None + unwrapped741 = deconstruct_result740 + self.pretty_data(unwrapped741) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat763 = self._try_flat(msg, self.pretty_def) - if flat763 is not None: - assert flat763 is not None - self.write(flat763) + flat755 = self._try_flat(msg, self.pretty_def) + if flat755 is not None: + assert flat755 is not None + self.write(flat755) return None else: - def _t1372(_dollar_dollar): + def _t1356(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1373 = _dollar_dollar.attrs + _t1357 = _dollar_dollar.attrs else: - _t1373 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1373,) - _t1374 = _t1372(msg) - fields757 = _t1374 - assert fields757 is not None - unwrapped_fields758 = fields757 + _t1357 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1357,) + _t1358 = _t1356(msg) + fields749 = _t1358 + assert fields749 is not None + unwrapped_fields750 = fields749 self.write("(") self.write("def") self.indent_sexp() self.newline() - field759 = unwrapped_fields758[0] - self.pretty_relation_id(field759) + field751 = unwrapped_fields750[0] + self.pretty_relation_id(field751) self.newline() - field760 = unwrapped_fields758[1] - self.pretty_abstraction(field760) - field761 = unwrapped_fields758[2] - if field761 is not None: + field752 = unwrapped_fields750[1] + self.pretty_abstraction(field752) + field753 = unwrapped_fields750[2] + if field753 is not None: self.newline() - assert field761 is not None - opt_val762 = field761 - self.pretty_attrs(opt_val762) + assert field753 is not None + opt_val754 = field753 + self.pretty_attrs(opt_val754) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat768 = self._try_flat(msg, self.pretty_relation_id) - if flat768 is not None: - assert flat768 is not None - self.write(flat768) + flat760 = self._try_flat(msg, self.pretty_relation_id) + if flat760 is not None: + assert flat760 is not None + self.write(flat760) return None else: - def _t1375(_dollar_dollar): + def _t1359(_dollar_dollar): if self.relation_id_to_string(_dollar_dollar) is not None: - _t1377 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1376 = _t1377 + _t1361 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1360 = _t1361 else: - _t1376 = None - return _t1376 - _t1378 = _t1375(msg) - deconstruct_result766 = _t1378 - if deconstruct_result766 is not None: - assert deconstruct_result766 is not None - unwrapped767 = deconstruct_result766 + _t1360 = None + return _t1360 + _t1362 = _t1359(msg) + deconstruct_result758 = _t1362 + if deconstruct_result758 is not None: + assert deconstruct_result758 is not None + unwrapped759 = deconstruct_result758 self.write(":") - self.write(unwrapped767) + self.write(unwrapped759) else: - def _t1379(_dollar_dollar): - _t1380 = self.deconstruct_relation_id_uint128(_dollar_dollar) - return _t1380 - _t1381 = _t1379(msg) - deconstruct_result764 = _t1381 - if deconstruct_result764 is not None: - assert deconstruct_result764 is not None - unwrapped765 = deconstruct_result764 - self.write(self.format_uint128(unwrapped765)) + def _t1363(_dollar_dollar): + _t1364 = self.deconstruct_relation_id_uint128(_dollar_dollar) + return _t1364 + _t1365 = _t1363(msg) + deconstruct_result756 = _t1365 + if deconstruct_result756 is not None: + assert deconstruct_result756 is not None + unwrapped757 = deconstruct_result756 + self.write(self.format_uint128(unwrapped757)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat773 = self._try_flat(msg, self.pretty_abstraction) - if flat773 is not None: - assert flat773 is not None - self.write(flat773) + flat765 = self._try_flat(msg, self.pretty_abstraction) + if flat765 is not None: + assert flat765 is not None + self.write(flat765) return None else: - def _t1382(_dollar_dollar): - _t1383 = self.deconstruct_bindings(_dollar_dollar) - return (_t1383, _dollar_dollar.value,) - _t1384 = _t1382(msg) - fields769 = _t1384 - assert fields769 is not None - unwrapped_fields770 = fields769 + def _t1366(_dollar_dollar): + _t1367 = self.deconstruct_bindings(_dollar_dollar) + return (_t1367, _dollar_dollar.value,) + _t1368 = _t1366(msg) + fields761 = _t1368 + assert fields761 is not None + unwrapped_fields762 = fields761 self.write("(") self.indent() - field771 = unwrapped_fields770[0] - self.pretty_bindings(field771) + field763 = unwrapped_fields762[0] + self.pretty_bindings(field763) self.newline() - field772 = unwrapped_fields770[1] - self.pretty_formula(field772) + field764 = unwrapped_fields762[1] + self.pretty_formula(field764) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat781 = self._try_flat(msg, self.pretty_bindings) - if flat781 is not None: - assert flat781 is not None - self.write(flat781) + flat773 = self._try_flat(msg, self.pretty_bindings) + if flat773 is not None: + assert flat773 is not None + self.write(flat773) return None else: - def _t1385(_dollar_dollar): + def _t1369(_dollar_dollar): if not len(_dollar_dollar[1]) == 0: - _t1386 = _dollar_dollar[1] + _t1370 = _dollar_dollar[1] else: - _t1386 = None - return (_dollar_dollar[0], _t1386,) - _t1387 = _t1385(msg) - fields774 = _t1387 - assert fields774 is not None - unwrapped_fields775 = fields774 + _t1370 = None + return (_dollar_dollar[0], _t1370,) + _t1371 = _t1369(msg) + fields766 = _t1371 + assert fields766 is not None + unwrapped_fields767 = fields766 self.write("[") self.indent() - field776 = unwrapped_fields775[0] - for i778, elem777 in enumerate(field776): - if (i778 > 0): + field768 = unwrapped_fields767[0] + for i770, elem769 in enumerate(field768): + if (i770 > 0): self.newline() - self.pretty_binding(elem777) - field779 = unwrapped_fields775[1] - if field779 is not None: + self.pretty_binding(elem769) + field771 = unwrapped_fields767[1] + if field771 is not None: self.newline() - assert field779 is not None - opt_val780 = field779 - self.pretty_value_bindings(opt_val780) + assert field771 is not None + opt_val772 = field771 + self.pretty_value_bindings(opt_val772) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat786 = self._try_flat(msg, self.pretty_binding) - if flat786 is not None: - assert flat786 is not None - self.write(flat786) + flat778 = self._try_flat(msg, self.pretty_binding) + if flat778 is not None: + assert flat778 is not None + self.write(flat778) return None else: - def _t1388(_dollar_dollar): + def _t1372(_dollar_dollar): return (_dollar_dollar.var.name, _dollar_dollar.type,) - _t1389 = _t1388(msg) - fields782 = _t1389 - assert fields782 is not None - unwrapped_fields783 = fields782 - field784 = unwrapped_fields783[0] - self.write(field784) + _t1373 = _t1372(msg) + fields774 = _t1373 + assert fields774 is not None + unwrapped_fields775 = fields774 + field776 = unwrapped_fields775[0] + self.write(field776) self.write("::") - field785 = unwrapped_fields783[1] - self.pretty_type(field785) + field777 = unwrapped_fields775[1] + self.pretty_type(field777) def pretty_type(self, msg: logic_pb2.Type): - flat809 = self._try_flat(msg, self.pretty_type) - if flat809 is not None: - assert flat809 is not None - self.write(flat809) + flat801 = self._try_flat(msg, self.pretty_type) + if flat801 is not None: + assert flat801 is not None + self.write(flat801) return None else: - def _t1390(_dollar_dollar): + def _t1374(_dollar_dollar): if _dollar_dollar.HasField("unspecified_type"): - _t1391 = _dollar_dollar.unspecified_type + _t1375 = _dollar_dollar.unspecified_type else: - _t1391 = None - return _t1391 - _t1392 = _t1390(msg) - deconstruct_result807 = _t1392 - if deconstruct_result807 is not None: - assert deconstruct_result807 is not None - unwrapped808 = deconstruct_result807 - self.pretty_unspecified_type(unwrapped808) + _t1375 = None + return _t1375 + _t1376 = _t1374(msg) + deconstruct_result799 = _t1376 + if deconstruct_result799 is not None: + assert deconstruct_result799 is not None + unwrapped800 = deconstruct_result799 + self.pretty_unspecified_type(unwrapped800) else: - def _t1393(_dollar_dollar): + def _t1377(_dollar_dollar): if _dollar_dollar.HasField("string_type"): - _t1394 = _dollar_dollar.string_type + _t1378 = _dollar_dollar.string_type else: - _t1394 = None - return _t1394 - _t1395 = _t1393(msg) - deconstruct_result805 = _t1395 - if deconstruct_result805 is not None: - assert deconstruct_result805 is not None - unwrapped806 = deconstruct_result805 - self.pretty_string_type(unwrapped806) + _t1378 = None + return _t1378 + _t1379 = _t1377(msg) + deconstruct_result797 = _t1379 + if deconstruct_result797 is not None: + assert deconstruct_result797 is not None + unwrapped798 = deconstruct_result797 + self.pretty_string_type(unwrapped798) else: - def _t1396(_dollar_dollar): + def _t1380(_dollar_dollar): if _dollar_dollar.HasField("int_type"): - _t1397 = _dollar_dollar.int_type + _t1381 = _dollar_dollar.int_type else: - _t1397 = None - return _t1397 - _t1398 = _t1396(msg) - deconstruct_result803 = _t1398 - if deconstruct_result803 is not None: - assert deconstruct_result803 is not None - unwrapped804 = deconstruct_result803 - self.pretty_int_type(unwrapped804) + _t1381 = None + return _t1381 + _t1382 = _t1380(msg) + deconstruct_result795 = _t1382 + if deconstruct_result795 is not None: + assert deconstruct_result795 is not None + unwrapped796 = deconstruct_result795 + self.pretty_int_type(unwrapped796) else: - def _t1399(_dollar_dollar): + def _t1383(_dollar_dollar): if _dollar_dollar.HasField("float_type"): - _t1400 = _dollar_dollar.float_type + _t1384 = _dollar_dollar.float_type else: - _t1400 = None - return _t1400 - _t1401 = _t1399(msg) - deconstruct_result801 = _t1401 - if deconstruct_result801 is not None: - assert deconstruct_result801 is not None - unwrapped802 = deconstruct_result801 - self.pretty_float_type(unwrapped802) + _t1384 = None + return _t1384 + _t1385 = _t1383(msg) + deconstruct_result793 = _t1385 + if deconstruct_result793 is not None: + assert deconstruct_result793 is not None + unwrapped794 = deconstruct_result793 + self.pretty_float_type(unwrapped794) else: - def _t1402(_dollar_dollar): + def _t1386(_dollar_dollar): if _dollar_dollar.HasField("uint128_type"): - _t1403 = _dollar_dollar.uint128_type + _t1387 = _dollar_dollar.uint128_type else: - _t1403 = None - return _t1403 - _t1404 = _t1402(msg) - deconstruct_result799 = _t1404 - if deconstruct_result799 is not None: - assert deconstruct_result799 is not None - unwrapped800 = deconstruct_result799 - self.pretty_uint128_type(unwrapped800) + _t1387 = None + return _t1387 + _t1388 = _t1386(msg) + deconstruct_result791 = _t1388 + if deconstruct_result791 is not None: + assert deconstruct_result791 is not None + unwrapped792 = deconstruct_result791 + self.pretty_uint128_type(unwrapped792) else: - def _t1405(_dollar_dollar): + def _t1389(_dollar_dollar): if _dollar_dollar.HasField("int128_type"): - _t1406 = _dollar_dollar.int128_type + _t1390 = _dollar_dollar.int128_type else: - _t1406 = None - return _t1406 - _t1407 = _t1405(msg) - deconstruct_result797 = _t1407 - if deconstruct_result797 is not None: - assert deconstruct_result797 is not None - unwrapped798 = deconstruct_result797 - self.pretty_int128_type(unwrapped798) + _t1390 = None + return _t1390 + _t1391 = _t1389(msg) + deconstruct_result789 = _t1391 + if deconstruct_result789 is not None: + assert deconstruct_result789 is not None + unwrapped790 = deconstruct_result789 + self.pretty_int128_type(unwrapped790) else: - def _t1408(_dollar_dollar): + def _t1392(_dollar_dollar): if _dollar_dollar.HasField("date_type"): - _t1409 = _dollar_dollar.date_type + _t1393 = _dollar_dollar.date_type else: - _t1409 = None - return _t1409 - _t1410 = _t1408(msg) - deconstruct_result795 = _t1410 - if deconstruct_result795 is not None: - assert deconstruct_result795 is not None - unwrapped796 = deconstruct_result795 - self.pretty_date_type(unwrapped796) + _t1393 = None + return _t1393 + _t1394 = _t1392(msg) + deconstruct_result787 = _t1394 + if deconstruct_result787 is not None: + assert deconstruct_result787 is not None + unwrapped788 = deconstruct_result787 + self.pretty_date_type(unwrapped788) else: - def _t1411(_dollar_dollar): + def _t1395(_dollar_dollar): if _dollar_dollar.HasField("datetime_type"): - _t1412 = _dollar_dollar.datetime_type + _t1396 = _dollar_dollar.datetime_type else: - _t1412 = None - return _t1412 - _t1413 = _t1411(msg) - deconstruct_result793 = _t1413 - if deconstruct_result793 is not None: - assert deconstruct_result793 is not None - unwrapped794 = deconstruct_result793 - self.pretty_datetime_type(unwrapped794) + _t1396 = None + return _t1396 + _t1397 = _t1395(msg) + deconstruct_result785 = _t1397 + if deconstruct_result785 is not None: + assert deconstruct_result785 is not None + unwrapped786 = deconstruct_result785 + self.pretty_datetime_type(unwrapped786) else: - def _t1414(_dollar_dollar): + def _t1398(_dollar_dollar): if _dollar_dollar.HasField("missing_type"): - _t1415 = _dollar_dollar.missing_type + _t1399 = _dollar_dollar.missing_type else: - _t1415 = None - return _t1415 - _t1416 = _t1414(msg) - deconstruct_result791 = _t1416 - if deconstruct_result791 is not None: - assert deconstruct_result791 is not None - unwrapped792 = deconstruct_result791 - self.pretty_missing_type(unwrapped792) + _t1399 = None + return _t1399 + _t1400 = _t1398(msg) + deconstruct_result783 = _t1400 + if deconstruct_result783 is not None: + assert deconstruct_result783 is not None + unwrapped784 = deconstruct_result783 + self.pretty_missing_type(unwrapped784) else: - def _t1417(_dollar_dollar): + def _t1401(_dollar_dollar): if _dollar_dollar.HasField("decimal_type"): - _t1418 = _dollar_dollar.decimal_type + _t1402 = _dollar_dollar.decimal_type else: - _t1418 = None - return _t1418 - _t1419 = _t1417(msg) - deconstruct_result789 = _t1419 - if deconstruct_result789 is not None: - assert deconstruct_result789 is not None - unwrapped790 = deconstruct_result789 - self.pretty_decimal_type(unwrapped790) + _t1402 = None + return _t1402 + _t1403 = _t1401(msg) + deconstruct_result781 = _t1403 + if deconstruct_result781 is not None: + assert deconstruct_result781 is not None + unwrapped782 = deconstruct_result781 + self.pretty_decimal_type(unwrapped782) else: - def _t1420(_dollar_dollar): + def _t1404(_dollar_dollar): if _dollar_dollar.HasField("boolean_type"): - _t1421 = _dollar_dollar.boolean_type + _t1405 = _dollar_dollar.boolean_type else: - _t1421 = None - return _t1421 - _t1422 = _t1420(msg) - deconstruct_result787 = _t1422 - if deconstruct_result787 is not None: - assert deconstruct_result787 is not None - unwrapped788 = deconstruct_result787 - self.pretty_boolean_type(unwrapped788) + _t1405 = None + return _t1405 + _t1406 = _t1404(msg) + deconstruct_result779 = _t1406 + if deconstruct_result779 is not None: + assert deconstruct_result779 is not None + unwrapped780 = deconstruct_result779 + self.pretty_boolean_type(unwrapped780) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields810 = msg + fields802 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields811 = msg + fields803 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields812 = msg + fields804 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields813 = msg + fields805 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields814 = msg + fields806 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields815 = msg + fields807 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields816 = msg + fields808 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields817 = msg + fields809 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields818 = msg + fields810 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat823 = self._try_flat(msg, self.pretty_decimal_type) - if flat823 is not None: - assert flat823 is not None - self.write(flat823) + flat815 = self._try_flat(msg, self.pretty_decimal_type) + if flat815 is not None: + assert flat815 is not None + self.write(flat815) return None else: - def _t1423(_dollar_dollar): + def _t1407(_dollar_dollar): return (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - _t1424 = _t1423(msg) - fields819 = _t1424 - assert fields819 is not None - unwrapped_fields820 = fields819 + _t1408 = _t1407(msg) + fields811 = _t1408 + assert fields811 is not None + unwrapped_fields812 = fields811 self.write("(") self.write("DECIMAL") self.indent_sexp() self.newline() - field821 = unwrapped_fields820[0] - self.write(str(field821)) + field813 = unwrapped_fields812[0] + self.write(str(field813)) self.newline() - field822 = unwrapped_fields820[1] - self.write(str(field822)) + field814 = unwrapped_fields812[1] + self.write(str(field814)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields824 = msg + fields816 = msg self.write("BOOLEAN") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat828 = self._try_flat(msg, self.pretty_value_bindings) - if flat828 is not None: - assert flat828 is not None - self.write(flat828) + flat820 = self._try_flat(msg, self.pretty_value_bindings) + if flat820 is not None: + assert flat820 is not None + self.write(flat820) return None else: - fields825 = msg + fields817 = msg self.write("|") - if not len(fields825) == 0: + if not len(fields817) == 0: self.write(" ") - for i827, elem826 in enumerate(fields825): - if (i827 > 0): + for i819, elem818 in enumerate(fields817): + if (i819 > 0): self.newline() - self.pretty_binding(elem826) + self.pretty_binding(elem818) def pretty_formula(self, msg: logic_pb2.Formula): - flat855 = self._try_flat(msg, self.pretty_formula) - if flat855 is not None: - assert flat855 is not None - self.write(flat855) + flat847 = self._try_flat(msg, self.pretty_formula) + if flat847 is not None: + assert flat847 is not None + self.write(flat847) return None else: - def _t1425(_dollar_dollar): + def _t1409(_dollar_dollar): if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1426 = _dollar_dollar.conjunction + _t1410 = _dollar_dollar.conjunction else: - _t1426 = None - return _t1426 - _t1427 = _t1425(msg) - deconstruct_result853 = _t1427 - if deconstruct_result853 is not None: - assert deconstruct_result853 is not None - unwrapped854 = deconstruct_result853 - self.pretty_true(unwrapped854) + _t1410 = None + return _t1410 + _t1411 = _t1409(msg) + deconstruct_result845 = _t1411 + if deconstruct_result845 is not None: + assert deconstruct_result845 is not None + unwrapped846 = deconstruct_result845 + self.pretty_true(unwrapped846) else: - def _t1428(_dollar_dollar): + def _t1412(_dollar_dollar): if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1429 = _dollar_dollar.disjunction + _t1413 = _dollar_dollar.disjunction else: - _t1429 = None - return _t1429 - _t1430 = _t1428(msg) - deconstruct_result851 = _t1430 - if deconstruct_result851 is not None: - assert deconstruct_result851 is not None - unwrapped852 = deconstruct_result851 - self.pretty_false(unwrapped852) + _t1413 = None + return _t1413 + _t1414 = _t1412(msg) + deconstruct_result843 = _t1414 + if deconstruct_result843 is not None: + assert deconstruct_result843 is not None + unwrapped844 = deconstruct_result843 + self.pretty_false(unwrapped844) else: - def _t1431(_dollar_dollar): + def _t1415(_dollar_dollar): if _dollar_dollar.HasField("exists"): - _t1432 = _dollar_dollar.exists + _t1416 = _dollar_dollar.exists else: - _t1432 = None - return _t1432 - _t1433 = _t1431(msg) - deconstruct_result849 = _t1433 - if deconstruct_result849 is not None: - assert deconstruct_result849 is not None - unwrapped850 = deconstruct_result849 - self.pretty_exists(unwrapped850) + _t1416 = None + return _t1416 + _t1417 = _t1415(msg) + deconstruct_result841 = _t1417 + if deconstruct_result841 is not None: + assert deconstruct_result841 is not None + unwrapped842 = deconstruct_result841 + self.pretty_exists(unwrapped842) else: - def _t1434(_dollar_dollar): + def _t1418(_dollar_dollar): if _dollar_dollar.HasField("reduce"): - _t1435 = _dollar_dollar.reduce + _t1419 = _dollar_dollar.reduce else: - _t1435 = None - return _t1435 - _t1436 = _t1434(msg) - deconstruct_result847 = _t1436 - if deconstruct_result847 is not None: - assert deconstruct_result847 is not None - unwrapped848 = deconstruct_result847 - self.pretty_reduce(unwrapped848) + _t1419 = None + return _t1419 + _t1420 = _t1418(msg) + deconstruct_result839 = _t1420 + if deconstruct_result839 is not None: + assert deconstruct_result839 is not None + unwrapped840 = deconstruct_result839 + self.pretty_reduce(unwrapped840) else: - def _t1437(_dollar_dollar): + def _t1421(_dollar_dollar): if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1438 = _dollar_dollar.conjunction + _t1422 = _dollar_dollar.conjunction else: - _t1438 = None - return _t1438 - _t1439 = _t1437(msg) - deconstruct_result845 = _t1439 - if deconstruct_result845 is not None: - assert deconstruct_result845 is not None - unwrapped846 = deconstruct_result845 - self.pretty_conjunction(unwrapped846) + _t1422 = None + return _t1422 + _t1423 = _t1421(msg) + deconstruct_result837 = _t1423 + if deconstruct_result837 is not None: + assert deconstruct_result837 is not None + unwrapped838 = deconstruct_result837 + self.pretty_conjunction(unwrapped838) else: - def _t1440(_dollar_dollar): + def _t1424(_dollar_dollar): if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1441 = _dollar_dollar.disjunction + _t1425 = _dollar_dollar.disjunction else: - _t1441 = None - return _t1441 - _t1442 = _t1440(msg) - deconstruct_result843 = _t1442 - if deconstruct_result843 is not None: - assert deconstruct_result843 is not None - unwrapped844 = deconstruct_result843 - self.pretty_disjunction(unwrapped844) + _t1425 = None + return _t1425 + _t1426 = _t1424(msg) + deconstruct_result835 = _t1426 + if deconstruct_result835 is not None: + assert deconstruct_result835 is not None + unwrapped836 = deconstruct_result835 + self.pretty_disjunction(unwrapped836) else: - def _t1443(_dollar_dollar): + def _t1427(_dollar_dollar): if _dollar_dollar.HasField("not"): - _t1444 = getattr(_dollar_dollar, 'not') + _t1428 = getattr(_dollar_dollar, 'not') else: - _t1444 = None - return _t1444 - _t1445 = _t1443(msg) - deconstruct_result841 = _t1445 - if deconstruct_result841 is not None: - assert deconstruct_result841 is not None - unwrapped842 = deconstruct_result841 - self.pretty_not(unwrapped842) + _t1428 = None + return _t1428 + _t1429 = _t1427(msg) + deconstruct_result833 = _t1429 + if deconstruct_result833 is not None: + assert deconstruct_result833 is not None + unwrapped834 = deconstruct_result833 + self.pretty_not(unwrapped834) else: - def _t1446(_dollar_dollar): + def _t1430(_dollar_dollar): if _dollar_dollar.HasField("ffi"): - _t1447 = _dollar_dollar.ffi + _t1431 = _dollar_dollar.ffi else: - _t1447 = None - return _t1447 - _t1448 = _t1446(msg) - deconstruct_result839 = _t1448 - if deconstruct_result839 is not None: - assert deconstruct_result839 is not None - unwrapped840 = deconstruct_result839 - self.pretty_ffi(unwrapped840) + _t1431 = None + return _t1431 + _t1432 = _t1430(msg) + deconstruct_result831 = _t1432 + if deconstruct_result831 is not None: + assert deconstruct_result831 is not None + unwrapped832 = deconstruct_result831 + self.pretty_ffi(unwrapped832) else: - def _t1449(_dollar_dollar): + def _t1433(_dollar_dollar): if _dollar_dollar.HasField("atom"): - _t1450 = _dollar_dollar.atom + _t1434 = _dollar_dollar.atom else: - _t1450 = None - return _t1450 - _t1451 = _t1449(msg) - deconstruct_result837 = _t1451 - if deconstruct_result837 is not None: - assert deconstruct_result837 is not None - unwrapped838 = deconstruct_result837 - self.pretty_atom(unwrapped838) + _t1434 = None + return _t1434 + _t1435 = _t1433(msg) + deconstruct_result829 = _t1435 + if deconstruct_result829 is not None: + assert deconstruct_result829 is not None + unwrapped830 = deconstruct_result829 + self.pretty_atom(unwrapped830) else: - def _t1452(_dollar_dollar): + def _t1436(_dollar_dollar): if _dollar_dollar.HasField("pragma"): - _t1453 = _dollar_dollar.pragma + _t1437 = _dollar_dollar.pragma else: - _t1453 = None - return _t1453 - _t1454 = _t1452(msg) - deconstruct_result835 = _t1454 - if deconstruct_result835 is not None: - assert deconstruct_result835 is not None - unwrapped836 = deconstruct_result835 - self.pretty_pragma(unwrapped836) + _t1437 = None + return _t1437 + _t1438 = _t1436(msg) + deconstruct_result827 = _t1438 + if deconstruct_result827 is not None: + assert deconstruct_result827 is not None + unwrapped828 = deconstruct_result827 + self.pretty_pragma(unwrapped828) else: - def _t1455(_dollar_dollar): + def _t1439(_dollar_dollar): if _dollar_dollar.HasField("primitive"): - _t1456 = _dollar_dollar.primitive + _t1440 = _dollar_dollar.primitive else: - _t1456 = None - return _t1456 - _t1457 = _t1455(msg) - deconstruct_result833 = _t1457 - if deconstruct_result833 is not None: - assert deconstruct_result833 is not None - unwrapped834 = deconstruct_result833 - self.pretty_primitive(unwrapped834) + _t1440 = None + return _t1440 + _t1441 = _t1439(msg) + deconstruct_result825 = _t1441 + if deconstruct_result825 is not None: + assert deconstruct_result825 is not None + unwrapped826 = deconstruct_result825 + self.pretty_primitive(unwrapped826) else: - def _t1458(_dollar_dollar): + def _t1442(_dollar_dollar): if _dollar_dollar.HasField("rel_atom"): - _t1459 = _dollar_dollar.rel_atom + _t1443 = _dollar_dollar.rel_atom else: - _t1459 = None - return _t1459 - _t1460 = _t1458(msg) - deconstruct_result831 = _t1460 - if deconstruct_result831 is not None: - assert deconstruct_result831 is not None - unwrapped832 = deconstruct_result831 - self.pretty_rel_atom(unwrapped832) + _t1443 = None + return _t1443 + _t1444 = _t1442(msg) + deconstruct_result823 = _t1444 + if deconstruct_result823 is not None: + assert deconstruct_result823 is not None + unwrapped824 = deconstruct_result823 + self.pretty_rel_atom(unwrapped824) else: - def _t1461(_dollar_dollar): + def _t1445(_dollar_dollar): if _dollar_dollar.HasField("cast"): - _t1462 = _dollar_dollar.cast + _t1446 = _dollar_dollar.cast else: - _t1462 = None - return _t1462 - _t1463 = _t1461(msg) - deconstruct_result829 = _t1463 - if deconstruct_result829 is not None: - assert deconstruct_result829 is not None - unwrapped830 = deconstruct_result829 - self.pretty_cast(unwrapped830) + _t1446 = None + return _t1446 + _t1447 = _t1445(msg) + deconstruct_result821 = _t1447 + if deconstruct_result821 is not None: + assert deconstruct_result821 is not None + unwrapped822 = deconstruct_result821 + self.pretty_cast(unwrapped822) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields856 = msg + fields848 = msg self.write("(") self.write("true") self.write(")") def pretty_false(self, msg: logic_pb2.Disjunction): - fields857 = msg + fields849 = msg self.write("(") self.write("false") self.write(")") def pretty_exists(self, msg: logic_pb2.Exists): - flat862 = self._try_flat(msg, self.pretty_exists) - if flat862 is not None: - assert flat862 is not None - self.write(flat862) + flat854 = self._try_flat(msg, self.pretty_exists) + if flat854 is not None: + assert flat854 is not None + self.write(flat854) return None else: - def _t1464(_dollar_dollar): - _t1465 = self.deconstruct_bindings(_dollar_dollar.body) - return (_t1465, _dollar_dollar.body.value,) - _t1466 = _t1464(msg) - fields858 = _t1466 - assert fields858 is not None - unwrapped_fields859 = fields858 + def _t1448(_dollar_dollar): + _t1449 = self.deconstruct_bindings(_dollar_dollar.body) + return (_t1449, _dollar_dollar.body.value,) + _t1450 = _t1448(msg) + fields850 = _t1450 + assert fields850 is not None + unwrapped_fields851 = fields850 self.write("(") self.write("exists") self.indent_sexp() self.newline() - field860 = unwrapped_fields859[0] - self.pretty_bindings(field860) + field852 = unwrapped_fields851[0] + self.pretty_bindings(field852) self.newline() - field861 = unwrapped_fields859[1] - self.pretty_formula(field861) + field853 = unwrapped_fields851[1] + self.pretty_formula(field853) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat868 = self._try_flat(msg, self.pretty_reduce) - if flat868 is not None: - assert flat868 is not None - self.write(flat868) + flat860 = self._try_flat(msg, self.pretty_reduce) + if flat860 is not None: + assert flat860 is not None + self.write(flat860) return None else: - def _t1467(_dollar_dollar): + def _t1451(_dollar_dollar): return (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - _t1468 = _t1467(msg) - fields863 = _t1468 - assert fields863 is not None - unwrapped_fields864 = fields863 + _t1452 = _t1451(msg) + fields855 = _t1452 + assert fields855 is not None + unwrapped_fields856 = fields855 self.write("(") self.write("reduce") self.indent_sexp() self.newline() - field865 = unwrapped_fields864[0] - self.pretty_abstraction(field865) + field857 = unwrapped_fields856[0] + self.pretty_abstraction(field857) self.newline() - field866 = unwrapped_fields864[1] - self.pretty_abstraction(field866) + field858 = unwrapped_fields856[1] + self.pretty_abstraction(field858) self.newline() - field867 = unwrapped_fields864[2] - self.pretty_terms(field867) + field859 = unwrapped_fields856[2] + self.pretty_terms(field859) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat872 = self._try_flat(msg, self.pretty_terms) - if flat872 is not None: - assert flat872 is not None - self.write(flat872) + flat864 = self._try_flat(msg, self.pretty_terms) + if flat864 is not None: + assert flat864 is not None + self.write(flat864) return None else: - fields869 = msg + fields861 = msg self.write("(") self.write("terms") self.indent_sexp() - if not len(fields869) == 0: + if not len(fields861) == 0: self.newline() - for i871, elem870 in enumerate(fields869): - if (i871 > 0): + for i863, elem862 in enumerate(fields861): + if (i863 > 0): self.newline() - self.pretty_term(elem870) + self.pretty_term(elem862) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat877 = self._try_flat(msg, self.pretty_term) - if flat877 is not None: - assert flat877 is not None - self.write(flat877) + flat869 = self._try_flat(msg, self.pretty_term) + if flat869 is not None: + assert flat869 is not None + self.write(flat869) return None else: - def _t1469(_dollar_dollar): + def _t1453(_dollar_dollar): if _dollar_dollar.HasField("var"): - _t1470 = _dollar_dollar.var + _t1454 = _dollar_dollar.var else: - _t1470 = None - return _t1470 - _t1471 = _t1469(msg) - deconstruct_result875 = _t1471 - if deconstruct_result875 is not None: - assert deconstruct_result875 is not None - unwrapped876 = deconstruct_result875 - self.pretty_var(unwrapped876) + _t1454 = None + return _t1454 + _t1455 = _t1453(msg) + deconstruct_result867 = _t1455 + if deconstruct_result867 is not None: + assert deconstruct_result867 is not None + unwrapped868 = deconstruct_result867 + self.pretty_var(unwrapped868) else: - def _t1472(_dollar_dollar): + def _t1456(_dollar_dollar): if _dollar_dollar.HasField("constant"): - _t1473 = _dollar_dollar.constant + _t1457 = _dollar_dollar.constant else: - _t1473 = None - return _t1473 - _t1474 = _t1472(msg) - deconstruct_result873 = _t1474 - if deconstruct_result873 is not None: - assert deconstruct_result873 is not None - unwrapped874 = deconstruct_result873 - self.pretty_constant(unwrapped874) + _t1457 = None + return _t1457 + _t1458 = _t1456(msg) + deconstruct_result865 = _t1458 + if deconstruct_result865 is not None: + assert deconstruct_result865 is not None + unwrapped866 = deconstruct_result865 + self.pretty_constant(unwrapped866) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat880 = self._try_flat(msg, self.pretty_var) - if flat880 is not None: - assert flat880 is not None - self.write(flat880) + flat872 = self._try_flat(msg, self.pretty_var) + if flat872 is not None: + assert flat872 is not None + self.write(flat872) return None else: - def _t1475(_dollar_dollar): + def _t1459(_dollar_dollar): return _dollar_dollar.name - _t1476 = _t1475(msg) - fields878 = _t1476 - assert fields878 is not None - unwrapped_fields879 = fields878 - self.write(unwrapped_fields879) + _t1460 = _t1459(msg) + fields870 = _t1460 + assert fields870 is not None + unwrapped_fields871 = fields870 + self.write(unwrapped_fields871) def pretty_constant(self, msg: logic_pb2.Value): - flat882 = self._try_flat(msg, self.pretty_constant) - if flat882 is not None: - assert flat882 is not None - self.write(flat882) + flat874 = self._try_flat(msg, self.pretty_constant) + if flat874 is not None: + assert flat874 is not None + self.write(flat874) return None else: - fields881 = msg - self.pretty_value(fields881) + fields873 = msg + self.pretty_value(fields873) def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat887 = self._try_flat(msg, self.pretty_conjunction) - if flat887 is not None: - assert flat887 is not None - self.write(flat887) + flat879 = self._try_flat(msg, self.pretty_conjunction) + if flat879 is not None: + assert flat879 is not None + self.write(flat879) return None else: - def _t1477(_dollar_dollar): + def _t1461(_dollar_dollar): return _dollar_dollar.args - _t1478 = _t1477(msg) - fields883 = _t1478 - assert fields883 is not None - unwrapped_fields884 = fields883 + _t1462 = _t1461(msg) + fields875 = _t1462 + assert fields875 is not None + unwrapped_fields876 = fields875 self.write("(") self.write("and") self.indent_sexp() - if not len(unwrapped_fields884) == 0: + if not len(unwrapped_fields876) == 0: self.newline() - for i886, elem885 in enumerate(unwrapped_fields884): - if (i886 > 0): + for i878, elem877 in enumerate(unwrapped_fields876): + if (i878 > 0): self.newline() - self.pretty_formula(elem885) + self.pretty_formula(elem877) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat892 = self._try_flat(msg, self.pretty_disjunction) - if flat892 is not None: - assert flat892 is not None - self.write(flat892) + flat884 = self._try_flat(msg, self.pretty_disjunction) + if flat884 is not None: + assert flat884 is not None + self.write(flat884) return None else: - def _t1479(_dollar_dollar): + def _t1463(_dollar_dollar): return _dollar_dollar.args - _t1480 = _t1479(msg) - fields888 = _t1480 - assert fields888 is not None - unwrapped_fields889 = fields888 + _t1464 = _t1463(msg) + fields880 = _t1464 + assert fields880 is not None + unwrapped_fields881 = fields880 self.write("(") self.write("or") self.indent_sexp() - if not len(unwrapped_fields889) == 0: + if not len(unwrapped_fields881) == 0: self.newline() - for i891, elem890 in enumerate(unwrapped_fields889): - if (i891 > 0): + for i883, elem882 in enumerate(unwrapped_fields881): + if (i883 > 0): self.newline() - self.pretty_formula(elem890) + self.pretty_formula(elem882) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat895 = self._try_flat(msg, self.pretty_not) - if flat895 is not None: - assert flat895 is not None - self.write(flat895) + flat887 = self._try_flat(msg, self.pretty_not) + if flat887 is not None: + assert flat887 is not None + self.write(flat887) return None else: - def _t1481(_dollar_dollar): + def _t1465(_dollar_dollar): return _dollar_dollar.arg - _t1482 = _t1481(msg) - fields893 = _t1482 - assert fields893 is not None - unwrapped_fields894 = fields893 + _t1466 = _t1465(msg) + fields885 = _t1466 + assert fields885 is not None + unwrapped_fields886 = fields885 self.write("(") self.write("not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields894) + self.pretty_formula(unwrapped_fields886) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat901 = self._try_flat(msg, self.pretty_ffi) - if flat901 is not None: - assert flat901 is not None - self.write(flat901) + flat893 = self._try_flat(msg, self.pretty_ffi) + if flat893 is not None: + assert flat893 is not None + self.write(flat893) return None else: - def _t1483(_dollar_dollar): + def _t1467(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - _t1484 = _t1483(msg) - fields896 = _t1484 - assert fields896 is not None - unwrapped_fields897 = fields896 + _t1468 = _t1467(msg) + fields888 = _t1468 + assert fields888 is not None + unwrapped_fields889 = fields888 self.write("(") self.write("ffi") self.indent_sexp() self.newline() - field898 = unwrapped_fields897[0] - self.pretty_name(field898) + field890 = unwrapped_fields889[0] + self.pretty_name(field890) self.newline() - field899 = unwrapped_fields897[1] - self.pretty_ffi_args(field899) + field891 = unwrapped_fields889[1] + self.pretty_ffi_args(field891) self.newline() - field900 = unwrapped_fields897[2] - self.pretty_terms(field900) + field892 = unwrapped_fields889[2] + self.pretty_terms(field892) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat903 = self._try_flat(msg, self.pretty_name) - if flat903 is not None: - assert flat903 is not None - self.write(flat903) + flat895 = self._try_flat(msg, self.pretty_name) + if flat895 is not None: + assert flat895 is not None + self.write(flat895) return None else: - fields902 = msg + fields894 = msg self.write(":") - self.write(fields902) + self.write(fields894) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat907 = self._try_flat(msg, self.pretty_ffi_args) - if flat907 is not None: - assert flat907 is not None - self.write(flat907) + flat899 = self._try_flat(msg, self.pretty_ffi_args) + if flat899 is not None: + assert flat899 is not None + self.write(flat899) return None else: - fields904 = msg + fields896 = msg self.write("(") self.write("args") self.indent_sexp() - if not len(fields904) == 0: + if not len(fields896) == 0: self.newline() - for i906, elem905 in enumerate(fields904): - if (i906 > 0): + for i898, elem897 in enumerate(fields896): + if (i898 > 0): self.newline() - self.pretty_abstraction(elem905) + self.pretty_abstraction(elem897) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat914 = self._try_flat(msg, self.pretty_atom) - if flat914 is not None: - assert flat914 is not None - self.write(flat914) + flat906 = self._try_flat(msg, self.pretty_atom) + if flat906 is not None: + assert flat906 is not None + self.write(flat906) return None else: - def _t1485(_dollar_dollar): + def _t1469(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1486 = _t1485(msg) - fields908 = _t1486 - assert fields908 is not None - unwrapped_fields909 = fields908 + _t1470 = _t1469(msg) + fields900 = _t1470 + assert fields900 is not None + unwrapped_fields901 = fields900 self.write("(") self.write("atom") self.indent_sexp() self.newline() - field910 = unwrapped_fields909[0] - self.pretty_relation_id(field910) - field911 = unwrapped_fields909[1] - if not len(field911) == 0: + field902 = unwrapped_fields901[0] + self.pretty_relation_id(field902) + field903 = unwrapped_fields901[1] + if not len(field903) == 0: self.newline() - for i913, elem912 in enumerate(field911): - if (i913 > 0): + for i905, elem904 in enumerate(field903): + if (i905 > 0): self.newline() - self.pretty_term(elem912) + self.pretty_term(elem904) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat921 = self._try_flat(msg, self.pretty_pragma) - if flat921 is not None: - assert flat921 is not None - self.write(flat921) + flat913 = self._try_flat(msg, self.pretty_pragma) + if flat913 is not None: + assert flat913 is not None + self.write(flat913) return None else: - def _t1487(_dollar_dollar): + def _t1471(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1488 = _t1487(msg) - fields915 = _t1488 - assert fields915 is not None - unwrapped_fields916 = fields915 + _t1472 = _t1471(msg) + fields907 = _t1472 + assert fields907 is not None + unwrapped_fields908 = fields907 self.write("(") self.write("pragma") self.indent_sexp() self.newline() - field917 = unwrapped_fields916[0] - self.pretty_name(field917) - field918 = unwrapped_fields916[1] - if not len(field918) == 0: + field909 = unwrapped_fields908[0] + self.pretty_name(field909) + field910 = unwrapped_fields908[1] + if not len(field910) == 0: self.newline() - for i920, elem919 in enumerate(field918): - if (i920 > 0): + for i912, elem911 in enumerate(field910): + if (i912 > 0): self.newline() - self.pretty_term(elem919) + self.pretty_term(elem911) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat937 = self._try_flat(msg, self.pretty_primitive) - if flat937 is not None: - assert flat937 is not None - self.write(flat937) + flat929 = self._try_flat(msg, self.pretty_primitive) + if flat929 is not None: + assert flat929 is not None + self.write(flat929) return None else: - def _t1489(_dollar_dollar): + def _t1473(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_eq": - _t1490 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1474 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1490 = None - return _t1490 - _t1491 = _t1489(msg) - guard_result936 = _t1491 - if guard_result936 is not None: + _t1474 = None + return _t1474 + _t1475 = _t1473(msg) + guard_result928 = _t1475 + if guard_result928 is not None: self.pretty_eq(msg) else: - def _t1492(_dollar_dollar): + def _t1476(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1493 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1477 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1493 = None - return _t1493 - _t1494 = _t1492(msg) - guard_result935 = _t1494 - if guard_result935 is not None: + _t1477 = None + return _t1477 + _t1478 = _t1476(msg) + guard_result927 = _t1478 + if guard_result927 is not None: self.pretty_lt(msg) else: - def _t1495(_dollar_dollar): + def _t1479(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1496 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1480 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1496 = None - return _t1496 - _t1497 = _t1495(msg) - guard_result934 = _t1497 - if guard_result934 is not None: + _t1480 = None + return _t1480 + _t1481 = _t1479(msg) + guard_result926 = _t1481 + if guard_result926 is not None: self.pretty_lt_eq(msg) else: - def _t1498(_dollar_dollar): + def _t1482(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1499 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1483 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1499 = None - return _t1499 - _t1500 = _t1498(msg) - guard_result933 = _t1500 - if guard_result933 is not None: + _t1483 = None + return _t1483 + _t1484 = _t1482(msg) + guard_result925 = _t1484 + if guard_result925 is not None: self.pretty_gt(msg) else: - def _t1501(_dollar_dollar): + def _t1485(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1502 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1486 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1502 = None - return _t1502 - _t1503 = _t1501(msg) - guard_result932 = _t1503 - if guard_result932 is not None: + _t1486 = None + return _t1486 + _t1487 = _t1485(msg) + guard_result924 = _t1487 + if guard_result924 is not None: self.pretty_gt_eq(msg) else: - def _t1504(_dollar_dollar): + def _t1488(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1505 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1489 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1505 = None - return _t1505 - _t1506 = _t1504(msg) - guard_result931 = _t1506 - if guard_result931 is not None: + _t1489 = None + return _t1489 + _t1490 = _t1488(msg) + guard_result923 = _t1490 + if guard_result923 is not None: self.pretty_add(msg) else: - def _t1507(_dollar_dollar): + def _t1491(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1508 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1492 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1508 = None - return _t1508 - _t1509 = _t1507(msg) - guard_result930 = _t1509 - if guard_result930 is not None: + _t1492 = None + return _t1492 + _t1493 = _t1491(msg) + guard_result922 = _t1493 + if guard_result922 is not None: self.pretty_minus(msg) else: - def _t1510(_dollar_dollar): + def _t1494(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1511 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1495 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1511 = None - return _t1511 - _t1512 = _t1510(msg) - guard_result929 = _t1512 - if guard_result929 is not None: + _t1495 = None + return _t1495 + _t1496 = _t1494(msg) + guard_result921 = _t1496 + if guard_result921 is not None: self.pretty_multiply(msg) else: - def _t1513(_dollar_dollar): + def _t1497(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1514 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1498 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1514 = None - return _t1514 - _t1515 = _t1513(msg) - guard_result928 = _t1515 - if guard_result928 is not None: + _t1498 = None + return _t1498 + _t1499 = _t1497(msg) + guard_result920 = _t1499 + if guard_result920 is not None: self.pretty_divide(msg) else: - def _t1516(_dollar_dollar): + def _t1500(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1517 = _t1516(msg) - fields922 = _t1517 - assert fields922 is not None - unwrapped_fields923 = fields922 + _t1501 = _t1500(msg) + fields914 = _t1501 + assert fields914 is not None + unwrapped_fields915 = fields914 self.write("(") self.write("primitive") self.indent_sexp() self.newline() - field924 = unwrapped_fields923[0] - self.pretty_name(field924) - field925 = unwrapped_fields923[1] - if not len(field925) == 0: + field916 = unwrapped_fields915[0] + self.pretty_name(field916) + field917 = unwrapped_fields915[1] + if not len(field917) == 0: self.newline() - for i927, elem926 in enumerate(field925): - if (i927 > 0): + for i919, elem918 in enumerate(field917): + if (i919 > 0): self.newline() - self.pretty_rel_term(elem926) + self.pretty_rel_term(elem918) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat942 = self._try_flat(msg, self.pretty_eq) - if flat942 is not None: - assert flat942 is not None - self.write(flat942) + flat934 = self._try_flat(msg, self.pretty_eq) + if flat934 is not None: + assert flat934 is not None + self.write(flat934) return None else: - def _t1518(_dollar_dollar): + def _t1502(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_eq": - _t1519 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1503 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1519 = None - return _t1519 - _t1520 = _t1518(msg) - fields938 = _t1520 - assert fields938 is not None - unwrapped_fields939 = fields938 + _t1503 = None + return _t1503 + _t1504 = _t1502(msg) + fields930 = _t1504 + assert fields930 is not None + unwrapped_fields931 = fields930 self.write("(") self.write("=") self.indent_sexp() self.newline() - field940 = unwrapped_fields939[0] - self.pretty_term(field940) + field932 = unwrapped_fields931[0] + self.pretty_term(field932) self.newline() - field941 = unwrapped_fields939[1] - self.pretty_term(field941) + field933 = unwrapped_fields931[1] + self.pretty_term(field933) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat947 = self._try_flat(msg, self.pretty_lt) - if flat947 is not None: - assert flat947 is not None - self.write(flat947) + flat939 = self._try_flat(msg, self.pretty_lt) + if flat939 is not None: + assert flat939 is not None + self.write(flat939) return None else: - def _t1521(_dollar_dollar): + def _t1505(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1522 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1506 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1522 = None - return _t1522 - _t1523 = _t1521(msg) - fields943 = _t1523 - assert fields943 is not None - unwrapped_fields944 = fields943 + _t1506 = None + return _t1506 + _t1507 = _t1505(msg) + fields935 = _t1507 + assert fields935 is not None + unwrapped_fields936 = fields935 self.write("(") self.write("<") self.indent_sexp() self.newline() - field945 = unwrapped_fields944[0] - self.pretty_term(field945) + field937 = unwrapped_fields936[0] + self.pretty_term(field937) self.newline() - field946 = unwrapped_fields944[1] - self.pretty_term(field946) + field938 = unwrapped_fields936[1] + self.pretty_term(field938) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat952 = self._try_flat(msg, self.pretty_lt_eq) - if flat952 is not None: - assert flat952 is not None - self.write(flat952) + flat944 = self._try_flat(msg, self.pretty_lt_eq) + if flat944 is not None: + assert flat944 is not None + self.write(flat944) return None else: - def _t1524(_dollar_dollar): + def _t1508(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1525 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1509 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1525 = None - return _t1525 - _t1526 = _t1524(msg) - fields948 = _t1526 - assert fields948 is not None - unwrapped_fields949 = fields948 + _t1509 = None + return _t1509 + _t1510 = _t1508(msg) + fields940 = _t1510 + assert fields940 is not None + unwrapped_fields941 = fields940 self.write("(") self.write("<=") self.indent_sexp() self.newline() - field950 = unwrapped_fields949[0] - self.pretty_term(field950) + field942 = unwrapped_fields941[0] + self.pretty_term(field942) self.newline() - field951 = unwrapped_fields949[1] - self.pretty_term(field951) + field943 = unwrapped_fields941[1] + self.pretty_term(field943) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat957 = self._try_flat(msg, self.pretty_gt) - if flat957 is not None: - assert flat957 is not None - self.write(flat957) + flat949 = self._try_flat(msg, self.pretty_gt) + if flat949 is not None: + assert flat949 is not None + self.write(flat949) return None else: - def _t1527(_dollar_dollar): + def _t1511(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1528 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1512 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1528 = None - return _t1528 - _t1529 = _t1527(msg) - fields953 = _t1529 - assert fields953 is not None - unwrapped_fields954 = fields953 + _t1512 = None + return _t1512 + _t1513 = _t1511(msg) + fields945 = _t1513 + assert fields945 is not None + unwrapped_fields946 = fields945 self.write("(") self.write(">") self.indent_sexp() self.newline() - field955 = unwrapped_fields954[0] - self.pretty_term(field955) + field947 = unwrapped_fields946[0] + self.pretty_term(field947) self.newline() - field956 = unwrapped_fields954[1] - self.pretty_term(field956) + field948 = unwrapped_fields946[1] + self.pretty_term(field948) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat962 = self._try_flat(msg, self.pretty_gt_eq) - if flat962 is not None: - assert flat962 is not None - self.write(flat962) + flat954 = self._try_flat(msg, self.pretty_gt_eq) + if flat954 is not None: + assert flat954 is not None + self.write(flat954) return None else: - def _t1530(_dollar_dollar): + def _t1514(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1531 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1515 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1531 = None - return _t1531 - _t1532 = _t1530(msg) - fields958 = _t1532 - assert fields958 is not None - unwrapped_fields959 = fields958 + _t1515 = None + return _t1515 + _t1516 = _t1514(msg) + fields950 = _t1516 + assert fields950 is not None + unwrapped_fields951 = fields950 self.write("(") self.write(">=") self.indent_sexp() self.newline() - field960 = unwrapped_fields959[0] - self.pretty_term(field960) + field952 = unwrapped_fields951[0] + self.pretty_term(field952) self.newline() - field961 = unwrapped_fields959[1] - self.pretty_term(field961) + field953 = unwrapped_fields951[1] + self.pretty_term(field953) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat968 = self._try_flat(msg, self.pretty_add) - if flat968 is not None: - assert flat968 is not None - self.write(flat968) + flat960 = self._try_flat(msg, self.pretty_add) + if flat960 is not None: + assert flat960 is not None + self.write(flat960) return None else: - def _t1533(_dollar_dollar): + def _t1517(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1534 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1518 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1534 = None - return _t1534 - _t1535 = _t1533(msg) - fields963 = _t1535 - assert fields963 is not None - unwrapped_fields964 = fields963 + _t1518 = None + return _t1518 + _t1519 = _t1517(msg) + fields955 = _t1519 + assert fields955 is not None + unwrapped_fields956 = fields955 self.write("(") self.write("+") self.indent_sexp() self.newline() - field965 = unwrapped_fields964[0] - self.pretty_term(field965) + field957 = unwrapped_fields956[0] + self.pretty_term(field957) self.newline() - field966 = unwrapped_fields964[1] - self.pretty_term(field966) + field958 = unwrapped_fields956[1] + self.pretty_term(field958) self.newline() - field967 = unwrapped_fields964[2] - self.pretty_term(field967) + field959 = unwrapped_fields956[2] + self.pretty_term(field959) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat974 = self._try_flat(msg, self.pretty_minus) - if flat974 is not None: - assert flat974 is not None - self.write(flat974) + flat966 = self._try_flat(msg, self.pretty_minus) + if flat966 is not None: + assert flat966 is not None + self.write(flat966) return None else: - def _t1536(_dollar_dollar): + def _t1520(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1537 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1521 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1537 = None - return _t1537 - _t1538 = _t1536(msg) - fields969 = _t1538 - assert fields969 is not None - unwrapped_fields970 = fields969 + _t1521 = None + return _t1521 + _t1522 = _t1520(msg) + fields961 = _t1522 + assert fields961 is not None + unwrapped_fields962 = fields961 self.write("(") self.write("-") self.indent_sexp() self.newline() - field971 = unwrapped_fields970[0] - self.pretty_term(field971) + field963 = unwrapped_fields962[0] + self.pretty_term(field963) self.newline() - field972 = unwrapped_fields970[1] - self.pretty_term(field972) + field964 = unwrapped_fields962[1] + self.pretty_term(field964) self.newline() - field973 = unwrapped_fields970[2] - self.pretty_term(field973) + field965 = unwrapped_fields962[2] + self.pretty_term(field965) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat980 = self._try_flat(msg, self.pretty_multiply) - if flat980 is not None: - assert flat980 is not None - self.write(flat980) + flat972 = self._try_flat(msg, self.pretty_multiply) + if flat972 is not None: + assert flat972 is not None + self.write(flat972) return None else: - def _t1539(_dollar_dollar): + def _t1523(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1540 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1524 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1540 = None - return _t1540 - _t1541 = _t1539(msg) - fields975 = _t1541 - assert fields975 is not None - unwrapped_fields976 = fields975 + _t1524 = None + return _t1524 + _t1525 = _t1523(msg) + fields967 = _t1525 + assert fields967 is not None + unwrapped_fields968 = fields967 self.write("(") self.write("*") self.indent_sexp() self.newline() - field977 = unwrapped_fields976[0] - self.pretty_term(field977) + field969 = unwrapped_fields968[0] + self.pretty_term(field969) self.newline() - field978 = unwrapped_fields976[1] - self.pretty_term(field978) + field970 = unwrapped_fields968[1] + self.pretty_term(field970) self.newline() - field979 = unwrapped_fields976[2] - self.pretty_term(field979) + field971 = unwrapped_fields968[2] + self.pretty_term(field971) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat986 = self._try_flat(msg, self.pretty_divide) - if flat986 is not None: - assert flat986 is not None - self.write(flat986) + flat978 = self._try_flat(msg, self.pretty_divide) + if flat978 is not None: + assert flat978 is not None + self.write(flat978) return None else: - def _t1542(_dollar_dollar): + def _t1526(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1543 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1527 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1543 = None - return _t1543 - _t1544 = _t1542(msg) - fields981 = _t1544 - assert fields981 is not None - unwrapped_fields982 = fields981 + _t1527 = None + return _t1527 + _t1528 = _t1526(msg) + fields973 = _t1528 + assert fields973 is not None + unwrapped_fields974 = fields973 self.write("(") self.write("/") self.indent_sexp() self.newline() - field983 = unwrapped_fields982[0] - self.pretty_term(field983) + field975 = unwrapped_fields974[0] + self.pretty_term(field975) self.newline() - field984 = unwrapped_fields982[1] - self.pretty_term(field984) + field976 = unwrapped_fields974[1] + self.pretty_term(field976) self.newline() - field985 = unwrapped_fields982[2] - self.pretty_term(field985) + field977 = unwrapped_fields974[2] + self.pretty_term(field977) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat991 = self._try_flat(msg, self.pretty_rel_term) - if flat991 is not None: - assert flat991 is not None - self.write(flat991) + flat983 = self._try_flat(msg, self.pretty_rel_term) + if flat983 is not None: + assert flat983 is not None + self.write(flat983) return None else: - def _t1545(_dollar_dollar): + def _t1529(_dollar_dollar): if _dollar_dollar.HasField("specialized_value"): - _t1546 = _dollar_dollar.specialized_value + _t1530 = _dollar_dollar.specialized_value else: - _t1546 = None - return _t1546 - _t1547 = _t1545(msg) - deconstruct_result989 = _t1547 - if deconstruct_result989 is not None: - assert deconstruct_result989 is not None - unwrapped990 = deconstruct_result989 - self.pretty_specialized_value(unwrapped990) + _t1530 = None + return _t1530 + _t1531 = _t1529(msg) + deconstruct_result981 = _t1531 + if deconstruct_result981 is not None: + assert deconstruct_result981 is not None + unwrapped982 = deconstruct_result981 + self.pretty_specialized_value(unwrapped982) else: - def _t1548(_dollar_dollar): + def _t1532(_dollar_dollar): if _dollar_dollar.HasField("term"): - _t1549 = _dollar_dollar.term + _t1533 = _dollar_dollar.term else: - _t1549 = None - return _t1549 - _t1550 = _t1548(msg) - deconstruct_result987 = _t1550 - if deconstruct_result987 is not None: - assert deconstruct_result987 is not None - unwrapped988 = deconstruct_result987 - self.pretty_term(unwrapped988) + _t1533 = None + return _t1533 + _t1534 = _t1532(msg) + deconstruct_result979 = _t1534 + if deconstruct_result979 is not None: + assert deconstruct_result979 is not None + unwrapped980 = deconstruct_result979 + self.pretty_term(unwrapped980) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat993 = self._try_flat(msg, self.pretty_specialized_value) - if flat993 is not None: - assert flat993 is not None - self.write(flat993) + flat985 = self._try_flat(msg, self.pretty_specialized_value) + if flat985 is not None: + assert flat985 is not None + self.write(flat985) return None else: - fields992 = msg + fields984 = msg self.write("#") - self.pretty_value(fields992) + self.pretty_value(fields984) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1000 = self._try_flat(msg, self.pretty_rel_atom) - if flat1000 is not None: - assert flat1000 is not None - self.write(flat1000) + flat992 = self._try_flat(msg, self.pretty_rel_atom) + if flat992 is not None: + assert flat992 is not None + self.write(flat992) return None else: - def _t1551(_dollar_dollar): + def _t1535(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1552 = _t1551(msg) - fields994 = _t1552 - assert fields994 is not None - unwrapped_fields995 = fields994 + _t1536 = _t1535(msg) + fields986 = _t1536 + assert fields986 is not None + unwrapped_fields987 = fields986 self.write("(") self.write("relatom") self.indent_sexp() self.newline() - field996 = unwrapped_fields995[0] - self.pretty_name(field996) - field997 = unwrapped_fields995[1] - if not len(field997) == 0: + field988 = unwrapped_fields987[0] + self.pretty_name(field988) + field989 = unwrapped_fields987[1] + if not len(field989) == 0: self.newline() - for i999, elem998 in enumerate(field997): - if (i999 > 0): + for i991, elem990 in enumerate(field989): + if (i991 > 0): self.newline() - self.pretty_rel_term(elem998) + self.pretty_rel_term(elem990) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1005 = self._try_flat(msg, self.pretty_cast) - if flat1005 is not None: - assert flat1005 is not None - self.write(flat1005) + flat997 = self._try_flat(msg, self.pretty_cast) + if flat997 is not None: + assert flat997 is not None + self.write(flat997) return None else: - def _t1553(_dollar_dollar): + def _t1537(_dollar_dollar): return (_dollar_dollar.input, _dollar_dollar.result,) - _t1554 = _t1553(msg) - fields1001 = _t1554 - assert fields1001 is not None - unwrapped_fields1002 = fields1001 + _t1538 = _t1537(msg) + fields993 = _t1538 + assert fields993 is not None + unwrapped_fields994 = fields993 self.write("(") self.write("cast") self.indent_sexp() self.newline() - field1003 = unwrapped_fields1002[0] - self.pretty_term(field1003) + field995 = unwrapped_fields994[0] + self.pretty_term(field995) self.newline() - field1004 = unwrapped_fields1002[1] - self.pretty_term(field1004) + field996 = unwrapped_fields994[1] + self.pretty_term(field996) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1009 = self._try_flat(msg, self.pretty_attrs) - if flat1009 is not None: - assert flat1009 is not None - self.write(flat1009) + flat1001 = self._try_flat(msg, self.pretty_attrs) + if flat1001 is not None: + assert flat1001 is not None + self.write(flat1001) return None else: - fields1006 = msg + fields998 = msg self.write("(") self.write("attrs") self.indent_sexp() - if not len(fields1006) == 0: + if not len(fields998) == 0: self.newline() - for i1008, elem1007 in enumerate(fields1006): - if (i1008 > 0): + for i1000, elem999 in enumerate(fields998): + if (i1000 > 0): self.newline() - self.pretty_attribute(elem1007) + self.pretty_attribute(elem999) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1016 = self._try_flat(msg, self.pretty_attribute) - if flat1016 is not None: - assert flat1016 is not None - self.write(flat1016) + flat1008 = self._try_flat(msg, self.pretty_attribute) + if flat1008 is not None: + assert flat1008 is not None + self.write(flat1008) return None else: - def _t1555(_dollar_dollar): + def _t1539(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.args,) - _t1556 = _t1555(msg) - fields1010 = _t1556 - assert fields1010 is not None - unwrapped_fields1011 = fields1010 + _t1540 = _t1539(msg) + fields1002 = _t1540 + assert fields1002 is not None + unwrapped_fields1003 = fields1002 self.write("(") self.write("attribute") self.indent_sexp() self.newline() - field1012 = unwrapped_fields1011[0] - self.pretty_name(field1012) - field1013 = unwrapped_fields1011[1] - if not len(field1013) == 0: + field1004 = unwrapped_fields1003[0] + self.pretty_name(field1004) + field1005 = unwrapped_fields1003[1] + if not len(field1005) == 0: self.newline() - for i1015, elem1014 in enumerate(field1013): - if (i1015 > 0): + for i1007, elem1006 in enumerate(field1005): + if (i1007 > 0): self.newline() - self.pretty_value(elem1014) + self.pretty_value(elem1006) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1023 = self._try_flat(msg, self.pretty_algorithm) - if flat1023 is not None: - assert flat1023 is not None - self.write(flat1023) + flat1015 = self._try_flat(msg, self.pretty_algorithm) + if flat1015 is not None: + assert flat1015 is not None + self.write(flat1015) return None else: - def _t1557(_dollar_dollar): + def _t1541(_dollar_dollar): return (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,) - _t1558 = _t1557(msg) - fields1017 = _t1558 - assert fields1017 is not None - unwrapped_fields1018 = fields1017 + _t1542 = _t1541(msg) + fields1009 = _t1542 + assert fields1009 is not None + unwrapped_fields1010 = fields1009 self.write("(") self.write("algorithm") self.indent_sexp() - field1019 = unwrapped_fields1018[0] - if not len(field1019) == 0: + field1011 = unwrapped_fields1010[0] + if not len(field1011) == 0: self.newline() - for i1021, elem1020 in enumerate(field1019): - if (i1021 > 0): + for i1013, elem1012 in enumerate(field1011): + if (i1013 > 0): self.newline() - self.pretty_relation_id(elem1020) + self.pretty_relation_id(elem1012) self.newline() - field1022 = unwrapped_fields1018[1] - self.pretty_script(field1022) + field1014 = unwrapped_fields1010[1] + self.pretty_script(field1014) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1028 = self._try_flat(msg, self.pretty_script) - if flat1028 is not None: - assert flat1028 is not None - self.write(flat1028) + flat1020 = self._try_flat(msg, self.pretty_script) + if flat1020 is not None: + assert flat1020 is not None + self.write(flat1020) return None else: - def _t1559(_dollar_dollar): + def _t1543(_dollar_dollar): return _dollar_dollar.constructs - _t1560 = _t1559(msg) - fields1024 = _t1560 - assert fields1024 is not None - unwrapped_fields1025 = fields1024 + _t1544 = _t1543(msg) + fields1016 = _t1544 + assert fields1016 is not None + unwrapped_fields1017 = fields1016 self.write("(") self.write("script") self.indent_sexp() - if not len(unwrapped_fields1025) == 0: + if not len(unwrapped_fields1017) == 0: self.newline() - for i1027, elem1026 in enumerate(unwrapped_fields1025): - if (i1027 > 0): + for i1019, elem1018 in enumerate(unwrapped_fields1017): + if (i1019 > 0): self.newline() - self.pretty_construct(elem1026) + self.pretty_construct(elem1018) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1033 = self._try_flat(msg, self.pretty_construct) - if flat1033 is not None: - assert flat1033 is not None - self.write(flat1033) + flat1025 = self._try_flat(msg, self.pretty_construct) + if flat1025 is not None: + assert flat1025 is not None + self.write(flat1025) return None else: - def _t1561(_dollar_dollar): + def _t1545(_dollar_dollar): if _dollar_dollar.HasField("loop"): - _t1562 = _dollar_dollar.loop + _t1546 = _dollar_dollar.loop else: - _t1562 = None - return _t1562 - _t1563 = _t1561(msg) - deconstruct_result1031 = _t1563 - if deconstruct_result1031 is not None: - assert deconstruct_result1031 is not None - unwrapped1032 = deconstruct_result1031 - self.pretty_loop(unwrapped1032) + _t1546 = None + return _t1546 + _t1547 = _t1545(msg) + deconstruct_result1023 = _t1547 + if deconstruct_result1023 is not None: + assert deconstruct_result1023 is not None + unwrapped1024 = deconstruct_result1023 + self.pretty_loop(unwrapped1024) else: - def _t1564(_dollar_dollar): + def _t1548(_dollar_dollar): if _dollar_dollar.HasField("instruction"): - _t1565 = _dollar_dollar.instruction + _t1549 = _dollar_dollar.instruction else: - _t1565 = None - return _t1565 - _t1566 = _t1564(msg) - deconstruct_result1029 = _t1566 - if deconstruct_result1029 is not None: - assert deconstruct_result1029 is not None - unwrapped1030 = deconstruct_result1029 - self.pretty_instruction(unwrapped1030) + _t1549 = None + return _t1549 + _t1550 = _t1548(msg) + deconstruct_result1021 = _t1550 + if deconstruct_result1021 is not None: + assert deconstruct_result1021 is not None + unwrapped1022 = deconstruct_result1021 + self.pretty_instruction(unwrapped1022) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1038 = self._try_flat(msg, self.pretty_loop) - if flat1038 is not None: - assert flat1038 is not None - self.write(flat1038) + flat1030 = self._try_flat(msg, self.pretty_loop) + if flat1030 is not None: + assert flat1030 is not None + self.write(flat1030) return None else: - def _t1567(_dollar_dollar): + def _t1551(_dollar_dollar): return (_dollar_dollar.init, _dollar_dollar.body,) - _t1568 = _t1567(msg) - fields1034 = _t1568 - assert fields1034 is not None - unwrapped_fields1035 = fields1034 + _t1552 = _t1551(msg) + fields1026 = _t1552 + assert fields1026 is not None + unwrapped_fields1027 = fields1026 self.write("(") self.write("loop") self.indent_sexp() self.newline() - field1036 = unwrapped_fields1035[0] - self.pretty_init(field1036) + field1028 = unwrapped_fields1027[0] + self.pretty_init(field1028) self.newline() - field1037 = unwrapped_fields1035[1] - self.pretty_script(field1037) + field1029 = unwrapped_fields1027[1] + self.pretty_script(field1029) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1042 = self._try_flat(msg, self.pretty_init) - if flat1042 is not None: - assert flat1042 is not None - self.write(flat1042) + flat1034 = self._try_flat(msg, self.pretty_init) + if flat1034 is not None: + assert flat1034 is not None + self.write(flat1034) return None else: - fields1039 = msg + fields1031 = msg self.write("(") self.write("init") self.indent_sexp() - if not len(fields1039) == 0: + if not len(fields1031) == 0: self.newline() - for i1041, elem1040 in enumerate(fields1039): - if (i1041 > 0): + for i1033, elem1032 in enumerate(fields1031): + if (i1033 > 0): self.newline() - self.pretty_instruction(elem1040) + self.pretty_instruction(elem1032) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1053 = self._try_flat(msg, self.pretty_instruction) - if flat1053 is not None: - assert flat1053 is not None - self.write(flat1053) + flat1045 = self._try_flat(msg, self.pretty_instruction) + if flat1045 is not None: + assert flat1045 is not None + self.write(flat1045) return None else: - def _t1569(_dollar_dollar): + def _t1553(_dollar_dollar): if _dollar_dollar.HasField("assign"): - _t1570 = _dollar_dollar.assign + _t1554 = _dollar_dollar.assign else: - _t1570 = None - return _t1570 - _t1571 = _t1569(msg) - deconstruct_result1051 = _t1571 - if deconstruct_result1051 is not None: - assert deconstruct_result1051 is not None - unwrapped1052 = deconstruct_result1051 - self.pretty_assign(unwrapped1052) + _t1554 = None + return _t1554 + _t1555 = _t1553(msg) + deconstruct_result1043 = _t1555 + if deconstruct_result1043 is not None: + assert deconstruct_result1043 is not None + unwrapped1044 = deconstruct_result1043 + self.pretty_assign(unwrapped1044) else: - def _t1572(_dollar_dollar): + def _t1556(_dollar_dollar): if _dollar_dollar.HasField("upsert"): - _t1573 = _dollar_dollar.upsert + _t1557 = _dollar_dollar.upsert else: - _t1573 = None - return _t1573 - _t1574 = _t1572(msg) - deconstruct_result1049 = _t1574 - if deconstruct_result1049 is not None: - assert deconstruct_result1049 is not None - unwrapped1050 = deconstruct_result1049 - self.pretty_upsert(unwrapped1050) + _t1557 = None + return _t1557 + _t1558 = _t1556(msg) + deconstruct_result1041 = _t1558 + if deconstruct_result1041 is not None: + assert deconstruct_result1041 is not None + unwrapped1042 = deconstruct_result1041 + self.pretty_upsert(unwrapped1042) else: - def _t1575(_dollar_dollar): + def _t1559(_dollar_dollar): if _dollar_dollar.HasField("break"): - _t1576 = getattr(_dollar_dollar, 'break') + _t1560 = getattr(_dollar_dollar, 'break') else: - _t1576 = None - return _t1576 - _t1577 = _t1575(msg) - deconstruct_result1047 = _t1577 - if deconstruct_result1047 is not None: - assert deconstruct_result1047 is not None - unwrapped1048 = deconstruct_result1047 - self.pretty_break(unwrapped1048) + _t1560 = None + return _t1560 + _t1561 = _t1559(msg) + deconstruct_result1039 = _t1561 + if deconstruct_result1039 is not None: + assert deconstruct_result1039 is not None + unwrapped1040 = deconstruct_result1039 + self.pretty_break(unwrapped1040) else: - def _t1578(_dollar_dollar): + def _t1562(_dollar_dollar): if _dollar_dollar.HasField("monoid_def"): - _t1579 = _dollar_dollar.monoid_def + _t1563 = _dollar_dollar.monoid_def else: - _t1579 = None - return _t1579 - _t1580 = _t1578(msg) - deconstruct_result1045 = _t1580 - if deconstruct_result1045 is not None: - assert deconstruct_result1045 is not None - unwrapped1046 = deconstruct_result1045 - self.pretty_monoid_def(unwrapped1046) + _t1563 = None + return _t1563 + _t1564 = _t1562(msg) + deconstruct_result1037 = _t1564 + if deconstruct_result1037 is not None: + assert deconstruct_result1037 is not None + unwrapped1038 = deconstruct_result1037 + self.pretty_monoid_def(unwrapped1038) else: - def _t1581(_dollar_dollar): + def _t1565(_dollar_dollar): if _dollar_dollar.HasField("monus_def"): - _t1582 = _dollar_dollar.monus_def + _t1566 = _dollar_dollar.monus_def else: - _t1582 = None - return _t1582 - _t1583 = _t1581(msg) - deconstruct_result1043 = _t1583 - if deconstruct_result1043 is not None: - assert deconstruct_result1043 is not None - unwrapped1044 = deconstruct_result1043 - self.pretty_monus_def(unwrapped1044) + _t1566 = None + return _t1566 + _t1567 = _t1565(msg) + deconstruct_result1035 = _t1567 + if deconstruct_result1035 is not None: + assert deconstruct_result1035 is not None + unwrapped1036 = deconstruct_result1035 + self.pretty_monus_def(unwrapped1036) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1060 = self._try_flat(msg, self.pretty_assign) - if flat1060 is not None: - assert flat1060 is not None - self.write(flat1060) + flat1052 = self._try_flat(msg, self.pretty_assign) + if flat1052 is not None: + assert flat1052 is not None + self.write(flat1052) return None else: - def _t1584(_dollar_dollar): + def _t1568(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1585 = _dollar_dollar.attrs + _t1569 = _dollar_dollar.attrs else: - _t1585 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1585,) - _t1586 = _t1584(msg) - fields1054 = _t1586 - assert fields1054 is not None - unwrapped_fields1055 = fields1054 + _t1569 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1569,) + _t1570 = _t1568(msg) + fields1046 = _t1570 + assert fields1046 is not None + unwrapped_fields1047 = fields1046 self.write("(") self.write("assign") self.indent_sexp() self.newline() - field1056 = unwrapped_fields1055[0] - self.pretty_relation_id(field1056) + field1048 = unwrapped_fields1047[0] + self.pretty_relation_id(field1048) self.newline() - field1057 = unwrapped_fields1055[1] - self.pretty_abstraction(field1057) - field1058 = unwrapped_fields1055[2] - if field1058 is not None: + field1049 = unwrapped_fields1047[1] + self.pretty_abstraction(field1049) + field1050 = unwrapped_fields1047[2] + if field1050 is not None: self.newline() - assert field1058 is not None - opt_val1059 = field1058 - self.pretty_attrs(opt_val1059) + assert field1050 is not None + opt_val1051 = field1050 + self.pretty_attrs(opt_val1051) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1067 = self._try_flat(msg, self.pretty_upsert) - if flat1067 is not None: - assert flat1067 is not None - self.write(flat1067) + flat1059 = self._try_flat(msg, self.pretty_upsert) + if flat1059 is not None: + assert flat1059 is not None + self.write(flat1059) return None else: - def _t1587(_dollar_dollar): + def _t1571(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1588 = _dollar_dollar.attrs + _t1572 = _dollar_dollar.attrs else: - _t1588 = None - return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1588,) - _t1589 = _t1587(msg) - fields1061 = _t1589 - assert fields1061 is not None - unwrapped_fields1062 = fields1061 + _t1572 = None + return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1572,) + _t1573 = _t1571(msg) + fields1053 = _t1573 + assert fields1053 is not None + unwrapped_fields1054 = fields1053 self.write("(") self.write("upsert") self.indent_sexp() self.newline() - field1063 = unwrapped_fields1062[0] - self.pretty_relation_id(field1063) + field1055 = unwrapped_fields1054[0] + self.pretty_relation_id(field1055) self.newline() - field1064 = unwrapped_fields1062[1] - self.pretty_abstraction_with_arity(field1064) - field1065 = unwrapped_fields1062[2] - if field1065 is not None: + field1056 = unwrapped_fields1054[1] + self.pretty_abstraction_with_arity(field1056) + field1057 = unwrapped_fields1054[2] + if field1057 is not None: self.newline() - assert field1065 is not None - opt_val1066 = field1065 - self.pretty_attrs(opt_val1066) + assert field1057 is not None + opt_val1058 = field1057 + self.pretty_attrs(opt_val1058) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1072 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1072 is not None: - assert flat1072 is not None - self.write(flat1072) + flat1064 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1064 is not None: + assert flat1064 is not None + self.write(flat1064) return None else: - def _t1590(_dollar_dollar): - _t1591 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - return (_t1591, _dollar_dollar[0].value,) - _t1592 = _t1590(msg) - fields1068 = _t1592 - assert fields1068 is not None - unwrapped_fields1069 = fields1068 + def _t1574(_dollar_dollar): + _t1575 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + return (_t1575, _dollar_dollar[0].value,) + _t1576 = _t1574(msg) + fields1060 = _t1576 + assert fields1060 is not None + unwrapped_fields1061 = fields1060 self.write("(") self.indent() - field1070 = unwrapped_fields1069[0] - self.pretty_bindings(field1070) + field1062 = unwrapped_fields1061[0] + self.pretty_bindings(field1062) self.newline() - field1071 = unwrapped_fields1069[1] - self.pretty_formula(field1071) + field1063 = unwrapped_fields1061[1] + self.pretty_formula(field1063) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1079 = self._try_flat(msg, self.pretty_break) - if flat1079 is not None: - assert flat1079 is not None - self.write(flat1079) + flat1071 = self._try_flat(msg, self.pretty_break) + if flat1071 is not None: + assert flat1071 is not None + self.write(flat1071) return None else: - def _t1593(_dollar_dollar): + def _t1577(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1594 = _dollar_dollar.attrs + _t1578 = _dollar_dollar.attrs else: - _t1594 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1594,) - _t1595 = _t1593(msg) - fields1073 = _t1595 - assert fields1073 is not None - unwrapped_fields1074 = fields1073 + _t1578 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1578,) + _t1579 = _t1577(msg) + fields1065 = _t1579 + assert fields1065 is not None + unwrapped_fields1066 = fields1065 self.write("(") self.write("break") self.indent_sexp() self.newline() - field1075 = unwrapped_fields1074[0] - self.pretty_relation_id(field1075) + field1067 = unwrapped_fields1066[0] + self.pretty_relation_id(field1067) self.newline() - field1076 = unwrapped_fields1074[1] - self.pretty_abstraction(field1076) - field1077 = unwrapped_fields1074[2] - if field1077 is not None: + field1068 = unwrapped_fields1066[1] + self.pretty_abstraction(field1068) + field1069 = unwrapped_fields1066[2] + if field1069 is not None: self.newline() - assert field1077 is not None - opt_val1078 = field1077 - self.pretty_attrs(opt_val1078) + assert field1069 is not None + opt_val1070 = field1069 + self.pretty_attrs(opt_val1070) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1087 = self._try_flat(msg, self.pretty_monoid_def) - if flat1087 is not None: - assert flat1087 is not None - self.write(flat1087) + flat1079 = self._try_flat(msg, self.pretty_monoid_def) + if flat1079 is not None: + assert flat1079 is not None + self.write(flat1079) return None else: - def _t1596(_dollar_dollar): + def _t1580(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1597 = _dollar_dollar.attrs + _t1581 = _dollar_dollar.attrs else: - _t1597 = None - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1597,) - _t1598 = _t1596(msg) - fields1080 = _t1598 - assert fields1080 is not None - unwrapped_fields1081 = fields1080 + _t1581 = None + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1581,) + _t1582 = _t1580(msg) + fields1072 = _t1582 + assert fields1072 is not None + unwrapped_fields1073 = fields1072 self.write("(") self.write("monoid") self.indent_sexp() self.newline() - field1082 = unwrapped_fields1081[0] - self.pretty_monoid(field1082) + field1074 = unwrapped_fields1073[0] + self.pretty_monoid(field1074) self.newline() - field1083 = unwrapped_fields1081[1] - self.pretty_relation_id(field1083) + field1075 = unwrapped_fields1073[1] + self.pretty_relation_id(field1075) self.newline() - field1084 = unwrapped_fields1081[2] - self.pretty_abstraction_with_arity(field1084) - field1085 = unwrapped_fields1081[3] - if field1085 is not None: + field1076 = unwrapped_fields1073[2] + self.pretty_abstraction_with_arity(field1076) + field1077 = unwrapped_fields1073[3] + if field1077 is not None: self.newline() - assert field1085 is not None - opt_val1086 = field1085 - self.pretty_attrs(opt_val1086) + assert field1077 is not None + opt_val1078 = field1077 + self.pretty_attrs(opt_val1078) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1096 = self._try_flat(msg, self.pretty_monoid) - if flat1096 is not None: - assert flat1096 is not None - self.write(flat1096) + flat1088 = self._try_flat(msg, self.pretty_monoid) + if flat1088 is not None: + assert flat1088 is not None + self.write(flat1088) return None else: - def _t1599(_dollar_dollar): + def _t1583(_dollar_dollar): if _dollar_dollar.HasField("or_monoid"): - _t1600 = _dollar_dollar.or_monoid + _t1584 = _dollar_dollar.or_monoid else: - _t1600 = None - return _t1600 - _t1601 = _t1599(msg) - deconstruct_result1094 = _t1601 - if deconstruct_result1094 is not None: - assert deconstruct_result1094 is not None - unwrapped1095 = deconstruct_result1094 - self.pretty_or_monoid(unwrapped1095) + _t1584 = None + return _t1584 + _t1585 = _t1583(msg) + deconstruct_result1086 = _t1585 + if deconstruct_result1086 is not None: + assert deconstruct_result1086 is not None + unwrapped1087 = deconstruct_result1086 + self.pretty_or_monoid(unwrapped1087) else: - def _t1602(_dollar_dollar): + def _t1586(_dollar_dollar): if _dollar_dollar.HasField("min_monoid"): - _t1603 = _dollar_dollar.min_monoid + _t1587 = _dollar_dollar.min_monoid else: - _t1603 = None - return _t1603 - _t1604 = _t1602(msg) - deconstruct_result1092 = _t1604 - if deconstruct_result1092 is not None: - assert deconstruct_result1092 is not None - unwrapped1093 = deconstruct_result1092 - self.pretty_min_monoid(unwrapped1093) + _t1587 = None + return _t1587 + _t1588 = _t1586(msg) + deconstruct_result1084 = _t1588 + if deconstruct_result1084 is not None: + assert deconstruct_result1084 is not None + unwrapped1085 = deconstruct_result1084 + self.pretty_min_monoid(unwrapped1085) else: - def _t1605(_dollar_dollar): + def _t1589(_dollar_dollar): if _dollar_dollar.HasField("max_monoid"): - _t1606 = _dollar_dollar.max_monoid + _t1590 = _dollar_dollar.max_monoid else: - _t1606 = None - return _t1606 - _t1607 = _t1605(msg) - deconstruct_result1090 = _t1607 - if deconstruct_result1090 is not None: - assert deconstruct_result1090 is not None - unwrapped1091 = deconstruct_result1090 - self.pretty_max_monoid(unwrapped1091) + _t1590 = None + return _t1590 + _t1591 = _t1589(msg) + deconstruct_result1082 = _t1591 + if deconstruct_result1082 is not None: + assert deconstruct_result1082 is not None + unwrapped1083 = deconstruct_result1082 + self.pretty_max_monoid(unwrapped1083) else: - def _t1608(_dollar_dollar): + def _t1592(_dollar_dollar): if _dollar_dollar.HasField("sum_monoid"): - _t1609 = _dollar_dollar.sum_monoid + _t1593 = _dollar_dollar.sum_monoid else: - _t1609 = None - return _t1609 - _t1610 = _t1608(msg) - deconstruct_result1088 = _t1610 - if deconstruct_result1088 is not None: - assert deconstruct_result1088 is not None - unwrapped1089 = deconstruct_result1088 - self.pretty_sum_monoid(unwrapped1089) + _t1593 = None + return _t1593 + _t1594 = _t1592(msg) + deconstruct_result1080 = _t1594 + if deconstruct_result1080 is not None: + assert deconstruct_result1080 is not None + unwrapped1081 = deconstruct_result1080 + self.pretty_sum_monoid(unwrapped1081) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1097 = msg + fields1089 = msg self.write("(") self.write("or") self.write(")") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1100 = self._try_flat(msg, self.pretty_min_monoid) - if flat1100 is not None: - assert flat1100 is not None - self.write(flat1100) + flat1092 = self._try_flat(msg, self.pretty_min_monoid) + if flat1092 is not None: + assert flat1092 is not None + self.write(flat1092) return None else: - def _t1611(_dollar_dollar): + def _t1595(_dollar_dollar): return _dollar_dollar.type - _t1612 = _t1611(msg) - fields1098 = _t1612 - assert fields1098 is not None - unwrapped_fields1099 = fields1098 + _t1596 = _t1595(msg) + fields1090 = _t1596 + assert fields1090 is not None + unwrapped_fields1091 = fields1090 self.write("(") self.write("min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1099) + self.pretty_type(unwrapped_fields1091) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1103 = self._try_flat(msg, self.pretty_max_monoid) - if flat1103 is not None: - assert flat1103 is not None - self.write(flat1103) + flat1095 = self._try_flat(msg, self.pretty_max_monoid) + if flat1095 is not None: + assert flat1095 is not None + self.write(flat1095) return None else: - def _t1613(_dollar_dollar): + def _t1597(_dollar_dollar): return _dollar_dollar.type - _t1614 = _t1613(msg) - fields1101 = _t1614 - assert fields1101 is not None - unwrapped_fields1102 = fields1101 + _t1598 = _t1597(msg) + fields1093 = _t1598 + assert fields1093 is not None + unwrapped_fields1094 = fields1093 self.write("(") self.write("max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1102) + self.pretty_type(unwrapped_fields1094) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1106 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1106 is not None: - assert flat1106 is not None - self.write(flat1106) + flat1098 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1098 is not None: + assert flat1098 is not None + self.write(flat1098) return None else: - def _t1615(_dollar_dollar): + def _t1599(_dollar_dollar): return _dollar_dollar.type - _t1616 = _t1615(msg) - fields1104 = _t1616 - assert fields1104 is not None - unwrapped_fields1105 = fields1104 + _t1600 = _t1599(msg) + fields1096 = _t1600 + assert fields1096 is not None + unwrapped_fields1097 = fields1096 self.write("(") self.write("sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1105) + self.pretty_type(unwrapped_fields1097) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1114 = self._try_flat(msg, self.pretty_monus_def) - if flat1114 is not None: - assert flat1114 is not None - self.write(flat1114) + flat1106 = self._try_flat(msg, self.pretty_monus_def) + if flat1106 is not None: + assert flat1106 is not None + self.write(flat1106) return None else: - def _t1617(_dollar_dollar): + def _t1601(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1618 = _dollar_dollar.attrs + _t1602 = _dollar_dollar.attrs else: - _t1618 = None - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1618,) - _t1619 = _t1617(msg) - fields1107 = _t1619 - assert fields1107 is not None - unwrapped_fields1108 = fields1107 + _t1602 = None + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1602,) + _t1603 = _t1601(msg) + fields1099 = _t1603 + assert fields1099 is not None + unwrapped_fields1100 = fields1099 self.write("(") self.write("monus") self.indent_sexp() self.newline() - field1109 = unwrapped_fields1108[0] - self.pretty_monoid(field1109) + field1101 = unwrapped_fields1100[0] + self.pretty_monoid(field1101) self.newline() - field1110 = unwrapped_fields1108[1] - self.pretty_relation_id(field1110) + field1102 = unwrapped_fields1100[1] + self.pretty_relation_id(field1102) self.newline() - field1111 = unwrapped_fields1108[2] - self.pretty_abstraction_with_arity(field1111) - field1112 = unwrapped_fields1108[3] - if field1112 is not None: + field1103 = unwrapped_fields1100[2] + self.pretty_abstraction_with_arity(field1103) + field1104 = unwrapped_fields1100[3] + if field1104 is not None: self.newline() - assert field1112 is not None - opt_val1113 = field1112 - self.pretty_attrs(opt_val1113) + assert field1104 is not None + opt_val1105 = field1104 + self.pretty_attrs(opt_val1105) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1121 = self._try_flat(msg, self.pretty_constraint) - if flat1121 is not None: - assert flat1121 is not None - self.write(flat1121) + flat1113 = self._try_flat(msg, self.pretty_constraint) + if flat1113 is not None: + assert flat1113 is not None + self.write(flat1113) return None else: - def _t1620(_dollar_dollar): + def _t1604(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - _t1621 = _t1620(msg) - fields1115 = _t1621 - assert fields1115 is not None - unwrapped_fields1116 = fields1115 + _t1605 = _t1604(msg) + fields1107 = _t1605 + assert fields1107 is not None + unwrapped_fields1108 = fields1107 self.write("(") self.write("functional_dependency") self.indent_sexp() self.newline() - field1117 = unwrapped_fields1116[0] - self.pretty_relation_id(field1117) + field1109 = unwrapped_fields1108[0] + self.pretty_relation_id(field1109) self.newline() - field1118 = unwrapped_fields1116[1] - self.pretty_abstraction(field1118) + field1110 = unwrapped_fields1108[1] + self.pretty_abstraction(field1110) self.newline() - field1119 = unwrapped_fields1116[2] - self.pretty_functional_dependency_keys(field1119) + field1111 = unwrapped_fields1108[2] + self.pretty_functional_dependency_keys(field1111) self.newline() - field1120 = unwrapped_fields1116[3] - self.pretty_functional_dependency_values(field1120) + field1112 = unwrapped_fields1108[3] + self.pretty_functional_dependency_values(field1112) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1125 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1125 is not None: - assert flat1125 is not None - self.write(flat1125) + flat1117 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1117 is not None: + assert flat1117 is not None + self.write(flat1117) return None else: - fields1122 = msg + fields1114 = msg self.write("(") self.write("keys") self.indent_sexp() - if not len(fields1122) == 0: + if not len(fields1114) == 0: self.newline() - for i1124, elem1123 in enumerate(fields1122): - if (i1124 > 0): + for i1116, elem1115 in enumerate(fields1114): + if (i1116 > 0): self.newline() - self.pretty_var(elem1123) + self.pretty_var(elem1115) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1129 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1129 is not None: - assert flat1129 is not None - self.write(flat1129) + flat1121 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1121 is not None: + assert flat1121 is not None + self.write(flat1121) return None else: - fields1126 = msg + fields1118 = msg self.write("(") self.write("values") self.indent_sexp() - if not len(fields1126) == 0: + if not len(fields1118) == 0: self.newline() - for i1128, elem1127 in enumerate(fields1126): - if (i1128 > 0): + for i1120, elem1119 in enumerate(fields1118): + if (i1120 > 0): self.newline() - self.pretty_var(elem1127) + self.pretty_var(elem1119) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1136 = self._try_flat(msg, self.pretty_data) - if flat1136 is not None: - assert flat1136 is not None - self.write(flat1136) + flat1128 = self._try_flat(msg, self.pretty_data) + if flat1128 is not None: + assert flat1128 is not None + self.write(flat1128) return None else: - def _t1622(_dollar_dollar): - if _dollar_dollar.HasField("rel_edb"): - _t1623 = _dollar_dollar.rel_edb + def _t1606(_dollar_dollar): + if _dollar_dollar.HasField("edb"): + _t1607 = _dollar_dollar.edb else: - _t1623 = None - return _t1623 - _t1624 = _t1622(msg) - deconstruct_result1134 = _t1624 - if deconstruct_result1134 is not None: - assert deconstruct_result1134 is not None - unwrapped1135 = deconstruct_result1134 - self.pretty_rel_edb(unwrapped1135) + _t1607 = None + return _t1607 + _t1608 = _t1606(msg) + deconstruct_result1126 = _t1608 + if deconstruct_result1126 is not None: + assert deconstruct_result1126 is not None + unwrapped1127 = deconstruct_result1126 + self.pretty_edb(unwrapped1127) else: - def _t1625(_dollar_dollar): + def _t1609(_dollar_dollar): if _dollar_dollar.HasField("betree_relation"): - _t1626 = _dollar_dollar.betree_relation + _t1610 = _dollar_dollar.betree_relation else: - _t1626 = None - return _t1626 - _t1627 = _t1625(msg) - deconstruct_result1132 = _t1627 - if deconstruct_result1132 is not None: - assert deconstruct_result1132 is not None - unwrapped1133 = deconstruct_result1132 - self.pretty_betree_relation(unwrapped1133) + _t1610 = None + return _t1610 + _t1611 = _t1609(msg) + deconstruct_result1124 = _t1611 + if deconstruct_result1124 is not None: + assert deconstruct_result1124 is not None + unwrapped1125 = deconstruct_result1124 + self.pretty_betree_relation(unwrapped1125) else: - def _t1628(_dollar_dollar): + def _t1612(_dollar_dollar): if _dollar_dollar.HasField("csv_data"): - _t1629 = _dollar_dollar.csv_data + _t1613 = _dollar_dollar.csv_data else: - _t1629 = None - return _t1629 - _t1630 = _t1628(msg) - deconstruct_result1130 = _t1630 - if deconstruct_result1130 is not None: - assert deconstruct_result1130 is not None - unwrapped1131 = deconstruct_result1130 - self.pretty_csv_data(unwrapped1131) + _t1613 = None + return _t1613 + _t1614 = _t1612(msg) + deconstruct_result1122 = _t1614 + if deconstruct_result1122 is not None: + assert deconstruct_result1122 is not None + unwrapped1123 = deconstruct_result1122 + self.pretty_csv_data(unwrapped1123) else: raise ParseError("No matching rule for data") - def pretty_rel_edb(self, msg: logic_pb2.RelEDB): - flat1142 = self._try_flat(msg, self.pretty_rel_edb) - if flat1142 is not None: - assert flat1142 is not None - self.write(flat1142) + def pretty_edb(self, msg: logic_pb2.EDB): + flat1134 = self._try_flat(msg, self.pretty_edb) + if flat1134 is not None: + assert flat1134 is not None + self.write(flat1134) return None else: - def _t1631(_dollar_dollar): + def _t1615(_dollar_dollar): return (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - _t1632 = _t1631(msg) - fields1137 = _t1632 - assert fields1137 is not None - unwrapped_fields1138 = fields1137 + _t1616 = _t1615(msg) + fields1129 = _t1616 + assert fields1129 is not None + unwrapped_fields1130 = fields1129 self.write("(") - self.write("rel_edb") + self.write("edb") self.indent_sexp() self.newline() - field1139 = unwrapped_fields1138[0] - self.pretty_relation_id(field1139) + field1131 = unwrapped_fields1130[0] + self.pretty_relation_id(field1131) self.newline() - field1140 = unwrapped_fields1138[1] - self.pretty_rel_edb_path(field1140) + field1132 = unwrapped_fields1130[1] + self.pretty_edb_path(field1132) self.newline() - field1141 = unwrapped_fields1138[2] - self.pretty_rel_edb_types(field1141) + field1133 = unwrapped_fields1130[2] + self.pretty_edb_types(field1133) self.dedent() self.write(")") - def pretty_rel_edb_path(self, msg: Sequence[str]): - flat1146 = self._try_flat(msg, self.pretty_rel_edb_path) - if flat1146 is not None: - assert flat1146 is not None - self.write(flat1146) + def pretty_edb_path(self, msg: Sequence[str]): + flat1138 = self._try_flat(msg, self.pretty_edb_path) + if flat1138 is not None: + assert flat1138 is not None + self.write(flat1138) return None else: - fields1143 = msg + fields1135 = msg self.write("[") self.indent() - for i1145, elem1144 in enumerate(fields1143): - if (i1145 > 0): + for i1137, elem1136 in enumerate(fields1135): + if (i1137 > 0): self.newline() - self.write(self.format_string_value(elem1144)) + self.write(self.format_string_value(elem1136)) self.dedent() self.write("]") - def pretty_rel_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1150 = self._try_flat(msg, self.pretty_rel_edb_types) - if flat1150 is not None: - assert flat1150 is not None - self.write(flat1150) + def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): + flat1142 = self._try_flat(msg, self.pretty_edb_types) + if flat1142 is not None: + assert flat1142 is not None + self.write(flat1142) return None else: - fields1147 = msg + fields1139 = msg self.write("[") self.indent() - for i1149, elem1148 in enumerate(fields1147): - if (i1149 > 0): + for i1141, elem1140 in enumerate(fields1139): + if (i1141 > 0): self.newline() - self.pretty_type(elem1148) + self.pretty_type(elem1140) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1155 = self._try_flat(msg, self.pretty_betree_relation) - if flat1155 is not None: - assert flat1155 is not None - self.write(flat1155) + flat1147 = self._try_flat(msg, self.pretty_betree_relation) + if flat1147 is not None: + assert flat1147 is not None + self.write(flat1147) return None else: - def _t1633(_dollar_dollar): + def _t1617(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.relation_info,) - _t1634 = _t1633(msg) - fields1151 = _t1634 - assert fields1151 is not None - unwrapped_fields1152 = fields1151 + _t1618 = _t1617(msg) + fields1143 = _t1618 + assert fields1143 is not None + unwrapped_fields1144 = fields1143 self.write("(") self.write("betree_relation") self.indent_sexp() self.newline() - field1153 = unwrapped_fields1152[0] - self.pretty_relation_id(field1153) + field1145 = unwrapped_fields1144[0] + self.pretty_relation_id(field1145) self.newline() - field1154 = unwrapped_fields1152[1] - self.pretty_betree_info(field1154) + field1146 = unwrapped_fields1144[1] + self.pretty_betree_info(field1146) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1161 = self._try_flat(msg, self.pretty_betree_info) - if flat1161 is not None: - assert flat1161 is not None - self.write(flat1161) + flat1153 = self._try_flat(msg, self.pretty_betree_info) + if flat1153 is not None: + assert flat1153 is not None + self.write(flat1153) return None else: - def _t1635(_dollar_dollar): - _t1636 = self.deconstruct_betree_info_config(_dollar_dollar) - return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1636,) - _t1637 = _t1635(msg) - fields1156 = _t1637 - assert fields1156 is not None - unwrapped_fields1157 = fields1156 + def _t1619(_dollar_dollar): + _t1620 = self.deconstruct_betree_info_config(_dollar_dollar) + return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1620,) + _t1621 = _t1619(msg) + fields1148 = _t1621 + assert fields1148 is not None + unwrapped_fields1149 = fields1148 self.write("(") self.write("betree_info") self.indent_sexp() self.newline() - field1158 = unwrapped_fields1157[0] - self.pretty_betree_info_key_types(field1158) + field1150 = unwrapped_fields1149[0] + self.pretty_betree_info_key_types(field1150) self.newline() - field1159 = unwrapped_fields1157[1] - self.pretty_betree_info_value_types(field1159) + field1151 = unwrapped_fields1149[1] + self.pretty_betree_info_value_types(field1151) self.newline() - field1160 = unwrapped_fields1157[2] - self.pretty_config_dict(field1160) + field1152 = unwrapped_fields1149[2] + self.pretty_config_dict(field1152) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1165 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1165 is not None: - assert flat1165 is not None - self.write(flat1165) + flat1157 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1157 is not None: + assert flat1157 is not None + self.write(flat1157) return None else: - fields1162 = msg + fields1154 = msg self.write("(") self.write("key_types") self.indent_sexp() - if not len(fields1162) == 0: + if not len(fields1154) == 0: self.newline() - for i1164, elem1163 in enumerate(fields1162): - if (i1164 > 0): + for i1156, elem1155 in enumerate(fields1154): + if (i1156 > 0): self.newline() - self.pretty_type(elem1163) + self.pretty_type(elem1155) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1169 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1169 is not None: - assert flat1169 is not None - self.write(flat1169) + flat1161 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1161 is not None: + assert flat1161 is not None + self.write(flat1161) return None else: - fields1166 = msg + fields1158 = msg self.write("(") self.write("value_types") self.indent_sexp() - if not len(fields1166) == 0: + if not len(fields1158) == 0: self.newline() - for i1168, elem1167 in enumerate(fields1166): - if (i1168 > 0): + for i1160, elem1159 in enumerate(fields1158): + if (i1160 > 0): self.newline() - self.pretty_type(elem1167) + self.pretty_type(elem1159) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1176 = self._try_flat(msg, self.pretty_csv_data) - if flat1176 is not None: - assert flat1176 is not None - self.write(flat1176) + flat1168 = self._try_flat(msg, self.pretty_csv_data) + if flat1168 is not None: + assert flat1168 is not None + self.write(flat1168) return None else: - def _t1638(_dollar_dollar): + def _t1622(_dollar_dollar): return (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - _t1639 = _t1638(msg) - fields1170 = _t1639 - assert fields1170 is not None - unwrapped_fields1171 = fields1170 + _t1623 = _t1622(msg) + fields1162 = _t1623 + assert fields1162 is not None + unwrapped_fields1163 = fields1162 self.write("(") self.write("csv_data") self.indent_sexp() self.newline() - field1172 = unwrapped_fields1171[0] - self.pretty_csvlocator(field1172) + field1164 = unwrapped_fields1163[0] + self.pretty_csvlocator(field1164) self.newline() - field1173 = unwrapped_fields1171[1] - self.pretty_csv_config(field1173) + field1165 = unwrapped_fields1163[1] + self.pretty_csv_config(field1165) self.newline() - field1174 = unwrapped_fields1171[2] - self.pretty_csv_columns(field1174) + field1166 = unwrapped_fields1163[2] + self.pretty_gnf_columns(field1166) self.newline() - field1175 = unwrapped_fields1171[3] - self.pretty_csv_asof(field1175) + field1167 = unwrapped_fields1163[3] + self.pretty_csv_asof(field1167) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1183 = self._try_flat(msg, self.pretty_csvlocator) - if flat1183 is not None: - assert flat1183 is not None - self.write(flat1183) + flat1175 = self._try_flat(msg, self.pretty_csvlocator) + if flat1175 is not None: + assert flat1175 is not None + self.write(flat1175) return None else: - def _t1640(_dollar_dollar): + def _t1624(_dollar_dollar): if not len(_dollar_dollar.paths) == 0: - _t1641 = _dollar_dollar.paths + _t1625 = _dollar_dollar.paths else: - _t1641 = None + _t1625 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1642 = _dollar_dollar.inline_data.decode('utf-8') + _t1626 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1642 = None - return (_t1641, _t1642,) - _t1643 = _t1640(msg) - fields1177 = _t1643 - assert fields1177 is not None - unwrapped_fields1178 = fields1177 + _t1626 = None + return (_t1625, _t1626,) + _t1627 = _t1624(msg) + fields1169 = _t1627 + assert fields1169 is not None + unwrapped_fields1170 = fields1169 self.write("(") self.write("csv_locator") self.indent_sexp() - field1179 = unwrapped_fields1178[0] - if field1179 is not None: + field1171 = unwrapped_fields1170[0] + if field1171 is not None: self.newline() - assert field1179 is not None - opt_val1180 = field1179 - self.pretty_csv_locator_paths(opt_val1180) - field1181 = unwrapped_fields1178[1] - if field1181 is not None: + assert field1171 is not None + opt_val1172 = field1171 + self.pretty_csv_locator_paths(opt_val1172) + field1173 = unwrapped_fields1170[1] + if field1173 is not None: self.newline() - assert field1181 is not None - opt_val1182 = field1181 - self.pretty_csv_locator_inline_data(opt_val1182) + assert field1173 is not None + opt_val1174 = field1173 + self.pretty_csv_locator_inline_data(opt_val1174) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1187 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1187 is not None: - assert flat1187 is not None - self.write(flat1187) + flat1179 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1179 is not None: + assert flat1179 is not None + self.write(flat1179) return None else: - fields1184 = msg + fields1176 = msg self.write("(") self.write("paths") self.indent_sexp() - if not len(fields1184) == 0: + if not len(fields1176) == 0: self.newline() - for i1186, elem1185 in enumerate(fields1184): - if (i1186 > 0): + for i1178, elem1177 in enumerate(fields1176): + if (i1178 > 0): self.newline() - self.write(self.format_string_value(elem1185)) + self.write(self.format_string_value(elem1177)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1189 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1189 is not None: - assert flat1189 is not None - self.write(flat1189) + flat1181 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1181 is not None: + assert flat1181 is not None + self.write(flat1181) return None else: - fields1188 = msg + fields1180 = msg self.write("(") self.write("inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1188)) + self.write(self.format_string_value(fields1180)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1192 = self._try_flat(msg, self.pretty_csv_config) - if flat1192 is not None: - assert flat1192 is not None - self.write(flat1192) + flat1184 = self._try_flat(msg, self.pretty_csv_config) + if flat1184 is not None: + assert flat1184 is not None + self.write(flat1184) return None else: - def _t1644(_dollar_dollar): - _t1645 = self.deconstruct_csv_config(_dollar_dollar) - return _t1645 - _t1646 = _t1644(msg) - fields1190 = _t1646 - assert fields1190 is not None - unwrapped_fields1191 = fields1190 + def _t1628(_dollar_dollar): + _t1629 = self.deconstruct_csv_config(_dollar_dollar) + return _t1629 + _t1630 = _t1628(msg) + fields1182 = _t1630 + assert fields1182 is not None + unwrapped_fields1183 = fields1182 self.write("(") self.write("csv_config") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields1191) + self.pretty_config_dict(unwrapped_fields1183) self.dedent() self.write(")") - def pretty_csv_columns(self, msg: Sequence[logic_pb2.CSVColumn]): - flat1196 = self._try_flat(msg, self.pretty_csv_columns) - if flat1196 is not None: - assert flat1196 is not None - self.write(flat1196) + def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): + flat1188 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1188 is not None: + assert flat1188 is not None + self.write(flat1188) return None else: - fields1193 = msg + fields1185 = msg self.write("(") self.write("columns") self.indent_sexp() - if not len(fields1193) == 0: + if not len(fields1185) == 0: self.newline() - for i1195, elem1194 in enumerate(fields1193): - if (i1195 > 0): + for i1187, elem1186 in enumerate(fields1185): + if (i1187 > 0): self.newline() - self.pretty_csv_column(elem1194) + self.pretty_gnf_column(elem1186) self.dedent() self.write(")") - def pretty_csv_column(self, msg: logic_pb2.CSVColumn): - flat1202 = self._try_flat(msg, self.pretty_csv_column) - if flat1202 is not None: - assert flat1202 is not None - self.write(flat1202) + def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): + flat1197 = self._try_flat(msg, self.pretty_gnf_column) + if flat1197 is not None: + assert flat1197 is not None + self.write(flat1197) return None else: - def _t1647(_dollar_dollar): - _t1648 = self.deconstruct_csv_column_tail(_dollar_dollar) - return (_dollar_dollar.column_path, _t1648,) - _t1649 = _t1647(msg) - fields1197 = _t1649 - assert fields1197 is not None - unwrapped_fields1198 = fields1197 + def _t1631(_dollar_dollar): + if _dollar_dollar.HasField("target_id"): + _t1632 = _dollar_dollar.target_id + else: + _t1632 = None + return (_dollar_dollar.column_path, _t1632, _dollar_dollar.types,) + _t1633 = _t1631(msg) + fields1189 = _t1633 + assert fields1189 is not None + unwrapped_fields1190 = fields1189 self.write("(") self.write("column") self.indent_sexp() self.newline() - field1199 = unwrapped_fields1198[0] - self.pretty_csv_column_path(field1199) - field1200 = unwrapped_fields1198[1] - if field1200 is not None: + field1191 = unwrapped_fields1190[0] + self.pretty_gnf_column_path(field1191) + field1192 = unwrapped_fields1190[1] + if field1192 is not None: self.newline() - assert field1200 is not None - opt_val1201 = field1200 - self.pretty_csv_column_tail(opt_val1201) + assert field1192 is not None + opt_val1193 = field1192 + self.pretty_relation_id(opt_val1193) + self.newline() + self.write("[") + field1194 = unwrapped_fields1190[2] + for i1196, elem1195 in enumerate(field1194): + if (i1196 > 0): + self.newline() + self.pretty_type(elem1195) + self.write("]") self.dedent() self.write(")") - def pretty_csv_column_path(self, msg: Sequence[str]): - flat1209 = self._try_flat(msg, self.pretty_csv_column_path) - if flat1209 is not None: - assert flat1209 is not None - self.write(flat1209) + def pretty_gnf_column_path(self, msg: Sequence[str]): + flat1204 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1204 is not None: + assert flat1204 is not None + self.write(flat1204) return None else: - def _t1650(_dollar_dollar): + def _t1634(_dollar_dollar): if len(_dollar_dollar) == 1: - _t1651 = _dollar_dollar[0] + _t1635 = _dollar_dollar[0] else: - _t1651 = None - return _t1651 - _t1652 = _t1650(msg) - deconstruct_result1207 = _t1652 - if deconstruct_result1207 is not None: - assert deconstruct_result1207 is not None - unwrapped1208 = deconstruct_result1207 - self.write(self.format_string_value(unwrapped1208)) + _t1635 = None + return _t1635 + _t1636 = _t1634(msg) + deconstruct_result1202 = _t1636 + if deconstruct_result1202 is not None: + assert deconstruct_result1202 is not None + unwrapped1203 = deconstruct_result1202 + self.write(self.format_string_value(unwrapped1203)) else: - def _t1653(_dollar_dollar): + def _t1637(_dollar_dollar): if len(_dollar_dollar) != 1: - _t1654 = _dollar_dollar + _t1638 = _dollar_dollar else: - _t1654 = None - return _t1654 - _t1655 = _t1653(msg) - deconstruct_result1203 = _t1655 - if deconstruct_result1203 is not None: - assert deconstruct_result1203 is not None - unwrapped1204 = deconstruct_result1203 + _t1638 = None + return _t1638 + _t1639 = _t1637(msg) + deconstruct_result1198 = _t1639 + if deconstruct_result1198 is not None: + assert deconstruct_result1198 is not None + unwrapped1199 = deconstruct_result1198 self.write("[") self.indent() - for i1206, elem1205 in enumerate(unwrapped1204): - if (i1206 > 0): + for i1201, elem1200 in enumerate(unwrapped1199): + if (i1201 > 0): self.newline() - self.write(self.format_string_value(elem1205)) + self.write(self.format_string_value(elem1200)) self.dedent() self.write("]") else: - raise ParseError("No matching rule for csv_column_path") - - def pretty_csv_column_tail(self, msg: tuple[Optional[logic_pb2.RelationId], Sequence[logic_pb2.Type]]): - flat1220 = self._try_flat(msg, self.pretty_csv_column_tail) - if flat1220 is not None: - assert flat1220 is not None - self.write(flat1220) - return None - else: - def _t1656(_dollar_dollar): - if _dollar_dollar[0] is not None: - _t1657 = (_dollar_dollar[0], _dollar_dollar[1],) - else: - _t1657 = None - return _t1657 - _t1658 = _t1656(msg) - deconstruct_result1214 = _t1658 - if deconstruct_result1214 is not None: - assert deconstruct_result1214 is not None - unwrapped1215 = deconstruct_result1214 - field1216 = unwrapped1215[0] - self.pretty_relation_id(field1216) - self.write(" ") - self.write("[") - field1217 = unwrapped1215[1] - for i1219, elem1218 in enumerate(field1217): - if (i1219 > 0): - self.newline() - self.pretty_type(elem1218) - self.write("]") - else: - def _t1659(_dollar_dollar): - return _dollar_dollar[1] - _t1660 = _t1659(msg) - fields1210 = _t1660 - assert fields1210 is not None - unwrapped_fields1211 = fields1210 - self.write("[") - self.indent() - for i1213, elem1212 in enumerate(unwrapped_fields1211): - if (i1213 > 0): - self.newline() - self.pretty_type(elem1212) - self.dedent() - self.write("]") + raise ParseError("No matching rule for gnf_column_path") def pretty_csv_asof(self, msg: str): - flat1222 = self._try_flat(msg, self.pretty_csv_asof) - if flat1222 is not None: - assert flat1222 is not None - self.write(flat1222) + flat1206 = self._try_flat(msg, self.pretty_csv_asof) + if flat1206 is not None: + assert flat1206 is not None + self.write(flat1206) return None else: - fields1221 = msg + fields1205 = msg self.write("(") self.write("asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1221)) + self.write(self.format_string_value(fields1205)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1225 = self._try_flat(msg, self.pretty_undefine) - if flat1225 is not None: - assert flat1225 is not None - self.write(flat1225) + flat1209 = self._try_flat(msg, self.pretty_undefine) + if flat1209 is not None: + assert flat1209 is not None + self.write(flat1209) return None else: - def _t1661(_dollar_dollar): + def _t1640(_dollar_dollar): return _dollar_dollar.fragment_id - _t1662 = _t1661(msg) - fields1223 = _t1662 - assert fields1223 is not None - unwrapped_fields1224 = fields1223 + _t1641 = _t1640(msg) + fields1207 = _t1641 + assert fields1207 is not None + unwrapped_fields1208 = fields1207 self.write("(") self.write("undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1224) + self.pretty_fragment_id(unwrapped_fields1208) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1230 = self._try_flat(msg, self.pretty_context) - if flat1230 is not None: - assert flat1230 is not None - self.write(flat1230) + flat1214 = self._try_flat(msg, self.pretty_context) + if flat1214 is not None: + assert flat1214 is not None + self.write(flat1214) return None else: - def _t1663(_dollar_dollar): + def _t1642(_dollar_dollar): return _dollar_dollar.relations - _t1664 = _t1663(msg) - fields1226 = _t1664 - assert fields1226 is not None - unwrapped_fields1227 = fields1226 + _t1643 = _t1642(msg) + fields1210 = _t1643 + assert fields1210 is not None + unwrapped_fields1211 = fields1210 self.write("(") self.write("context") self.indent_sexp() - if not len(unwrapped_fields1227) == 0: + if not len(unwrapped_fields1211) == 0: self.newline() - for i1229, elem1228 in enumerate(unwrapped_fields1227): - if (i1229 > 0): + for i1213, elem1212 in enumerate(unwrapped_fields1211): + if (i1213 > 0): self.newline() - self.pretty_relation_id(elem1228) + self.pretty_relation_id(elem1212) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1235 = self._try_flat(msg, self.pretty_snapshot) - if flat1235 is not None: - assert flat1235 is not None - self.write(flat1235) + flat1219 = self._try_flat(msg, self.pretty_snapshot) + if flat1219 is not None: + assert flat1219 is not None + self.write(flat1219) return None else: - def _t1665(_dollar_dollar): + def _t1644(_dollar_dollar): return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - _t1666 = _t1665(msg) - fields1231 = _t1666 - assert fields1231 is not None - unwrapped_fields1232 = fields1231 + _t1645 = _t1644(msg) + fields1215 = _t1645 + assert fields1215 is not None + unwrapped_fields1216 = fields1215 self.write("(") self.write("snapshot") self.indent_sexp() self.newline() - field1233 = unwrapped_fields1232[0] - self.pretty_rel_edb_path(field1233) + field1217 = unwrapped_fields1216[0] + self.pretty_edb_path(field1217) self.newline() - field1234 = unwrapped_fields1232[1] - self.pretty_relation_id(field1234) + field1218 = unwrapped_fields1216[1] + self.pretty_relation_id(field1218) self.dedent() self.write(")") def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1239 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1239 is not None: - assert flat1239 is not None - self.write(flat1239) + flat1223 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1223 is not None: + assert flat1223 is not None + self.write(flat1223) return None else: - fields1236 = msg + fields1220 = msg self.write("(") self.write("reads") self.indent_sexp() - if not len(fields1236) == 0: + if not len(fields1220) == 0: self.newline() - for i1238, elem1237 in enumerate(fields1236): - if (i1238 > 0): + for i1222, elem1221 in enumerate(fields1220): + if (i1222 > 0): self.newline() - self.pretty_read(elem1237) + self.pretty_read(elem1221) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1250 = self._try_flat(msg, self.pretty_read) - if flat1250 is not None: - assert flat1250 is not None - self.write(flat1250) + flat1234 = self._try_flat(msg, self.pretty_read) + if flat1234 is not None: + assert flat1234 is not None + self.write(flat1234) return None else: - def _t1667(_dollar_dollar): + def _t1646(_dollar_dollar): if _dollar_dollar.HasField("demand"): - _t1668 = _dollar_dollar.demand + _t1647 = _dollar_dollar.demand else: - _t1668 = None - return _t1668 - _t1669 = _t1667(msg) - deconstruct_result1248 = _t1669 - if deconstruct_result1248 is not None: - assert deconstruct_result1248 is not None - unwrapped1249 = deconstruct_result1248 - self.pretty_demand(unwrapped1249) + _t1647 = None + return _t1647 + _t1648 = _t1646(msg) + deconstruct_result1232 = _t1648 + if deconstruct_result1232 is not None: + assert deconstruct_result1232 is not None + unwrapped1233 = deconstruct_result1232 + self.pretty_demand(unwrapped1233) else: - def _t1670(_dollar_dollar): + def _t1649(_dollar_dollar): if _dollar_dollar.HasField("output"): - _t1671 = _dollar_dollar.output + _t1650 = _dollar_dollar.output else: - _t1671 = None - return _t1671 - _t1672 = _t1670(msg) - deconstruct_result1246 = _t1672 - if deconstruct_result1246 is not None: - assert deconstruct_result1246 is not None - unwrapped1247 = deconstruct_result1246 - self.pretty_output(unwrapped1247) + _t1650 = None + return _t1650 + _t1651 = _t1649(msg) + deconstruct_result1230 = _t1651 + if deconstruct_result1230 is not None: + assert deconstruct_result1230 is not None + unwrapped1231 = deconstruct_result1230 + self.pretty_output(unwrapped1231) else: - def _t1673(_dollar_dollar): + def _t1652(_dollar_dollar): if _dollar_dollar.HasField("what_if"): - _t1674 = _dollar_dollar.what_if + _t1653 = _dollar_dollar.what_if else: - _t1674 = None - return _t1674 - _t1675 = _t1673(msg) - deconstruct_result1244 = _t1675 - if deconstruct_result1244 is not None: - assert deconstruct_result1244 is not None - unwrapped1245 = deconstruct_result1244 - self.pretty_what_if(unwrapped1245) + _t1653 = None + return _t1653 + _t1654 = _t1652(msg) + deconstruct_result1228 = _t1654 + if deconstruct_result1228 is not None: + assert deconstruct_result1228 is not None + unwrapped1229 = deconstruct_result1228 + self.pretty_what_if(unwrapped1229) else: - def _t1676(_dollar_dollar): + def _t1655(_dollar_dollar): if _dollar_dollar.HasField("abort"): - _t1677 = _dollar_dollar.abort + _t1656 = _dollar_dollar.abort else: - _t1677 = None - return _t1677 - _t1678 = _t1676(msg) - deconstruct_result1242 = _t1678 - if deconstruct_result1242 is not None: - assert deconstruct_result1242 is not None - unwrapped1243 = deconstruct_result1242 - self.pretty_abort(unwrapped1243) + _t1656 = None + return _t1656 + _t1657 = _t1655(msg) + deconstruct_result1226 = _t1657 + if deconstruct_result1226 is not None: + assert deconstruct_result1226 is not None + unwrapped1227 = deconstruct_result1226 + self.pretty_abort(unwrapped1227) else: - def _t1679(_dollar_dollar): + def _t1658(_dollar_dollar): if _dollar_dollar.HasField("export"): - _t1680 = _dollar_dollar.export + _t1659 = _dollar_dollar.export else: - _t1680 = None - return _t1680 - _t1681 = _t1679(msg) - deconstruct_result1240 = _t1681 - if deconstruct_result1240 is not None: - assert deconstruct_result1240 is not None - unwrapped1241 = deconstruct_result1240 - self.pretty_export(unwrapped1241) + _t1659 = None + return _t1659 + _t1660 = _t1658(msg) + deconstruct_result1224 = _t1660 + if deconstruct_result1224 is not None: + assert deconstruct_result1224 is not None + unwrapped1225 = deconstruct_result1224 + self.pretty_export(unwrapped1225) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1253 = self._try_flat(msg, self.pretty_demand) - if flat1253 is not None: - assert flat1253 is not None - self.write(flat1253) + flat1237 = self._try_flat(msg, self.pretty_demand) + if flat1237 is not None: + assert flat1237 is not None + self.write(flat1237) return None else: - def _t1682(_dollar_dollar): + def _t1661(_dollar_dollar): return _dollar_dollar.relation_id - _t1683 = _t1682(msg) - fields1251 = _t1683 - assert fields1251 is not None - unwrapped_fields1252 = fields1251 + _t1662 = _t1661(msg) + fields1235 = _t1662 + assert fields1235 is not None + unwrapped_fields1236 = fields1235 self.write("(") self.write("demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1252) + self.pretty_relation_id(unwrapped_fields1236) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1258 = self._try_flat(msg, self.pretty_output) - if flat1258 is not None: - assert flat1258 is not None - self.write(flat1258) + flat1242 = self._try_flat(msg, self.pretty_output) + if flat1242 is not None: + assert flat1242 is not None + self.write(flat1242) return None else: - def _t1684(_dollar_dollar): + def _t1663(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.relation_id,) - _t1685 = _t1684(msg) - fields1254 = _t1685 - assert fields1254 is not None - unwrapped_fields1255 = fields1254 + _t1664 = _t1663(msg) + fields1238 = _t1664 + assert fields1238 is not None + unwrapped_fields1239 = fields1238 self.write("(") self.write("output") self.indent_sexp() self.newline() - field1256 = unwrapped_fields1255[0] - self.pretty_name(field1256) + field1240 = unwrapped_fields1239[0] + self.pretty_name(field1240) self.newline() - field1257 = unwrapped_fields1255[1] - self.pretty_relation_id(field1257) + field1241 = unwrapped_fields1239[1] + self.pretty_relation_id(field1241) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1263 = self._try_flat(msg, self.pretty_what_if) - if flat1263 is not None: - assert flat1263 is not None - self.write(flat1263) + flat1247 = self._try_flat(msg, self.pretty_what_if) + if flat1247 is not None: + assert flat1247 is not None + self.write(flat1247) return None else: - def _t1686(_dollar_dollar): + def _t1665(_dollar_dollar): return (_dollar_dollar.branch, _dollar_dollar.epoch,) - _t1687 = _t1686(msg) - fields1259 = _t1687 - assert fields1259 is not None - unwrapped_fields1260 = fields1259 + _t1666 = _t1665(msg) + fields1243 = _t1666 + assert fields1243 is not None + unwrapped_fields1244 = fields1243 self.write("(") self.write("what_if") self.indent_sexp() self.newline() - field1261 = unwrapped_fields1260[0] - self.pretty_name(field1261) + field1245 = unwrapped_fields1244[0] + self.pretty_name(field1245) self.newline() - field1262 = unwrapped_fields1260[1] - self.pretty_epoch(field1262) + field1246 = unwrapped_fields1244[1] + self.pretty_epoch(field1246) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1269 = self._try_flat(msg, self.pretty_abort) - if flat1269 is not None: - assert flat1269 is not None - self.write(flat1269) + flat1253 = self._try_flat(msg, self.pretty_abort) + if flat1253 is not None: + assert flat1253 is not None + self.write(flat1253) return None else: - def _t1688(_dollar_dollar): + def _t1667(_dollar_dollar): if _dollar_dollar.name != "abort": - _t1689 = _dollar_dollar.name + _t1668 = _dollar_dollar.name else: - _t1689 = None - return (_t1689, _dollar_dollar.relation_id,) - _t1690 = _t1688(msg) - fields1264 = _t1690 - assert fields1264 is not None - unwrapped_fields1265 = fields1264 + _t1668 = None + return (_t1668, _dollar_dollar.relation_id,) + _t1669 = _t1667(msg) + fields1248 = _t1669 + assert fields1248 is not None + unwrapped_fields1249 = fields1248 self.write("(") self.write("abort") self.indent_sexp() - field1266 = unwrapped_fields1265[0] - if field1266 is not None: + field1250 = unwrapped_fields1249[0] + if field1250 is not None: self.newline() - assert field1266 is not None - opt_val1267 = field1266 - self.pretty_name(opt_val1267) + assert field1250 is not None + opt_val1251 = field1250 + self.pretty_name(opt_val1251) self.newline() - field1268 = unwrapped_fields1265[1] - self.pretty_relation_id(field1268) + field1252 = unwrapped_fields1249[1] + self.pretty_relation_id(field1252) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1272 = self._try_flat(msg, self.pretty_export) - if flat1272 is not None: - assert flat1272 is not None - self.write(flat1272) + flat1256 = self._try_flat(msg, self.pretty_export) + if flat1256 is not None: + assert flat1256 is not None + self.write(flat1256) return None else: - def _t1691(_dollar_dollar): + def _t1670(_dollar_dollar): return _dollar_dollar.csv_config - _t1692 = _t1691(msg) - fields1270 = _t1692 - assert fields1270 is not None - unwrapped_fields1271 = fields1270 + _t1671 = _t1670(msg) + fields1254 = _t1671 + assert fields1254 is not None + unwrapped_fields1255 = fields1254 self.write("(") self.write("export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped_fields1271) + self.pretty_export_csv_config(unwrapped_fields1255) self.dedent() self.write(")") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1278 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1278 is not None: - assert flat1278 is not None - self.write(flat1278) + flat1262 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1262 is not None: + assert flat1262 is not None + self.write(flat1262) return None else: - def _t1693(_dollar_dollar): - _t1694 = self.deconstruct_export_csv_config(_dollar_dollar) - return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1694,) - _t1695 = _t1693(msg) - fields1273 = _t1695 - assert fields1273 is not None - unwrapped_fields1274 = fields1273 + def _t1672(_dollar_dollar): + _t1673 = self.deconstruct_export_csv_config(_dollar_dollar) + return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1673,) + _t1674 = _t1672(msg) + fields1257 = _t1674 + assert fields1257 is not None + unwrapped_fields1258 = fields1257 self.write("(") self.write("export_csv_config") self.indent_sexp() self.newline() - field1275 = unwrapped_fields1274[0] - self.pretty_export_csv_path(field1275) + field1259 = unwrapped_fields1258[0] + self.pretty_export_csv_path(field1259) self.newline() - field1276 = unwrapped_fields1274[1] - self.pretty_export_csv_columns(field1276) + field1260 = unwrapped_fields1258[1] + self.pretty_export_csv_columns(field1260) self.newline() - field1277 = unwrapped_fields1274[2] - self.pretty_config_dict(field1277) + field1261 = unwrapped_fields1258[2] + self.pretty_config_dict(field1261) self.dedent() self.write(")") def pretty_export_csv_path(self, msg: str): - flat1280 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1280 is not None: - assert flat1280 is not None - self.write(flat1280) + flat1264 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1264 is not None: + assert flat1264 is not None + self.write(flat1264) return None else: - fields1279 = msg + fields1263 = msg self.write("(") self.write("path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1279)) + self.write(self.format_string_value(fields1263)) self.dedent() self.write(")") def pretty_export_csv_columns(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1284 = self._try_flat(msg, self.pretty_export_csv_columns) - if flat1284 is not None: - assert flat1284 is not None - self.write(flat1284) + flat1268 = self._try_flat(msg, self.pretty_export_csv_columns) + if flat1268 is not None: + assert flat1268 is not None + self.write(flat1268) return None else: - fields1281 = msg + fields1265 = msg self.write("(") self.write("columns") self.indent_sexp() - if not len(fields1281) == 0: + if not len(fields1265) == 0: self.newline() - for i1283, elem1282 in enumerate(fields1281): - if (i1283 > 0): + for i1267, elem1266 in enumerate(fields1265): + if (i1267 > 0): self.newline() - self.pretty_export_csv_column(elem1282) + self.pretty_export_csv_column(elem1266) self.dedent() self.write(")") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1289 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1289 is not None: - assert flat1289 is not None - self.write(flat1289) + flat1273 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1273 is not None: + assert flat1273 is not None + self.write(flat1273) return None else: - def _t1696(_dollar_dollar): + def _t1675(_dollar_dollar): return (_dollar_dollar.column_name, _dollar_dollar.column_data,) - _t1697 = _t1696(msg) - fields1285 = _t1697 - assert fields1285 is not None - unwrapped_fields1286 = fields1285 + _t1676 = _t1675(msg) + fields1269 = _t1676 + assert fields1269 is not None + unwrapped_fields1270 = fields1269 self.write("(") self.write("column") self.indent_sexp() self.newline() - field1287 = unwrapped_fields1286[0] - self.write(self.format_string_value(field1287)) + field1271 = unwrapped_fields1270[0] + self.write(self.format_string_value(field1271)) self.newline() - field1288 = unwrapped_fields1286[1] - self.pretty_relation_id(field1288) + field1272 = unwrapped_fields1270[1] + self.pretty_relation_id(field1272) self.dedent() self.write(")") @@ -3893,8 +3853,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1736 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1736) + _t1714 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1714) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") @@ -4132,8 +4092,8 @@ def pprint_dispatch(self, msg): self.pretty_constraint(msg) elif isinstance(msg, logic_pb2.Data): self.pretty_data(msg) - elif isinstance(msg, logic_pb2.RelEDB): - self.pretty_rel_edb(msg) + elif isinstance(msg, logic_pb2.EDB): + self.pretty_edb(msg) elif isinstance(msg, logic_pb2.BeTreeRelation): self.pretty_betree_relation(msg) elif isinstance(msg, logic_pb2.BeTreeInfo): @@ -4144,8 +4104,8 @@ def pprint_dispatch(self, msg): self.pretty_csvlocator(msg) elif isinstance(msg, logic_pb2.CSVConfig): self.pretty_csv_config(msg) - elif isinstance(msg, logic_pb2.CSVColumn): - self.pretty_csv_column(msg) + elif isinstance(msg, logic_pb2.GNFColumn): + self.pretty_gnf_column(msg) elif isinstance(msg, transactions_pb2.Undefine): self.pretty_undefine(msg) elif isinstance(msg, transactions_pb2.Context): diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.py b/sdks/python/src/lqp/proto/v1/logic_pb2.py index b19672d5..74019ce3 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.py +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.py @@ -14,7 +14,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\"u\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\"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\"m\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\"\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\"\xd6\x01\n\x04\x44\x61ta\x12\x36\n\x07rel_edb\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.RelEDBH\x00R\x06relEdb\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\x63svDataB\x0b\n\tdata_type\"\x8b\x01\n\x06RelEDB\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\"\xca\x01\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.CSVColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\xe3\x02\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\"\xae\x01\n\tCSVColumn\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\"\x89\x06\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\x62ooleanTypeB\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\"\xd1\x04\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\x62ooleanValueB\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\"u\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\"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\"m\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\"\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\"\xcc\x01\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\x63svDataB\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\"\xca\x01\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\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\xe3\x02\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\"\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\"\x89\x06\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\x62ooleanTypeB\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\"\xd1\x04\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\x62ooleanValueB\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) @@ -97,63 +97,63 @@ _globals['_ATTRIBUTE']._serialized_start=5346 _globals['_ATTRIBUTE']._serialized_end=5425 _globals['_DATA']._serialized_start=5428 - _globals['_DATA']._serialized_end=5642 - _globals['_RELEDB']._serialized_start=5645 - _globals['_RELEDB']._serialized_end=5784 - _globals['_BETREERELATION']._serialized_start=5787 - _globals['_BETREERELATION']._serialized_end=5926 - _globals['_BETREEINFO']._serialized_start=5929 - _globals['_BETREEINFO']._serialized_end=6216 - _globals['_BETREECONFIG']._serialized_start=6219 - _globals['_BETREECONFIG']._serialized_end=6348 - _globals['_BETREELOCATOR']._serialized_start=6351 - _globals['_BETREELOCATOR']._serialized_end=6553 - _globals['_CSVDATA']._serialized_start=6556 - _globals['_CSVDATA']._serialized_end=6758 - _globals['_CSVLOCATOR']._serialized_start=6760 - _globals['_CSVLOCATOR']._serialized_end=6827 - _globals['_CSVCONFIG']._serialized_start=6830 - _globals['_CSVCONFIG']._serialized_end=7185 - _globals['_CSVCOLUMN']._serialized_start=7188 - _globals['_CSVCOLUMN']._serialized_end=7362 - _globals['_RELATIONID']._serialized_start=7364 - _globals['_RELATIONID']._serialized_end=7424 - _globals['_TYPE']._serialized_start=7427 - _globals['_TYPE']._serialized_end=8204 - _globals['_UNSPECIFIEDTYPE']._serialized_start=8206 - _globals['_UNSPECIFIEDTYPE']._serialized_end=8223 - _globals['_STRINGTYPE']._serialized_start=8225 - _globals['_STRINGTYPE']._serialized_end=8237 - _globals['_INTTYPE']._serialized_start=8239 - _globals['_INTTYPE']._serialized_end=8248 - _globals['_FLOATTYPE']._serialized_start=8250 - _globals['_FLOATTYPE']._serialized_end=8261 - _globals['_UINT128TYPE']._serialized_start=8263 - _globals['_UINT128TYPE']._serialized_end=8276 - _globals['_INT128TYPE']._serialized_start=8278 - _globals['_INT128TYPE']._serialized_end=8290 - _globals['_DATETYPE']._serialized_start=8292 - _globals['_DATETYPE']._serialized_end=8302 - _globals['_DATETIMETYPE']._serialized_start=8304 - _globals['_DATETIMETYPE']._serialized_end=8318 - _globals['_MISSINGTYPE']._serialized_start=8320 - _globals['_MISSINGTYPE']._serialized_end=8333 - _globals['_DECIMALTYPE']._serialized_start=8335 - _globals['_DECIMALTYPE']._serialized_end=8400 - _globals['_BOOLEANTYPE']._serialized_start=8402 - _globals['_BOOLEANTYPE']._serialized_end=8415 - _globals['_VALUE']._serialized_start=8418 - _globals['_VALUE']._serialized_end=9011 - _globals['_UINT128VALUE']._serialized_start=9013 - _globals['_UINT128VALUE']._serialized_end=9065 - _globals['_INT128VALUE']._serialized_start=9067 - _globals['_INT128VALUE']._serialized_end=9118 - _globals['_MISSINGVALUE']._serialized_start=9120 - _globals['_MISSINGVALUE']._serialized_end=9134 - _globals['_DATEVALUE']._serialized_start=9136 - _globals['_DATEVALUE']._serialized_end=9207 - _globals['_DATETIMEVALUE']._serialized_start=9210 - _globals['_DATETIMEVALUE']._serialized_end=9387 - _globals['_DECIMALVALUE']._serialized_start=9389 - _globals['_DECIMALVALUE']._serialized_end=9511 + _globals['_DATA']._serialized_end=5632 + _globals['_EDB']._serialized_start=5635 + _globals['_EDB']._serialized_end=5771 + _globals['_BETREERELATION']._serialized_start=5774 + _globals['_BETREERELATION']._serialized_end=5913 + _globals['_BETREEINFO']._serialized_start=5916 + _globals['_BETREEINFO']._serialized_end=6203 + _globals['_BETREECONFIG']._serialized_start=6206 + _globals['_BETREECONFIG']._serialized_end=6335 + _globals['_BETREELOCATOR']._serialized_start=6338 + _globals['_BETREELOCATOR']._serialized_end=6540 + _globals['_CSVDATA']._serialized_start=6543 + _globals['_CSVDATA']._serialized_end=6745 + _globals['_CSVLOCATOR']._serialized_start=6747 + _globals['_CSVLOCATOR']._serialized_end=6814 + _globals['_CSVCONFIG']._serialized_start=6817 + _globals['_CSVCONFIG']._serialized_end=7172 + _globals['_GNFCOLUMN']._serialized_start=7175 + _globals['_GNFCOLUMN']._serialized_end=7349 + _globals['_RELATIONID']._serialized_start=7351 + _globals['_RELATIONID']._serialized_end=7411 + _globals['_TYPE']._serialized_start=7414 + _globals['_TYPE']._serialized_end=8191 + _globals['_UNSPECIFIEDTYPE']._serialized_start=8193 + _globals['_UNSPECIFIEDTYPE']._serialized_end=8210 + _globals['_STRINGTYPE']._serialized_start=8212 + _globals['_STRINGTYPE']._serialized_end=8224 + _globals['_INTTYPE']._serialized_start=8226 + _globals['_INTTYPE']._serialized_end=8235 + _globals['_FLOATTYPE']._serialized_start=8237 + _globals['_FLOATTYPE']._serialized_end=8248 + _globals['_UINT128TYPE']._serialized_start=8250 + _globals['_UINT128TYPE']._serialized_end=8263 + _globals['_INT128TYPE']._serialized_start=8265 + _globals['_INT128TYPE']._serialized_end=8277 + _globals['_DATETYPE']._serialized_start=8279 + _globals['_DATETYPE']._serialized_end=8289 + _globals['_DATETIMETYPE']._serialized_start=8291 + _globals['_DATETIMETYPE']._serialized_end=8305 + _globals['_MISSINGTYPE']._serialized_start=8307 + _globals['_MISSINGTYPE']._serialized_end=8320 + _globals['_DECIMALTYPE']._serialized_start=8322 + _globals['_DECIMALTYPE']._serialized_end=8387 + _globals['_BOOLEANTYPE']._serialized_start=8389 + _globals['_BOOLEANTYPE']._serialized_end=8402 + _globals['_VALUE']._serialized_start=8405 + _globals['_VALUE']._serialized_end=8998 + _globals['_UINT128VALUE']._serialized_start=9000 + _globals['_UINT128VALUE']._serialized_end=9052 + _globals['_INT128VALUE']._serialized_start=9054 + _globals['_INT128VALUE']._serialized_end=9105 + _globals['_MISSINGVALUE']._serialized_start=9107 + _globals['_MISSINGVALUE']._serialized_end=9121 + _globals['_DATEVALUE']._serialized_start=9123 + _globals['_DATEVALUE']._serialized_end=9194 + _globals['_DATETIMEVALUE']._serialized_start=9197 + _globals['_DATETIMEVALUE']._serialized_end=9374 + _globals['_DECIMALVALUE']._serialized_start=9376 + _globals['_DECIMALVALUE']._serialized_end=9498 # @@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 2411d8fc..8f8e1a08 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi @@ -337,16 +337,16 @@ class Attribute(_message.Message): def __init__(self, name: _Optional[str] = ..., args: _Optional[_Iterable[_Union[Value, _Mapping]]] = ...) -> None: ... class Data(_message.Message): - __slots__ = ("rel_edb", "betree_relation", "csv_data") - REL_EDB_FIELD_NUMBER: _ClassVar[int] + __slots__ = ("edb", "betree_relation", "csv_data") + EDB_FIELD_NUMBER: _ClassVar[int] BETREE_RELATION_FIELD_NUMBER: _ClassVar[int] CSV_DATA_FIELD_NUMBER: _ClassVar[int] - rel_edb: RelEDB + edb: EDB betree_relation: BeTreeRelation csv_data: CSVData - def __init__(self, rel_edb: _Optional[_Union[RelEDB, _Mapping]] = ..., betree_relation: _Optional[_Union[BeTreeRelation, _Mapping]] = ..., csv_data: _Optional[_Union[CSVData, _Mapping]] = ...) -> None: ... + def __init__(self, edb: _Optional[_Union[EDB, _Mapping]] = ..., betree_relation: _Optional[_Union[BeTreeRelation, _Mapping]] = ..., csv_data: _Optional[_Union[CSVData, _Mapping]] = ...) -> None: ... -class RelEDB(_message.Message): +class EDB(_message.Message): __slots__ = ("target_id", "path", "types") TARGET_ID_FIELD_NUMBER: _ClassVar[int] PATH_FIELD_NUMBER: _ClassVar[int] @@ -408,9 +408,9 @@ class CSVData(_message.Message): ASOF_FIELD_NUMBER: _ClassVar[int] locator: CSVLocator config: CSVConfig - columns: _containers.RepeatedCompositeFieldContainer[CSVColumn] + columns: _containers.RepeatedCompositeFieldContainer[GNFColumn] asof: str - def __init__(self, locator: _Optional[_Union[CSVLocator, _Mapping]] = ..., config: _Optional[_Union[CSVConfig, _Mapping]] = ..., columns: _Optional[_Iterable[_Union[CSVColumn, _Mapping]]] = ..., asof: _Optional[str] = ...) -> None: ... + def __init__(self, locator: _Optional[_Union[CSVLocator, _Mapping]] = ..., config: _Optional[_Union[CSVConfig, _Mapping]] = ..., columns: _Optional[_Iterable[_Union[GNFColumn, _Mapping]]] = ..., asof: _Optional[str] = ...) -> None: ... class CSVLocator(_message.Message): __slots__ = ("paths", "inline_data") @@ -446,7 +446,7 @@ class CSVConfig(_message.Message): compression: str def __init__(self, header_row: _Optional[int] = ..., skip: _Optional[int] = ..., new_line: _Optional[str] = ..., delimiter: _Optional[str] = ..., quotechar: _Optional[str] = ..., escapechar: _Optional[str] = ..., comment: _Optional[str] = ..., missing_strings: _Optional[_Iterable[str]] = ..., decimal_separator: _Optional[str] = ..., encoding: _Optional[str] = ..., compression: _Optional[str] = ...) -> None: ... -class CSVColumn(_message.Message): +class GNFColumn(_message.Message): __slots__ = ("column_path", "target_id", "types") COLUMN_PATH_FIELD_NUMBER: _ClassVar[int] TARGET_ID_FIELD_NUMBER: _ClassVar[int] diff --git a/sdks/python/tests/test_extra_pretty.py b/sdks/python/tests/test_extra_pretty.py index 152d5a2d..60955a17 100644 --- a/sdks/python/tests/test_extra_pretty.py +++ b/sdks/python/tests/test_extra_pretty.py @@ -221,16 +221,16 @@ def test_instruction_assign(self): result = _pp(msg) assert result.startswith("(assign") - def test_data_rel_edb(self): + def test_data_edb(self): msg = logic_pb2.Data( - rel_edb=logic_pb2.RelEDB( + edb=logic_pb2.EDB( target_id=logic_pb2.RelationId(id_low=1, id_high=0), path=["base", "rel"], types=[], ) ) result = _pp(msg) - assert result.startswith("(rel_edb") + assert result.startswith("(edb") def test_read_demand(self): msg = transactions_pb2.Read( From 500175d22fd7c3695eb35f143b793aaa6fa66280 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 22:38:37 +0100 Subject: [PATCH 7/8] Generalize Snapshot action --- meta/src/meta/grammar.y | 16 +- meta/src/meta/target.py | 3 - proto/relationalai/lqp/v1/transactions.proto | 11 +- sdks/go/src/lqp/v1/transactions.pb.go | 427 +- sdks/go/src/parser.go | 3854 +++++++-------- sdks/go/src/pretty.go | 3868 +++++++-------- .../src/LogicalQueryProtocol.jl | 2 +- .../LogicalQueryProtocol.jl/src/equality.jl | 11 +- .../relationalai/lqp/v1/transactions_pb.jl | 193 +- .../LogicalQueryProtocol.jl/src/parser.jl | 3170 ++++++------ .../LogicalQueryProtocol.jl/src/pretty.jl | 3902 +++++++-------- .../test/equality_tests.jl | 67 +- sdks/python/src/lqp/gen/parser.py | 3260 ++++++------- sdks/python/src/lqp/gen/pretty.py | 4303 +++++++++-------- .../src/lqp/proto/v1/transactions_pb2.py | 44 +- .../src/lqp/proto/v1/transactions_pb2.pyi | 8 +- tests/bin/snapshot.bin | Bin 1186 -> 1184 bytes tests/lqp/snapshot.bin | Bin 0 -> 1184 bytes tests/lqp/snapshot.lqp | 7 +- tests/pretty/snapshot.lqp | 7 +- tests/pretty_debug/snapshot.lqp | 7 +- 21 files changed, 11709 insertions(+), 11451 deletions(-) create mode 100644 tests/lqp/snapshot.bin diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index bec04604..06974f3f 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -148,6 +148,7 @@ %nonterm string_type logic.StringType %nonterm sum_monoid logic.SumMonoid %nonterm snapshot transactions.Snapshot +%nonterm snapshot_mapping transactions.SnapshotMapping %nonterm sync transactions.Sync %nonterm term logic.Term %nonterm terms Sequence[logic.Term] @@ -1009,12 +1010,17 @@ context construct: $$ = transactions.Context(relations=$3) deconstruct: $3: Sequence[logic.RelationId] = $$.relations -snapshot - : "(" "snapshot" edb_path relation_id ")" - construct: $$ = transactions.Snapshot(destination_path=$3, source_relation=$4) +snapshot_mapping + : edb_path relation_id + construct: $$ = transactions.SnapshotMapping(destination_path=$1, source_relation=$2) deconstruct: - $3: Sequence[String] = $$.destination_path - $4: logic.RelationId = $$.source_relation + $1: Sequence[String] = $$.destination_path + $2: logic.RelationId = $$.source_relation + +snapshot + : "(" "snapshot" snapshot_mapping* ")" + construct: $$ = transactions.Snapshot(mappings=$3) + deconstruct: $3: Sequence[transactions.SnapshotMapping] = $$.mappings epoch_reads : "(" "reads" read* ")" diff --git a/meta/src/meta/target.py b/meta/src/meta/target.py index d8653cd7..fc0db432 100644 --- a/meta/src/meta/target.py +++ b/meta/src/meta/target.py @@ -345,9 +345,6 @@ def __post_init__(self): def target_type(self) -> "TargetType": if isinstance(self.func, (ParseNonterminal, PrintNonterminal)): return self.func.target_type() - # Special handling for tuple builtin: construct TupleType from argument types - if isinstance(self.func, Builtin) and self.func.name == "tuple": - return TupleType(tuple(arg.target_type() for arg in self.args)) func_type = self.func.target_type() if isinstance(func_type, FunctionType): # Match parameter types against argument types to build type variable mapping diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto index a40b5875..30cdc4c5 100644 --- a/proto/relationalai/lqp/v1/transactions.proto +++ b/proto/relationalai/lqp/v1/transactions.proto @@ -64,13 +64,18 @@ message Context { repeated RelationId relations = 1; } -// Demand the source IDB, take an immutable snapshot, and turn it into an EDB under the -// given path (specified as a sequence of strings, see EDB). -message Snapshot { +// A single (destination, source) pair within a Snapshot action. +message SnapshotMapping { repeated string destination_path = 1; RelationId source_relation = 2; } +// Demand the source IDBs, take immutable snapshots, and turn them into EDBs under the +// given paths (specified as sequences of strings, see EDB). +message Snapshot { + repeated SnapshotMapping mappings = 1; +} + // // Export config // diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index 7589f230..73527b07 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -571,9 +571,8 @@ func (x *Context) GetRelations() []*RelationId { return nil } -// Demand the source IDB, take an immutable snapshot, and turn it into an EDB under the -// given path (specified as a sequence of strings, see EDB). -type Snapshot struct { +// A single (destination, source) pair within a Snapshot action. +type SnapshotMapping struct { state protoimpl.MessageState `protogen:"open.v1"` DestinationPath []string `protobuf:"bytes,1,rep,name=destination_path,json=destinationPath,proto3" json:"destination_path,omitempty"` SourceRelation *RelationId `protobuf:"bytes,2,opt,name=source_relation,json=sourceRelation,proto3" json:"source_relation,omitempty"` @@ -581,20 +580,20 @@ type Snapshot struct { sizeCache protoimpl.SizeCache } -func (x *Snapshot) Reset() { - *x = Snapshot{} +func (x *SnapshotMapping) Reset() { + *x = SnapshotMapping{} mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Snapshot) String() string { +func (x *SnapshotMapping) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Snapshot) ProtoMessage() {} +func (*SnapshotMapping) ProtoMessage() {} -func (x *Snapshot) ProtoReflect() protoreflect.Message { +func (x *SnapshotMapping) ProtoReflect() protoreflect.Message { mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[9] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -606,25 +605,71 @@ func (x *Snapshot) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Snapshot.ProtoReflect.Descriptor instead. -func (*Snapshot) Descriptor() ([]byte, []int) { +// Deprecated: Use SnapshotMapping.ProtoReflect.Descriptor instead. +func (*SnapshotMapping) Descriptor() ([]byte, []int) { return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{9} } -func (x *Snapshot) GetDestinationPath() []string { +func (x *SnapshotMapping) GetDestinationPath() []string { if x != nil { return x.DestinationPath } return nil } -func (x *Snapshot) GetSourceRelation() *RelationId { +func (x *SnapshotMapping) GetSourceRelation() *RelationId { if x != nil { return x.SourceRelation } return nil } +// Demand the source IDBs, take immutable snapshots, and turn them into EDBs under the +// given paths (specified as sequences of strings, see EDB). +type Snapshot struct { + state protoimpl.MessageState `protogen:"open.v1"` + Mappings []*SnapshotMapping `protobuf:"bytes,1,rep,name=mappings,proto3" json:"mappings,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Snapshot) Reset() { + *x = Snapshot{} + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Snapshot) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Snapshot) ProtoMessage() {} + +func (x *Snapshot) ProtoReflect() protoreflect.Message { + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10] + 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 Snapshot.ProtoReflect.Descriptor instead. +func (*Snapshot) Descriptor() ([]byte, []int) { + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{10} +} + +func (x *Snapshot) GetMappings() []*SnapshotMapping { + if x != nil { + return x.Mappings + } + return nil +} + type ExportCSVConfig struct { state protoimpl.MessageState `protogen:"open.v1"` Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` @@ -642,7 +687,7 @@ type ExportCSVConfig struct { func (x *ExportCSVConfig) Reset() { *x = ExportCSVConfig{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -654,7 +699,7 @@ func (x *ExportCSVConfig) String() string { func (*ExportCSVConfig) ProtoMessage() {} func (x *ExportCSVConfig) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -667,7 +712,7 @@ func (x *ExportCSVConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use ExportCSVConfig.ProtoReflect.Descriptor instead. func (*ExportCSVConfig) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{10} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{11} } func (x *ExportCSVConfig) GetPath() string { @@ -743,7 +788,7 @@ type ExportCSVColumn struct { func (x *ExportCSVColumn) Reset() { *x = ExportCSVColumn{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -755,7 +800,7 @@ func (x *ExportCSVColumn) String() string { func (*ExportCSVColumn) ProtoMessage() {} func (x *ExportCSVColumn) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -768,7 +813,7 @@ func (x *ExportCSVColumn) ProtoReflect() protoreflect.Message { // Deprecated: Use ExportCSVColumn.ProtoReflect.Descriptor instead. func (*ExportCSVColumn) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{11} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{12} } func (x *ExportCSVColumn) GetColumnName() string { @@ -801,7 +846,7 @@ type Read struct { func (x *Read) Reset() { *x = Read{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -813,7 +858,7 @@ func (x *Read) String() string { func (*Read) ProtoMessage() {} func (x *Read) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -826,7 +871,7 @@ func (x *Read) ProtoReflect() protoreflect.Message { // Deprecated: Use Read.ProtoReflect.Descriptor instead. func (*Read) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{12} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{13} } func (x *Read) GetReadType() isRead_ReadType { @@ -924,7 +969,7 @@ type Demand struct { func (x *Demand) Reset() { *x = Demand{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -936,7 +981,7 @@ func (x *Demand) String() string { func (*Demand) ProtoMessage() {} func (x *Demand) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -949,7 +994,7 @@ func (x *Demand) ProtoReflect() protoreflect.Message { // Deprecated: Use Demand.ProtoReflect.Descriptor instead. func (*Demand) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{13} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{14} } func (x *Demand) GetRelationId() *RelationId { @@ -969,7 +1014,7 @@ type Output struct { func (x *Output) Reset() { *x = Output{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -981,7 +1026,7 @@ func (x *Output) String() string { func (*Output) ProtoMessage() {} func (x *Output) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -994,7 +1039,7 @@ func (x *Output) ProtoReflect() protoreflect.Message { // Deprecated: Use Output.ProtoReflect.Descriptor instead. func (*Output) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{14} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{15} } func (x *Output) GetName() string { @@ -1023,7 +1068,7 @@ type Export struct { func (x *Export) Reset() { *x = Export{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1035,7 +1080,7 @@ func (x *Export) String() string { func (*Export) ProtoMessage() {} func (x *Export) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1048,7 +1093,7 @@ func (x *Export) ProtoReflect() protoreflect.Message { // Deprecated: Use Export.ProtoReflect.Descriptor instead. func (*Export) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{15} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{16} } func (x *Export) GetExportConfig() isExport_ExportConfig { @@ -1087,7 +1132,7 @@ type WhatIf struct { func (x *WhatIf) Reset() { *x = WhatIf{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1099,7 +1144,7 @@ func (x *WhatIf) String() string { func (*WhatIf) ProtoMessage() {} func (x *WhatIf) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1112,7 +1157,7 @@ func (x *WhatIf) ProtoReflect() protoreflect.Message { // Deprecated: Use WhatIf.ProtoReflect.Descriptor instead. func (*WhatIf) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{16} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{17} } func (x *WhatIf) GetBranch() string { @@ -1139,7 +1184,7 @@ type Abort struct { func (x *Abort) Reset() { *x = Abort{} - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1151,7 +1196,7 @@ func (x *Abort) String() string { func (*Abort) ProtoMessage() {} func (x *Abort) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17] + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1164,7 +1209,7 @@ func (x *Abort) ProtoReflect() protoreflect.Message { // Deprecated: Use Abort.ProtoReflect.Descriptor instead. func (*Abort) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{17} + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{18} } func (x *Abort) GetName() string { @@ -1258,118 +1303,124 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x22, 0x7f, 0x0a, 0x08, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x29, 0x0a, 0x10, - 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, - 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x74, 0x68, 0x12, 0x48, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, - 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x64, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x22, 0xc4, 0x04, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x47, 0x0a, 0x0c, 0x64, 0x61, 0x74, - 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, - 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, - 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x88, 0x01, 0x01, 0x12, 0x25, - 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, - 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, - 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, 0x12, 0x37, 0x0a, 0x15, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, - 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x13, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x4d, - 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, 0x01, 0x12, - 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x04, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x44, - 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x51, 0x75, 0x6f, 0x74, 0x65, - 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x09, 0x20, 0x01, - 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x45, 0x73, 0x63, 0x61, - 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x70, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c, - 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x14, 0x0a, 0x12, - 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, - 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, - 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x0f, 0x0a, 0x0d, - 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x42, 0x13, 0x0a, - 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, - 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, - 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x22, 0x74, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, - 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, - 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, - 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, - 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x22, 0xa4, - 0x02, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, - 0x6d, 0x61, 0x6e, 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x35, - 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, - 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, - 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x06, 0x6f, - 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x66, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x68, 0x61, - 0x74, 0x49, 0x66, 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x32, 0x0a, - 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, + 0x22, 0x86, 0x01, 0x0a, 0x0f, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x4d, 0x61, 0x70, + 0x70, 0x69, 0x6e, 0x67, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, + 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x74, 0x68, 0x12, + 0x48, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4c, 0x0a, 0x08, 0x53, 0x6e, 0x61, + 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6e, + 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x52, 0x08, 0x6d, + 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x22, 0xc4, 0x04, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, + 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, + 0x47, 0x0a, 0x0c, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x0b, 0x64, 0x61, 0x74, + 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, + 0x65, 0x88, 0x01, 0x01, 0x12, 0x25, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x11, 0x73, + 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, 0x12, 0x37, 0x0a, 0x15, + 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x13, 0x73, + 0x79, 0x6e, 0x74, 0x61, 0x78, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x88, 0x01, 0x01, 0x12, 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, + 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x04, 0x52, 0x0b, 0x73, + 0x79, 0x6e, 0x74, 0x61, 0x78, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a, + 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, + 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a, + 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, + 0x61, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, 0x73, 0x79, 0x6e, 0x74, + 0x61, 0x78, 0x45, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x42, + 0x11, 0x0a, 0x0f, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, + 0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x73, 0x79, 0x6e, + 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, + 0x6c, 0x69, 0x6d, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, + 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, + 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x22, 0x74, + 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, + 0x44, 0x61, 0x74, 0x61, 0x22, 0xa4, 0x02, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, + 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, + 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x48, 0x00, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, + 0x68, 0x61, 0x74, 0x5f, 0x69, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, - 0x76, 0x31, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x05, 0x61, 0x62, 0x6f, 0x72, - 0x74, 0x12, 0x35, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, - 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x00, - 0x52, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, - 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x64, 0x22, 0x5e, 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, - 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x64, 0x22, 0x60, 0x0a, 0x06, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x45, 0x0a, 0x0a, 0x63, - 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x22, 0x52, 0x0a, 0x06, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x16, 0x0a, - 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, - 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x30, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, - 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x5d, 0x0a, 0x05, 0x41, 0x62, 0x6f, 0x72, 0x74, - 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x87, 0x01, 0x0a, 0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74, - 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x1d, 0x4d, + 0x76, 0x31, 0x2e, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, + 0x74, 0x49, 0x66, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, + 0x52, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, + 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, + 0x70, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, + 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, + 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x5e, 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x60, 0x0a, 0x06, 0x45, 0x78, 0x70, 0x6f, 0x72, + 0x74, 0x12, 0x45, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x09, 0x63, + 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x52, 0x0a, 0x06, 0x57, 0x68, 0x61, + 0x74, 0x49, 0x66, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x30, 0x0a, 0x05, 0x65, + 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x5d, 0x0a, + 0x05, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, + 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x87, 0x01, 0x0a, + 0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x12, 0x21, 0x0a, 0x1d, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, + 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, + 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, 0x10, 0x01, 0x12, + 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, + 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, - 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, - 0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x49, - 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, - 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, - 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03, - 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, - 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, - 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, - 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03, 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, + 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, + 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, }) var ( @@ -1385,7 +1436,7 @@ func file_relationalai_lqp_v1_transactions_proto_rawDescGZIP() []byte { } var file_relationalai_lqp_v1_transactions_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_relationalai_lqp_v1_transactions_proto_msgTypes = make([]protoimpl.MessageInfo, 18) +var file_relationalai_lqp_v1_transactions_proto_msgTypes = make([]protoimpl.MessageInfo, 19) var file_relationalai_lqp_v1_transactions_proto_goTypes = []any{ (MaintenanceLevel)(0), // 0: relationalai.lqp.v1.MaintenanceLevel (*Transaction)(nil), // 1: relationalai.lqp.v1.Transaction @@ -1397,18 +1448,19 @@ var file_relationalai_lqp_v1_transactions_proto_goTypes = []any{ (*Define)(nil), // 7: relationalai.lqp.v1.Define (*Undefine)(nil), // 8: relationalai.lqp.v1.Undefine (*Context)(nil), // 9: relationalai.lqp.v1.Context - (*Snapshot)(nil), // 10: relationalai.lqp.v1.Snapshot - (*ExportCSVConfig)(nil), // 11: relationalai.lqp.v1.ExportCSVConfig - (*ExportCSVColumn)(nil), // 12: relationalai.lqp.v1.ExportCSVColumn - (*Read)(nil), // 13: relationalai.lqp.v1.Read - (*Demand)(nil), // 14: relationalai.lqp.v1.Demand - (*Output)(nil), // 15: relationalai.lqp.v1.Output - (*Export)(nil), // 16: relationalai.lqp.v1.Export - (*WhatIf)(nil), // 17: relationalai.lqp.v1.WhatIf - (*Abort)(nil), // 18: relationalai.lqp.v1.Abort - (*FragmentId)(nil), // 19: relationalai.lqp.v1.FragmentId - (*Fragment)(nil), // 20: relationalai.lqp.v1.Fragment - (*RelationId)(nil), // 21: relationalai.lqp.v1.RelationId + (*SnapshotMapping)(nil), // 10: relationalai.lqp.v1.SnapshotMapping + (*Snapshot)(nil), // 11: relationalai.lqp.v1.Snapshot + (*ExportCSVConfig)(nil), // 12: relationalai.lqp.v1.ExportCSVConfig + (*ExportCSVColumn)(nil), // 13: relationalai.lqp.v1.ExportCSVColumn + (*Read)(nil), // 14: relationalai.lqp.v1.Read + (*Demand)(nil), // 15: relationalai.lqp.v1.Demand + (*Output)(nil), // 16: relationalai.lqp.v1.Output + (*Export)(nil), // 17: relationalai.lqp.v1.Export + (*WhatIf)(nil), // 18: relationalai.lqp.v1.WhatIf + (*Abort)(nil), // 19: relationalai.lqp.v1.Abort + (*FragmentId)(nil), // 20: relationalai.lqp.v1.FragmentId + (*Fragment)(nil), // 21: relationalai.lqp.v1.Fragment + (*RelationId)(nil), // 22: relationalai.lqp.v1.RelationId } var file_relationalai_lqp_v1_transactions_proto_depIdxs = []int32{ 5, // 0: relationalai.lqp.v1.Transaction.epochs:type_name -> relationalai.lqp.v1.Epoch @@ -1416,34 +1468,35 @@ var file_relationalai_lqp_v1_transactions_proto_depIdxs = []int32{ 4, // 2: relationalai.lqp.v1.Transaction.sync:type_name -> relationalai.lqp.v1.Sync 3, // 3: relationalai.lqp.v1.Configure.ivm_config:type_name -> relationalai.lqp.v1.IVMConfig 0, // 4: relationalai.lqp.v1.IVMConfig.level:type_name -> relationalai.lqp.v1.MaintenanceLevel - 19, // 5: relationalai.lqp.v1.Sync.fragments:type_name -> relationalai.lqp.v1.FragmentId + 20, // 5: relationalai.lqp.v1.Sync.fragments:type_name -> relationalai.lqp.v1.FragmentId 6, // 6: relationalai.lqp.v1.Epoch.writes:type_name -> relationalai.lqp.v1.Write - 13, // 7: relationalai.lqp.v1.Epoch.reads:type_name -> relationalai.lqp.v1.Read + 14, // 7: relationalai.lqp.v1.Epoch.reads:type_name -> relationalai.lqp.v1.Read 7, // 8: relationalai.lqp.v1.Write.define:type_name -> relationalai.lqp.v1.Define 8, // 9: relationalai.lqp.v1.Write.undefine:type_name -> relationalai.lqp.v1.Undefine 9, // 10: relationalai.lqp.v1.Write.context:type_name -> relationalai.lqp.v1.Context - 10, // 11: relationalai.lqp.v1.Write.snapshot:type_name -> relationalai.lqp.v1.Snapshot - 20, // 12: relationalai.lqp.v1.Define.fragment:type_name -> relationalai.lqp.v1.Fragment - 19, // 13: relationalai.lqp.v1.Undefine.fragment_id:type_name -> relationalai.lqp.v1.FragmentId - 21, // 14: relationalai.lqp.v1.Context.relations:type_name -> relationalai.lqp.v1.RelationId - 21, // 15: relationalai.lqp.v1.Snapshot.source_relation:type_name -> relationalai.lqp.v1.RelationId - 12, // 16: relationalai.lqp.v1.ExportCSVConfig.data_columns:type_name -> relationalai.lqp.v1.ExportCSVColumn - 21, // 17: relationalai.lqp.v1.ExportCSVColumn.column_data:type_name -> relationalai.lqp.v1.RelationId - 14, // 18: relationalai.lqp.v1.Read.demand:type_name -> relationalai.lqp.v1.Demand - 15, // 19: relationalai.lqp.v1.Read.output:type_name -> relationalai.lqp.v1.Output - 17, // 20: relationalai.lqp.v1.Read.what_if:type_name -> relationalai.lqp.v1.WhatIf - 18, // 21: relationalai.lqp.v1.Read.abort:type_name -> relationalai.lqp.v1.Abort - 16, // 22: relationalai.lqp.v1.Read.export:type_name -> relationalai.lqp.v1.Export - 21, // 23: relationalai.lqp.v1.Demand.relation_id:type_name -> relationalai.lqp.v1.RelationId - 21, // 24: relationalai.lqp.v1.Output.relation_id:type_name -> relationalai.lqp.v1.RelationId - 11, // 25: relationalai.lqp.v1.Export.csv_config:type_name -> relationalai.lqp.v1.ExportCSVConfig - 5, // 26: relationalai.lqp.v1.WhatIf.epoch:type_name -> relationalai.lqp.v1.Epoch - 21, // 27: relationalai.lqp.v1.Abort.relation_id:type_name -> relationalai.lqp.v1.RelationId - 28, // [28:28] is the sub-list for method output_type - 28, // [28:28] is the sub-list for method input_type - 28, // [28:28] is the sub-list for extension type_name - 28, // [28:28] is the sub-list for extension extendee - 0, // [0:28] is the sub-list for field type_name + 11, // 11: relationalai.lqp.v1.Write.snapshot:type_name -> relationalai.lqp.v1.Snapshot + 21, // 12: relationalai.lqp.v1.Define.fragment:type_name -> relationalai.lqp.v1.Fragment + 20, // 13: relationalai.lqp.v1.Undefine.fragment_id:type_name -> relationalai.lqp.v1.FragmentId + 22, // 14: relationalai.lqp.v1.Context.relations:type_name -> relationalai.lqp.v1.RelationId + 22, // 15: relationalai.lqp.v1.SnapshotMapping.source_relation:type_name -> relationalai.lqp.v1.RelationId + 10, // 16: relationalai.lqp.v1.Snapshot.mappings:type_name -> relationalai.lqp.v1.SnapshotMapping + 13, // 17: relationalai.lqp.v1.ExportCSVConfig.data_columns:type_name -> relationalai.lqp.v1.ExportCSVColumn + 22, // 18: relationalai.lqp.v1.ExportCSVColumn.column_data:type_name -> relationalai.lqp.v1.RelationId + 15, // 19: relationalai.lqp.v1.Read.demand:type_name -> relationalai.lqp.v1.Demand + 16, // 20: relationalai.lqp.v1.Read.output:type_name -> relationalai.lqp.v1.Output + 18, // 21: relationalai.lqp.v1.Read.what_if:type_name -> relationalai.lqp.v1.WhatIf + 19, // 22: relationalai.lqp.v1.Read.abort:type_name -> relationalai.lqp.v1.Abort + 17, // 23: relationalai.lqp.v1.Read.export:type_name -> relationalai.lqp.v1.Export + 22, // 24: relationalai.lqp.v1.Demand.relation_id:type_name -> relationalai.lqp.v1.RelationId + 22, // 25: relationalai.lqp.v1.Output.relation_id:type_name -> relationalai.lqp.v1.RelationId + 12, // 26: relationalai.lqp.v1.Export.csv_config:type_name -> relationalai.lqp.v1.ExportCSVConfig + 5, // 27: relationalai.lqp.v1.WhatIf.epoch:type_name -> relationalai.lqp.v1.Epoch + 22, // 28: relationalai.lqp.v1.Abort.relation_id:type_name -> relationalai.lqp.v1.RelationId + 29, // [29:29] is the sub-list for method output_type + 29, // [29:29] is the sub-list for method input_type + 29, // [29:29] is the sub-list for extension type_name + 29, // [29:29] is the sub-list for extension extendee + 0, // [0:29] is the sub-list for field type_name } func init() { file_relationalai_lqp_v1_transactions_proto_init() } @@ -1460,15 +1513,15 @@ func file_relationalai_lqp_v1_transactions_proto_init() { (*Write_Context)(nil), (*Write_Snapshot)(nil), } - file_relationalai_lqp_v1_transactions_proto_msgTypes[10].OneofWrappers = []any{} - file_relationalai_lqp_v1_transactions_proto_msgTypes[12].OneofWrappers = []any{ + file_relationalai_lqp_v1_transactions_proto_msgTypes[11].OneofWrappers = []any{} + file_relationalai_lqp_v1_transactions_proto_msgTypes[13].OneofWrappers = []any{ (*Read_Demand)(nil), (*Read_Output)(nil), (*Read_WhatIf)(nil), (*Read_Abort)(nil), (*Read_Export)(nil), } - file_relationalai_lqp_v1_transactions_proto_msgTypes[15].OneofWrappers = []any{ + file_relationalai_lqp_v1_transactions_proto_msgTypes[16].OneofWrappers = []any{ (*Export_CsvConfig)(nil), } type x struct{} @@ -1477,7 +1530,7 @@ func file_relationalai_lqp_v1_transactions_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_relationalai_lqp_v1_transactions_proto_rawDesc), len(file_relationalai_lqp_v1_transactions_proto_rawDesc)), NumEnums: 1, - NumMessages: 18, + NumMessages: 19, NumExtensions: 0, NumServices: 0, }, diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index 4163fa1e..4016cd4b 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -524,150 +524,150 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t1340 interface{} + var _t1350 interface{} if (value != nil && hasProtoField(value, "int_value")) { return int32(value.GetIntValue()) } - _ = _t1340 + _ = _t1350 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t1341 interface{} + var _t1351 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t1341 + _ = _t1351 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t1342 interface{} + var _t1352 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t1342 + _ = _t1352 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t1343 interface{} + var _t1353 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t1343 + _ = _t1353 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t1344 interface{} + var _t1354 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t1344 + _ = _t1354 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t1345 interface{} + var _t1355 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t1345 + _ = _t1355 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t1346 interface{} + var _t1356 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t1346 + _ = _t1356 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t1347 interface{} + var _t1357 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t1347 + _ = _t1357 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t1348 interface{} + var _t1358 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t1348 + _ = _t1358 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t1349 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t1349 - _t1350 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t1350 - _t1351 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t1351 - _t1352 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t1352 - _t1353 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t1353 - _t1354 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t1354 - _t1355 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t1355 - _t1356 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t1356 - _t1357 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t1357 - _t1358 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t1358 - _t1359 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") - compression := _t1359 - _t1360 := &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} - return _t1360 + _t1359 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t1359 + _t1360 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t1360 + _t1361 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t1361 + _t1362 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t1362 + _t1363 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t1363 + _t1364 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t1364 + _t1365 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t1365 + _t1366 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t1366 + _t1367 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t1367 + _t1368 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t1368 + _t1369 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") + compression := _t1369 + _t1370 := &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} + return _t1370 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t1361 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t1361 - _t1362 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t1362 - _t1363 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t1363 - _t1364 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t1364 - _t1365 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t1365 - _t1366 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t1366 - _t1367 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t1367 - _t1368 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t1368 - _t1369 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t1369 - _t1370 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t1371 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t1371 + _t1372 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t1372 + _t1373 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t1373 + _t1374 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t1374 + _t1375 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t1375 + _t1376 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t1376 + _t1377 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t1377 + _t1378 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t1378 + _t1379 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t1379 + _t1380 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t1370.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t1380.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t1370.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t1380.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t1370 - _t1371 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t1371 + relation_locator := _t1380 + _t1381 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t1381 } func (p *Parser) default_configure() *pb.Configure { - _t1372 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t1372 - _t1373 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t1373 + _t1382 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t1382 + _t1383 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t1383 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -689,32 +689,32 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t1374 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t1374 - _t1375 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t1375 - _t1376 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t1376 + _t1384 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t1384 + _t1385 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t1385 + _t1386 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t1386 } func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t1377 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t1377 - _t1378 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t1378 - _t1379 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t1379 - _t1380 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t1380 - _t1381 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t1381 - _t1382 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t1382 - _t1383 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t1383 - _t1384 := &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 _t1384 + _t1387 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t1387 + _t1388 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t1388 + _t1389 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t1389 + _t1390 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t1390 + _t1391 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t1391 + _t1392 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t1392 + _t1393 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t1393 + _t1394 := &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 _t1394 } // --- Parse functions --- @@ -722,2481 +722,2465 @@ func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, c func (p *Parser) parse_transaction() *pb.Transaction { p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t724 *pb.Configure + var _t732 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t725 := p.parse_configure() - _t724 = _t725 + _t733 := p.parse_configure() + _t732 = _t733 } - configure362 := _t724 - var _t726 *pb.Sync + configure366 := _t732 + var _t734 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t727 := p.parse_sync() - _t726 = _t727 + _t735 := p.parse_sync() + _t734 = _t735 } - sync363 := _t726 - xs364 := []*pb.Epoch{} - cond365 := p.matchLookaheadLiteral("(", 0) - for cond365 { - _t728 := p.parse_epoch() - item366 := _t728 - xs364 = append(xs364, item366) - cond365 = p.matchLookaheadLiteral("(", 0) + sync367 := _t734 + xs368 := []*pb.Epoch{} + cond369 := p.matchLookaheadLiteral("(", 0) + for cond369 { + _t736 := p.parse_epoch() + item370 := _t736 + xs368 = append(xs368, item370) + cond369 = p.matchLookaheadLiteral("(", 0) } - epochs367 := xs364 + epochs371 := xs368 p.consumeLiteral(")") - _t729 := p.default_configure() - _t730 := configure362 - if configure362 == nil { - _t730 = _t729 + _t737 := p.default_configure() + _t738 := configure366 + if configure366 == nil { + _t738 = _t737 } - _t731 := &pb.Transaction{Epochs: epochs367, Configure: _t730, Sync: sync363} - return _t731 + _t739 := &pb.Transaction{Epochs: epochs371, Configure: _t738, Sync: sync367} + return _t739 } func (p *Parser) parse_configure() *pb.Configure { p.consumeLiteral("(") p.consumeLiteral("configure") - _t732 := p.parse_config_dict() - config_dict368 := _t732 + _t740 := p.parse_config_dict() + config_dict372 := _t740 p.consumeLiteral(")") - _t733 := p.construct_configure(config_dict368) - return _t733 + _t741 := p.construct_configure(config_dict372) + return _t741 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs369 := [][]interface{}{} - cond370 := p.matchLookaheadLiteral(":", 0) - for cond370 { - _t734 := p.parse_config_key_value() - item371 := _t734 - xs369 = append(xs369, item371) - cond370 = p.matchLookaheadLiteral(":", 0) - } - config_key_values372 := xs369 + xs373 := [][]interface{}{} + cond374 := p.matchLookaheadLiteral(":", 0) + for cond374 { + _t742 := p.parse_config_key_value() + item375 := _t742 + xs373 = append(xs373, item375) + cond374 = p.matchLookaheadLiteral(":", 0) + } + config_key_values376 := xs373 p.consumeLiteral("}") - return config_key_values372 + return config_key_values376 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol373 := p.consumeTerminal("SYMBOL").Value.str - _t735 := p.parse_value() - value374 := _t735 - return []interface{}{symbol373, value374} + symbol377 := p.consumeTerminal("SYMBOL").Value.str + _t743 := p.parse_value() + value378 := _t743 + return []interface{}{symbol377, value378} } func (p *Parser) parse_value() *pb.Value { - var _t736 int64 + var _t744 int64 if p.matchLookaheadLiteral("true", 0) { - _t736 = 9 + _t744 = 9 } else { - var _t737 int64 + var _t745 int64 if p.matchLookaheadLiteral("missing", 0) { - _t737 = 8 + _t745 = 8 } else { - var _t738 int64 + var _t746 int64 if p.matchLookaheadLiteral("false", 0) { - _t738 = 9 + _t746 = 9 } else { - var _t739 int64 + var _t747 int64 if p.matchLookaheadLiteral("(", 0) { - var _t740 int64 + var _t748 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t740 = 1 + _t748 = 1 } else { - var _t741 int64 + var _t749 int64 if p.matchLookaheadLiteral("date", 1) { - _t741 = 0 + _t749 = 0 } else { - _t741 = -1 + _t749 = -1 } - _t740 = _t741 + _t748 = _t749 } - _t739 = _t740 + _t747 = _t748 } else { - var _t742 int64 + var _t750 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t742 = 5 + _t750 = 5 } else { - var _t743 int64 + var _t751 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t743 = 2 + _t751 = 2 } else { - var _t744 int64 + var _t752 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t744 = 6 + _t752 = 6 } else { - var _t745 int64 + var _t753 int64 if p.matchLookaheadTerminal("INT", 0) { - _t745 = 3 + _t753 = 3 } else { - var _t746 int64 + var _t754 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t746 = 4 + _t754 = 4 } else { - var _t747 int64 + var _t755 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t747 = 7 + _t755 = 7 } else { - _t747 = -1 + _t755 = -1 } - _t746 = _t747 + _t754 = _t755 } - _t745 = _t746 + _t753 = _t754 } - _t744 = _t745 + _t752 = _t753 } - _t743 = _t744 + _t751 = _t752 } - _t742 = _t743 + _t750 = _t751 } - _t739 = _t742 + _t747 = _t750 } - _t738 = _t739 + _t746 = _t747 } - _t737 = _t738 + _t745 = _t746 } - _t736 = _t737 - } - prediction375 := _t736 - var _t748 *pb.Value - if prediction375 == 9 { - _t749 := p.parse_boolean_value() - boolean_value384 := _t749 - _t750 := &pb.Value{} - _t750.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value384} - _t748 = _t750 + _t744 = _t745 + } + prediction379 := _t744 + var _t756 *pb.Value + if prediction379 == 9 { + _t757 := p.parse_boolean_value() + boolean_value388 := _t757 + _t758 := &pb.Value{} + _t758.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value388} + _t756 = _t758 } else { - var _t751 *pb.Value - if prediction375 == 8 { + var _t759 *pb.Value + if prediction379 == 8 { p.consumeLiteral("missing") - _t752 := &pb.MissingValue{} - _t753 := &pb.Value{} - _t753.Value = &pb.Value_MissingValue{MissingValue: _t752} - _t751 = _t753 + _t760 := &pb.MissingValue{} + _t761 := &pb.Value{} + _t761.Value = &pb.Value_MissingValue{MissingValue: _t760} + _t759 = _t761 } else { - var _t754 *pb.Value - if prediction375 == 7 { - decimal383 := p.consumeTerminal("DECIMAL").Value.decimal - _t755 := &pb.Value{} - _t755.Value = &pb.Value_DecimalValue{DecimalValue: decimal383} - _t754 = _t755 + var _t762 *pb.Value + if prediction379 == 7 { + decimal387 := p.consumeTerminal("DECIMAL").Value.decimal + _t763 := &pb.Value{} + _t763.Value = &pb.Value_DecimalValue{DecimalValue: decimal387} + _t762 = _t763 } else { - var _t756 *pb.Value - if prediction375 == 6 { - int128382 := p.consumeTerminal("INT128").Value.int128 - _t757 := &pb.Value{} - _t757.Value = &pb.Value_Int128Value{Int128Value: int128382} - _t756 = _t757 + var _t764 *pb.Value + if prediction379 == 6 { + int128386 := p.consumeTerminal("INT128").Value.int128 + _t765 := &pb.Value{} + _t765.Value = &pb.Value_Int128Value{Int128Value: int128386} + _t764 = _t765 } else { - var _t758 *pb.Value - if prediction375 == 5 { - uint128381 := p.consumeTerminal("UINT128").Value.uint128 - _t759 := &pb.Value{} - _t759.Value = &pb.Value_Uint128Value{Uint128Value: uint128381} - _t758 = _t759 + var _t766 *pb.Value + if prediction379 == 5 { + uint128385 := p.consumeTerminal("UINT128").Value.uint128 + _t767 := &pb.Value{} + _t767.Value = &pb.Value_Uint128Value{Uint128Value: uint128385} + _t766 = _t767 } else { - var _t760 *pb.Value - if prediction375 == 4 { - float380 := p.consumeTerminal("FLOAT").Value.f64 - _t761 := &pb.Value{} - _t761.Value = &pb.Value_FloatValue{FloatValue: float380} - _t760 = _t761 + var _t768 *pb.Value + if prediction379 == 4 { + float384 := p.consumeTerminal("FLOAT").Value.f64 + _t769 := &pb.Value{} + _t769.Value = &pb.Value_FloatValue{FloatValue: float384} + _t768 = _t769 } else { - var _t762 *pb.Value - if prediction375 == 3 { - int379 := p.consumeTerminal("INT").Value.i64 - _t763 := &pb.Value{} - _t763.Value = &pb.Value_IntValue{IntValue: int379} - _t762 = _t763 + var _t770 *pb.Value + if prediction379 == 3 { + int383 := p.consumeTerminal("INT").Value.i64 + _t771 := &pb.Value{} + _t771.Value = &pb.Value_IntValue{IntValue: int383} + _t770 = _t771 } else { - var _t764 *pb.Value - if prediction375 == 2 { - string378 := p.consumeTerminal("STRING").Value.str - _t765 := &pb.Value{} - _t765.Value = &pb.Value_StringValue{StringValue: string378} - _t764 = _t765 + var _t772 *pb.Value + if prediction379 == 2 { + string382 := p.consumeTerminal("STRING").Value.str + _t773 := &pb.Value{} + _t773.Value = &pb.Value_StringValue{StringValue: string382} + _t772 = _t773 } else { - var _t766 *pb.Value - if prediction375 == 1 { - _t767 := p.parse_datetime() - datetime377 := _t767 - _t768 := &pb.Value{} - _t768.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime377} - _t766 = _t768 + var _t774 *pb.Value + if prediction379 == 1 { + _t775 := p.parse_datetime() + datetime381 := _t775 + _t776 := &pb.Value{} + _t776.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime381} + _t774 = _t776 } else { - var _t769 *pb.Value - if prediction375 == 0 { - _t770 := p.parse_date() - date376 := _t770 - _t771 := &pb.Value{} - _t771.Value = &pb.Value_DateValue{DateValue: date376} - _t769 = _t771 + var _t777 *pb.Value + if prediction379 == 0 { + _t778 := p.parse_date() + date380 := _t778 + _t779 := &pb.Value{} + _t779.Value = &pb.Value_DateValue{DateValue: date380} + _t777 = _t779 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t766 = _t769 + _t774 = _t777 } - _t764 = _t766 + _t772 = _t774 } - _t762 = _t764 + _t770 = _t772 } - _t760 = _t762 + _t768 = _t770 } - _t758 = _t760 + _t766 = _t768 } - _t756 = _t758 + _t764 = _t766 } - _t754 = _t756 + _t762 = _t764 } - _t751 = _t754 + _t759 = _t762 } - _t748 = _t751 + _t756 = _t759 } - return _t748 + return _t756 } func (p *Parser) parse_date() *pb.DateValue { p.consumeLiteral("(") p.consumeLiteral("date") - int385 := p.consumeTerminal("INT").Value.i64 - int_3386 := p.consumeTerminal("INT").Value.i64 - int_4387 := p.consumeTerminal("INT").Value.i64 + int389 := p.consumeTerminal("INT").Value.i64 + int_3390 := p.consumeTerminal("INT").Value.i64 + int_4391 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t772 := &pb.DateValue{Year: int32(int385), Month: int32(int_3386), Day: int32(int_4387)} - return _t772 + _t780 := &pb.DateValue{Year: int32(int389), Month: int32(int_3390), Day: int32(int_4391)} + return _t780 } func (p *Parser) parse_datetime() *pb.DateTimeValue { p.consumeLiteral("(") p.consumeLiteral("datetime") - int388 := p.consumeTerminal("INT").Value.i64 - int_3389 := p.consumeTerminal("INT").Value.i64 - int_4390 := p.consumeTerminal("INT").Value.i64 - int_5391 := p.consumeTerminal("INT").Value.i64 - int_6392 := p.consumeTerminal("INT").Value.i64 - int_7393 := p.consumeTerminal("INT").Value.i64 - var _t773 *int64 + int392 := p.consumeTerminal("INT").Value.i64 + int_3393 := p.consumeTerminal("INT").Value.i64 + int_4394 := p.consumeTerminal("INT").Value.i64 + int_5395 := p.consumeTerminal("INT").Value.i64 + int_6396 := p.consumeTerminal("INT").Value.i64 + int_7397 := p.consumeTerminal("INT").Value.i64 + var _t781 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t773 = ptr(p.consumeTerminal("INT").Value.i64) + _t781 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8394 := _t773 + int_8398 := _t781 p.consumeLiteral(")") - _t774 := &pb.DateTimeValue{Year: int32(int388), Month: int32(int_3389), Day: int32(int_4390), Hour: int32(int_5391), Minute: int32(int_6392), Second: int32(int_7393), Microsecond: int32(deref(int_8394, 0))} - return _t774 + _t782 := &pb.DateTimeValue{Year: int32(int392), Month: int32(int_3393), Day: int32(int_4394), Hour: int32(int_5395), Minute: int32(int_6396), Second: int32(int_7397), Microsecond: int32(deref(int_8398, 0))} + return _t782 } func (p *Parser) parse_boolean_value() bool { - var _t775 int64 + var _t783 int64 if p.matchLookaheadLiteral("true", 0) { - _t775 = 0 + _t783 = 0 } else { - var _t776 int64 + var _t784 int64 if p.matchLookaheadLiteral("false", 0) { - _t776 = 1 + _t784 = 1 } else { - _t776 = -1 + _t784 = -1 } - _t775 = _t776 + _t783 = _t784 } - prediction395 := _t775 - var _t777 bool - if prediction395 == 1 { + prediction399 := _t783 + var _t785 bool + if prediction399 == 1 { p.consumeLiteral("false") - _t777 = false + _t785 = false } else { - var _t778 bool - if prediction395 == 0 { + var _t786 bool + if prediction399 == 0 { p.consumeLiteral("true") - _t778 = true + _t786 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t777 = _t778 + _t785 = _t786 } - return _t777 + return _t785 } func (p *Parser) parse_sync() *pb.Sync { p.consumeLiteral("(") p.consumeLiteral("sync") - xs396 := []*pb.FragmentId{} - cond397 := p.matchLookaheadLiteral(":", 0) - for cond397 { - _t779 := p.parse_fragment_id() - item398 := _t779 - xs396 = append(xs396, item398) - cond397 = p.matchLookaheadLiteral(":", 0) + xs400 := []*pb.FragmentId{} + cond401 := p.matchLookaheadLiteral(":", 0) + for cond401 { + _t787 := p.parse_fragment_id() + item402 := _t787 + xs400 = append(xs400, item402) + cond401 = p.matchLookaheadLiteral(":", 0) } - fragment_ids399 := xs396 + fragment_ids403 := xs400 p.consumeLiteral(")") - _t780 := &pb.Sync{Fragments: fragment_ids399} - return _t780 + _t788 := &pb.Sync{Fragments: fragment_ids403} + return _t788 } func (p *Parser) parse_fragment_id() *pb.FragmentId { p.consumeLiteral(":") - symbol400 := p.consumeTerminal("SYMBOL").Value.str - return &pb.FragmentId{Id: []byte(symbol400)} + symbol404 := p.consumeTerminal("SYMBOL").Value.str + return &pb.FragmentId{Id: []byte(symbol404)} } func (p *Parser) parse_epoch() *pb.Epoch { p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t781 []*pb.Write + var _t789 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t782 := p.parse_epoch_writes() - _t781 = _t782 + _t790 := p.parse_epoch_writes() + _t789 = _t790 } - epoch_writes401 := _t781 - var _t783 []*pb.Read + epoch_writes405 := _t789 + var _t791 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t784 := p.parse_epoch_reads() - _t783 = _t784 + _t792 := p.parse_epoch_reads() + _t791 = _t792 } - epoch_reads402 := _t783 + epoch_reads406 := _t791 p.consumeLiteral(")") - _t785 := epoch_writes401 - if epoch_writes401 == nil { - _t785 = []*pb.Write{} + _t793 := epoch_writes405 + if epoch_writes405 == nil { + _t793 = []*pb.Write{} } - _t786 := epoch_reads402 - if epoch_reads402 == nil { - _t786 = []*pb.Read{} + _t794 := epoch_reads406 + if epoch_reads406 == nil { + _t794 = []*pb.Read{} } - _t787 := &pb.Epoch{Writes: _t785, Reads: _t786} - return _t787 + _t795 := &pb.Epoch{Writes: _t793, Reads: _t794} + return _t795 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs403 := []*pb.Write{} - cond404 := p.matchLookaheadLiteral("(", 0) - for cond404 { - _t788 := p.parse_write() - item405 := _t788 - xs403 = append(xs403, item405) - cond404 = p.matchLookaheadLiteral("(", 0) + xs407 := []*pb.Write{} + cond408 := p.matchLookaheadLiteral("(", 0) + for cond408 { + _t796 := p.parse_write() + item409 := _t796 + xs407 = append(xs407, item409) + cond408 = p.matchLookaheadLiteral("(", 0) } - writes406 := xs403 + writes410 := xs407 p.consumeLiteral(")") - return writes406 + return writes410 } func (p *Parser) parse_write() *pb.Write { - var _t789 int64 + var _t797 int64 if p.matchLookaheadLiteral("(", 0) { - var _t790 int64 + var _t798 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t790 = 1 + _t798 = 1 } else { - var _t791 int64 + var _t799 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t791 = 3 + _t799 = 3 } else { - var _t792 int64 + var _t800 int64 if p.matchLookaheadLiteral("define", 1) { - _t792 = 0 + _t800 = 0 } else { - var _t793 int64 + var _t801 int64 if p.matchLookaheadLiteral("context", 1) { - _t793 = 2 + _t801 = 2 } else { - _t793 = -1 + _t801 = -1 } - _t792 = _t793 + _t800 = _t801 } - _t791 = _t792 + _t799 = _t800 } - _t790 = _t791 + _t798 = _t799 } - _t789 = _t790 + _t797 = _t798 } else { - _t789 = -1 - } - prediction407 := _t789 - var _t794 *pb.Write - if prediction407 == 3 { - _t795 := p.parse_snapshot() - snapshot411 := _t795 - _t796 := &pb.Write{} - _t796.WriteType = &pb.Write_Snapshot{Snapshot: snapshot411} - _t794 = _t796 + _t797 = -1 + } + prediction411 := _t797 + var _t802 *pb.Write + if prediction411 == 3 { + _t803 := p.parse_snapshot() + snapshot415 := _t803 + _t804 := &pb.Write{} + _t804.WriteType = &pb.Write_Snapshot{Snapshot: snapshot415} + _t802 = _t804 } else { - var _t797 *pb.Write - if prediction407 == 2 { - _t798 := p.parse_context() - context410 := _t798 - _t799 := &pb.Write{} - _t799.WriteType = &pb.Write_Context{Context: context410} - _t797 = _t799 + var _t805 *pb.Write + if prediction411 == 2 { + _t806 := p.parse_context() + context414 := _t806 + _t807 := &pb.Write{} + _t807.WriteType = &pb.Write_Context{Context: context414} + _t805 = _t807 } else { - var _t800 *pb.Write - if prediction407 == 1 { - _t801 := p.parse_undefine() - undefine409 := _t801 - _t802 := &pb.Write{} - _t802.WriteType = &pb.Write_Undefine{Undefine: undefine409} - _t800 = _t802 + var _t808 *pb.Write + if prediction411 == 1 { + _t809 := p.parse_undefine() + undefine413 := _t809 + _t810 := &pb.Write{} + _t810.WriteType = &pb.Write_Undefine{Undefine: undefine413} + _t808 = _t810 } else { - var _t803 *pb.Write - if prediction407 == 0 { - _t804 := p.parse_define() - define408 := _t804 - _t805 := &pb.Write{} - _t805.WriteType = &pb.Write_Define{Define: define408} - _t803 = _t805 + var _t811 *pb.Write + if prediction411 == 0 { + _t812 := p.parse_define() + define412 := _t812 + _t813 := &pb.Write{} + _t813.WriteType = &pb.Write_Define{Define: define412} + _t811 = _t813 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t800 = _t803 + _t808 = _t811 } - _t797 = _t800 + _t805 = _t808 } - _t794 = _t797 + _t802 = _t805 } - return _t794 + return _t802 } func (p *Parser) parse_define() *pb.Define { p.consumeLiteral("(") p.consumeLiteral("define") - _t806 := p.parse_fragment() - fragment412 := _t806 + _t814 := p.parse_fragment() + fragment416 := _t814 p.consumeLiteral(")") - _t807 := &pb.Define{Fragment: fragment412} - return _t807 + _t815 := &pb.Define{Fragment: fragment416} + return _t815 } func (p *Parser) parse_fragment() *pb.Fragment { p.consumeLiteral("(") p.consumeLiteral("fragment") - _t808 := p.parse_new_fragment_id() - new_fragment_id413 := _t808 - xs414 := []*pb.Declaration{} - cond415 := p.matchLookaheadLiteral("(", 0) - for cond415 { - _t809 := p.parse_declaration() - item416 := _t809 - xs414 = append(xs414, item416) - cond415 = p.matchLookaheadLiteral("(", 0) + _t816 := p.parse_new_fragment_id() + new_fragment_id417 := _t816 + xs418 := []*pb.Declaration{} + cond419 := p.matchLookaheadLiteral("(", 0) + for cond419 { + _t817 := p.parse_declaration() + item420 := _t817 + xs418 = append(xs418, item420) + cond419 = p.matchLookaheadLiteral("(", 0) } - declarations417 := xs414 + declarations421 := xs418 p.consumeLiteral(")") - return p.constructFragment(new_fragment_id413, declarations417) + return p.constructFragment(new_fragment_id417, declarations421) } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - _t810 := p.parse_fragment_id() - fragment_id418 := _t810 - p.startFragment(fragment_id418) - return fragment_id418 + _t818 := p.parse_fragment_id() + fragment_id422 := _t818 + p.startFragment(fragment_id422) + return fragment_id422 } func (p *Parser) parse_declaration() *pb.Declaration { - var _t811 int64 + var _t819 int64 if p.matchLookaheadLiteral("(", 0) { - var _t812 int64 + var _t820 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t812 = 2 + _t820 = 2 } else { - var _t813 int64 + var _t821 int64 if p.matchLookaheadLiteral("edb", 1) { - _t813 = 3 + _t821 = 3 } else { - var _t814 int64 + var _t822 int64 if p.matchLookaheadLiteral("def", 1) { - _t814 = 0 + _t822 = 0 } else { - var _t815 int64 + var _t823 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t815 = 3 + _t823 = 3 } else { - var _t816 int64 + var _t824 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t816 = 3 + _t824 = 3 } else { - var _t817 int64 + var _t825 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t817 = 1 + _t825 = 1 } else { - _t817 = -1 + _t825 = -1 } - _t816 = _t817 + _t824 = _t825 } - _t815 = _t816 + _t823 = _t824 } - _t814 = _t815 + _t822 = _t823 } - _t813 = _t814 + _t821 = _t822 } - _t812 = _t813 + _t820 = _t821 } - _t811 = _t812 + _t819 = _t820 } else { - _t811 = -1 - } - prediction419 := _t811 - var _t818 *pb.Declaration - if prediction419 == 3 { - _t819 := p.parse_data() - data423 := _t819 - _t820 := &pb.Declaration{} - _t820.DeclarationType = &pb.Declaration_Data{Data: data423} - _t818 = _t820 + _t819 = -1 + } + prediction423 := _t819 + var _t826 *pb.Declaration + if prediction423 == 3 { + _t827 := p.parse_data() + data427 := _t827 + _t828 := &pb.Declaration{} + _t828.DeclarationType = &pb.Declaration_Data{Data: data427} + _t826 = _t828 } else { - var _t821 *pb.Declaration - if prediction419 == 2 { - _t822 := p.parse_constraint() - constraint422 := _t822 - _t823 := &pb.Declaration{} - _t823.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint422} - _t821 = _t823 + var _t829 *pb.Declaration + if prediction423 == 2 { + _t830 := p.parse_constraint() + constraint426 := _t830 + _t831 := &pb.Declaration{} + _t831.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint426} + _t829 = _t831 } else { - var _t824 *pb.Declaration - if prediction419 == 1 { - _t825 := p.parse_algorithm() - algorithm421 := _t825 - _t826 := &pb.Declaration{} - _t826.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm421} - _t824 = _t826 + var _t832 *pb.Declaration + if prediction423 == 1 { + _t833 := p.parse_algorithm() + algorithm425 := _t833 + _t834 := &pb.Declaration{} + _t834.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm425} + _t832 = _t834 } else { - var _t827 *pb.Declaration - if prediction419 == 0 { - _t828 := p.parse_def() - def420 := _t828 - _t829 := &pb.Declaration{} - _t829.DeclarationType = &pb.Declaration_Def{Def: def420} - _t827 = _t829 + var _t835 *pb.Declaration + if prediction423 == 0 { + _t836 := p.parse_def() + def424 := _t836 + _t837 := &pb.Declaration{} + _t837.DeclarationType = &pb.Declaration_Def{Def: def424} + _t835 = _t837 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t824 = _t827 + _t832 = _t835 } - _t821 = _t824 + _t829 = _t832 } - _t818 = _t821 + _t826 = _t829 } - return _t818 + return _t826 } func (p *Parser) parse_def() *pb.Def { p.consumeLiteral("(") p.consumeLiteral("def") - _t830 := p.parse_relation_id() - relation_id424 := _t830 - _t831 := p.parse_abstraction() - abstraction425 := _t831 - var _t832 []*pb.Attribute + _t838 := p.parse_relation_id() + relation_id428 := _t838 + _t839 := p.parse_abstraction() + abstraction429 := _t839 + var _t840 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t833 := p.parse_attrs() - _t832 = _t833 + _t841 := p.parse_attrs() + _t840 = _t841 } - attrs426 := _t832 + attrs430 := _t840 p.consumeLiteral(")") - _t834 := attrs426 - if attrs426 == nil { - _t834 = []*pb.Attribute{} + _t842 := attrs430 + if attrs430 == nil { + _t842 = []*pb.Attribute{} } - _t835 := &pb.Def{Name: relation_id424, Body: abstraction425, Attrs: _t834} - return _t835 + _t843 := &pb.Def{Name: relation_id428, Body: abstraction429, Attrs: _t842} + return _t843 } func (p *Parser) parse_relation_id() *pb.RelationId { - var _t836 int64 + var _t844 int64 if p.matchLookaheadLiteral(":", 0) { - _t836 = 0 + _t844 = 0 } else { - var _t837 int64 + var _t845 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t837 = 1 + _t845 = 1 } else { - _t837 = -1 + _t845 = -1 } - _t836 = _t837 - } - prediction427 := _t836 - var _t838 *pb.RelationId - if prediction427 == 1 { - uint128429 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128429 - _t838 = &pb.RelationId{IdLow: uint128429.Low, IdHigh: uint128429.High} + _t844 = _t845 + } + prediction431 := _t844 + var _t846 *pb.RelationId + if prediction431 == 1 { + uint128433 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128433 + _t846 = &pb.RelationId{IdLow: uint128433.Low, IdHigh: uint128433.High} } else { - var _t839 *pb.RelationId - if prediction427 == 0 { + var _t847 *pb.RelationId + if prediction431 == 0 { p.consumeLiteral(":") - symbol428 := p.consumeTerminal("SYMBOL").Value.str - _t839 = p.relationIdFromString(symbol428) + symbol432 := p.consumeTerminal("SYMBOL").Value.str + _t847 = p.relationIdFromString(symbol432) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t838 = _t839 + _t846 = _t847 } - return _t838 + return _t846 } func (p *Parser) parse_abstraction() *pb.Abstraction { p.consumeLiteral("(") - _t840 := p.parse_bindings() - bindings430 := _t840 - _t841 := p.parse_formula() - formula431 := _t841 + _t848 := p.parse_bindings() + bindings434 := _t848 + _t849 := p.parse_formula() + formula435 := _t849 p.consumeLiteral(")") - _t842 := &pb.Abstraction{Vars: listConcat(bindings430[0].([]*pb.Binding), bindings430[1].([]*pb.Binding)), Value: formula431} - return _t842 + _t850 := &pb.Abstraction{Vars: listConcat(bindings434[0].([]*pb.Binding), bindings434[1].([]*pb.Binding)), Value: formula435} + return _t850 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs432 := []*pb.Binding{} - cond433 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond433 { - _t843 := p.parse_binding() - item434 := _t843 - xs432 = append(xs432, item434) - cond433 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings435 := xs432 - var _t844 []*pb.Binding + xs436 := []*pb.Binding{} + cond437 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond437 { + _t851 := p.parse_binding() + item438 := _t851 + xs436 = append(xs436, item438) + cond437 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings439 := xs436 + var _t852 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t845 := p.parse_value_bindings() - _t844 = _t845 + _t853 := p.parse_value_bindings() + _t852 = _t853 } - value_bindings436 := _t844 + value_bindings440 := _t852 p.consumeLiteral("]") - _t846 := value_bindings436 - if value_bindings436 == nil { - _t846 = []*pb.Binding{} + _t854 := value_bindings440 + if value_bindings440 == nil { + _t854 = []*pb.Binding{} } - return []interface{}{bindings435, _t846} + return []interface{}{bindings439, _t854} } func (p *Parser) parse_binding() *pb.Binding { - symbol437 := p.consumeTerminal("SYMBOL").Value.str + symbol441 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t847 := p.parse_type() - type438 := _t847 - _t848 := &pb.Var{Name: symbol437} - _t849 := &pb.Binding{Var: _t848, Type: type438} - return _t849 + _t855 := p.parse_type() + type442 := _t855 + _t856 := &pb.Var{Name: symbol441} + _t857 := &pb.Binding{Var: _t856, Type: type442} + return _t857 } func (p *Parser) parse_type() *pb.Type { - var _t850 int64 + var _t858 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t850 = 0 + _t858 = 0 } else { - var _t851 int64 + var _t859 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t851 = 4 + _t859 = 4 } else { - var _t852 int64 + var _t860 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t852 = 1 + _t860 = 1 } else { - var _t853 int64 + var _t861 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t853 = 8 + _t861 = 8 } else { - var _t854 int64 + var _t862 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t854 = 5 + _t862 = 5 } else { - var _t855 int64 + var _t863 int64 if p.matchLookaheadLiteral("INT", 0) { - _t855 = 2 + _t863 = 2 } else { - var _t856 int64 + var _t864 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t856 = 3 + _t864 = 3 } else { - var _t857 int64 + var _t865 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t857 = 7 + _t865 = 7 } else { - var _t858 int64 + var _t866 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t858 = 6 + _t866 = 6 } else { - var _t859 int64 + var _t867 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t859 = 10 + _t867 = 10 } else { - var _t860 int64 + var _t868 int64 if p.matchLookaheadLiteral("(", 0) { - _t860 = 9 + _t868 = 9 } else { - _t860 = -1 + _t868 = -1 } - _t859 = _t860 + _t867 = _t868 } - _t858 = _t859 + _t866 = _t867 } - _t857 = _t858 + _t865 = _t866 } - _t856 = _t857 + _t864 = _t865 } - _t855 = _t856 + _t863 = _t864 } - _t854 = _t855 + _t862 = _t863 } - _t853 = _t854 + _t861 = _t862 } - _t852 = _t853 + _t860 = _t861 } - _t851 = _t852 + _t859 = _t860 } - _t850 = _t851 - } - prediction439 := _t850 - var _t861 *pb.Type - if prediction439 == 10 { - _t862 := p.parse_boolean_type() - boolean_type450 := _t862 - _t863 := &pb.Type{} - _t863.Type = &pb.Type_BooleanType{BooleanType: boolean_type450} - _t861 = _t863 + _t858 = _t859 + } + prediction443 := _t858 + var _t869 *pb.Type + if prediction443 == 10 { + _t870 := p.parse_boolean_type() + boolean_type454 := _t870 + _t871 := &pb.Type{} + _t871.Type = &pb.Type_BooleanType{BooleanType: boolean_type454} + _t869 = _t871 } else { - var _t864 *pb.Type - if prediction439 == 9 { - _t865 := p.parse_decimal_type() - decimal_type449 := _t865 - _t866 := &pb.Type{} - _t866.Type = &pb.Type_DecimalType{DecimalType: decimal_type449} - _t864 = _t866 + var _t872 *pb.Type + if prediction443 == 9 { + _t873 := p.parse_decimal_type() + decimal_type453 := _t873 + _t874 := &pb.Type{} + _t874.Type = &pb.Type_DecimalType{DecimalType: decimal_type453} + _t872 = _t874 } else { - var _t867 *pb.Type - if prediction439 == 8 { - _t868 := p.parse_missing_type() - missing_type448 := _t868 - _t869 := &pb.Type{} - _t869.Type = &pb.Type_MissingType{MissingType: missing_type448} - _t867 = _t869 + var _t875 *pb.Type + if prediction443 == 8 { + _t876 := p.parse_missing_type() + missing_type452 := _t876 + _t877 := &pb.Type{} + _t877.Type = &pb.Type_MissingType{MissingType: missing_type452} + _t875 = _t877 } else { - var _t870 *pb.Type - if prediction439 == 7 { - _t871 := p.parse_datetime_type() - datetime_type447 := _t871 - _t872 := &pb.Type{} - _t872.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type447} - _t870 = _t872 + var _t878 *pb.Type + if prediction443 == 7 { + _t879 := p.parse_datetime_type() + datetime_type451 := _t879 + _t880 := &pb.Type{} + _t880.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type451} + _t878 = _t880 } else { - var _t873 *pb.Type - if prediction439 == 6 { - _t874 := p.parse_date_type() - date_type446 := _t874 - _t875 := &pb.Type{} - _t875.Type = &pb.Type_DateType{DateType: date_type446} - _t873 = _t875 + var _t881 *pb.Type + if prediction443 == 6 { + _t882 := p.parse_date_type() + date_type450 := _t882 + _t883 := &pb.Type{} + _t883.Type = &pb.Type_DateType{DateType: date_type450} + _t881 = _t883 } else { - var _t876 *pb.Type - if prediction439 == 5 { - _t877 := p.parse_int128_type() - int128_type445 := _t877 - _t878 := &pb.Type{} - _t878.Type = &pb.Type_Int128Type{Int128Type: int128_type445} - _t876 = _t878 + var _t884 *pb.Type + if prediction443 == 5 { + _t885 := p.parse_int128_type() + int128_type449 := _t885 + _t886 := &pb.Type{} + _t886.Type = &pb.Type_Int128Type{Int128Type: int128_type449} + _t884 = _t886 } else { - var _t879 *pb.Type - if prediction439 == 4 { - _t880 := p.parse_uint128_type() - uint128_type444 := _t880 - _t881 := &pb.Type{} - _t881.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type444} - _t879 = _t881 + var _t887 *pb.Type + if prediction443 == 4 { + _t888 := p.parse_uint128_type() + uint128_type448 := _t888 + _t889 := &pb.Type{} + _t889.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type448} + _t887 = _t889 } else { - var _t882 *pb.Type - if prediction439 == 3 { - _t883 := p.parse_float_type() - float_type443 := _t883 - _t884 := &pb.Type{} - _t884.Type = &pb.Type_FloatType{FloatType: float_type443} - _t882 = _t884 + var _t890 *pb.Type + if prediction443 == 3 { + _t891 := p.parse_float_type() + float_type447 := _t891 + _t892 := &pb.Type{} + _t892.Type = &pb.Type_FloatType{FloatType: float_type447} + _t890 = _t892 } else { - var _t885 *pb.Type - if prediction439 == 2 { - _t886 := p.parse_int_type() - int_type442 := _t886 - _t887 := &pb.Type{} - _t887.Type = &pb.Type_IntType{IntType: int_type442} - _t885 = _t887 + var _t893 *pb.Type + if prediction443 == 2 { + _t894 := p.parse_int_type() + int_type446 := _t894 + _t895 := &pb.Type{} + _t895.Type = &pb.Type_IntType{IntType: int_type446} + _t893 = _t895 } else { - var _t888 *pb.Type - if prediction439 == 1 { - _t889 := p.parse_string_type() - string_type441 := _t889 - _t890 := &pb.Type{} - _t890.Type = &pb.Type_StringType{StringType: string_type441} - _t888 = _t890 + var _t896 *pb.Type + if prediction443 == 1 { + _t897 := p.parse_string_type() + string_type445 := _t897 + _t898 := &pb.Type{} + _t898.Type = &pb.Type_StringType{StringType: string_type445} + _t896 = _t898 } else { - var _t891 *pb.Type - if prediction439 == 0 { - _t892 := p.parse_unspecified_type() - unspecified_type440 := _t892 - _t893 := &pb.Type{} - _t893.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type440} - _t891 = _t893 + var _t899 *pb.Type + if prediction443 == 0 { + _t900 := p.parse_unspecified_type() + unspecified_type444 := _t900 + _t901 := &pb.Type{} + _t901.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type444} + _t899 = _t901 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t888 = _t891 + _t896 = _t899 } - _t885 = _t888 + _t893 = _t896 } - _t882 = _t885 + _t890 = _t893 } - _t879 = _t882 + _t887 = _t890 } - _t876 = _t879 + _t884 = _t887 } - _t873 = _t876 + _t881 = _t884 } - _t870 = _t873 + _t878 = _t881 } - _t867 = _t870 + _t875 = _t878 } - _t864 = _t867 + _t872 = _t875 } - _t861 = _t864 + _t869 = _t872 } - return _t861 + return _t869 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { p.consumeLiteral("UNKNOWN") - _t894 := &pb.UnspecifiedType{} - return _t894 + _t902 := &pb.UnspecifiedType{} + return _t902 } func (p *Parser) parse_string_type() *pb.StringType { p.consumeLiteral("STRING") - _t895 := &pb.StringType{} - return _t895 + _t903 := &pb.StringType{} + return _t903 } func (p *Parser) parse_int_type() *pb.IntType { p.consumeLiteral("INT") - _t896 := &pb.IntType{} - return _t896 + _t904 := &pb.IntType{} + return _t904 } func (p *Parser) parse_float_type() *pb.FloatType { p.consumeLiteral("FLOAT") - _t897 := &pb.FloatType{} - return _t897 + _t905 := &pb.FloatType{} + return _t905 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { p.consumeLiteral("UINT128") - _t898 := &pb.UInt128Type{} - return _t898 + _t906 := &pb.UInt128Type{} + return _t906 } func (p *Parser) parse_int128_type() *pb.Int128Type { p.consumeLiteral("INT128") - _t899 := &pb.Int128Type{} - return _t899 + _t907 := &pb.Int128Type{} + return _t907 } func (p *Parser) parse_date_type() *pb.DateType { p.consumeLiteral("DATE") - _t900 := &pb.DateType{} - return _t900 + _t908 := &pb.DateType{} + return _t908 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { p.consumeLiteral("DATETIME") - _t901 := &pb.DateTimeType{} - return _t901 + _t909 := &pb.DateTimeType{} + return _t909 } func (p *Parser) parse_missing_type() *pb.MissingType { p.consumeLiteral("MISSING") - _t902 := &pb.MissingType{} - return _t902 + _t910 := &pb.MissingType{} + return _t910 } func (p *Parser) parse_decimal_type() *pb.DecimalType { p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int451 := p.consumeTerminal("INT").Value.i64 - int_3452 := p.consumeTerminal("INT").Value.i64 + int455 := p.consumeTerminal("INT").Value.i64 + int_3456 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t903 := &pb.DecimalType{Precision: int32(int451), Scale: int32(int_3452)} - return _t903 + _t911 := &pb.DecimalType{Precision: int32(int455), Scale: int32(int_3456)} + return _t911 } func (p *Parser) parse_boolean_type() *pb.BooleanType { p.consumeLiteral("BOOLEAN") - _t904 := &pb.BooleanType{} - return _t904 + _t912 := &pb.BooleanType{} + return _t912 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs453 := []*pb.Binding{} - cond454 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond454 { - _t905 := p.parse_binding() - item455 := _t905 - xs453 = append(xs453, item455) - cond454 = p.matchLookaheadTerminal("SYMBOL", 0) + xs457 := []*pb.Binding{} + cond458 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond458 { + _t913 := p.parse_binding() + item459 := _t913 + xs457 = append(xs457, item459) + cond458 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings456 := xs453 - return bindings456 + bindings460 := xs457 + return bindings460 } func (p *Parser) parse_formula() *pb.Formula { - var _t906 int64 + var _t914 int64 if p.matchLookaheadLiteral("(", 0) { - var _t907 int64 + var _t915 int64 if p.matchLookaheadLiteral("true", 1) { - _t907 = 0 + _t915 = 0 } else { - var _t908 int64 + var _t916 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t908 = 11 + _t916 = 11 } else { - var _t909 int64 + var _t917 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t909 = 3 + _t917 = 3 } else { - var _t910 int64 + var _t918 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t910 = 10 + _t918 = 10 } else { - var _t911 int64 + var _t919 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t911 = 9 + _t919 = 9 } else { - var _t912 int64 + var _t920 int64 if p.matchLookaheadLiteral("or", 1) { - _t912 = 5 + _t920 = 5 } else { - var _t913 int64 + var _t921 int64 if p.matchLookaheadLiteral("not", 1) { - _t913 = 6 + _t921 = 6 } else { - var _t914 int64 + var _t922 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t914 = 7 + _t922 = 7 } else { - var _t915 int64 + var _t923 int64 if p.matchLookaheadLiteral("false", 1) { - _t915 = 1 + _t923 = 1 } else { - var _t916 int64 + var _t924 int64 if p.matchLookaheadLiteral("exists", 1) { - _t916 = 2 + _t924 = 2 } else { - var _t917 int64 + var _t925 int64 if p.matchLookaheadLiteral("cast", 1) { - _t917 = 12 + _t925 = 12 } else { - var _t918 int64 + var _t926 int64 if p.matchLookaheadLiteral("atom", 1) { - _t918 = 8 + _t926 = 8 } else { - var _t919 int64 + var _t927 int64 if p.matchLookaheadLiteral("and", 1) { - _t919 = 4 + _t927 = 4 } else { - var _t920 int64 + var _t928 int64 if p.matchLookaheadLiteral(">=", 1) { - _t920 = 10 + _t928 = 10 } else { - var _t921 int64 + var _t929 int64 if p.matchLookaheadLiteral(">", 1) { - _t921 = 10 + _t929 = 10 } else { - var _t922 int64 + var _t930 int64 if p.matchLookaheadLiteral("=", 1) { - _t922 = 10 + _t930 = 10 } else { - var _t923 int64 + var _t931 int64 if p.matchLookaheadLiteral("<=", 1) { - _t923 = 10 + _t931 = 10 } else { - var _t924 int64 + var _t932 int64 if p.matchLookaheadLiteral("<", 1) { - _t924 = 10 + _t932 = 10 } else { - var _t925 int64 + var _t933 int64 if p.matchLookaheadLiteral("/", 1) { - _t925 = 10 + _t933 = 10 } else { - var _t926 int64 + var _t934 int64 if p.matchLookaheadLiteral("-", 1) { - _t926 = 10 + _t934 = 10 } else { - var _t927 int64 + var _t935 int64 if p.matchLookaheadLiteral("+", 1) { - _t927 = 10 + _t935 = 10 } else { - var _t928 int64 + var _t936 int64 if p.matchLookaheadLiteral("*", 1) { - _t928 = 10 + _t936 = 10 } else { - _t928 = -1 + _t936 = -1 } - _t927 = _t928 + _t935 = _t936 } - _t926 = _t927 + _t934 = _t935 } - _t925 = _t926 + _t933 = _t934 } - _t924 = _t925 + _t932 = _t933 } - _t923 = _t924 + _t931 = _t932 } - _t922 = _t923 + _t930 = _t931 } - _t921 = _t922 + _t929 = _t930 } - _t920 = _t921 + _t928 = _t929 } - _t919 = _t920 + _t927 = _t928 } - _t918 = _t919 + _t926 = _t927 } - _t917 = _t918 + _t925 = _t926 } - _t916 = _t917 + _t924 = _t925 } - _t915 = _t916 + _t923 = _t924 } - _t914 = _t915 + _t922 = _t923 } - _t913 = _t914 + _t921 = _t922 } - _t912 = _t913 + _t920 = _t921 } - _t911 = _t912 + _t919 = _t920 } - _t910 = _t911 + _t918 = _t919 } - _t909 = _t910 + _t917 = _t918 } - _t908 = _t909 + _t916 = _t917 } - _t907 = _t908 + _t915 = _t916 } - _t906 = _t907 + _t914 = _t915 } else { - _t906 = -1 - } - prediction457 := _t906 - var _t929 *pb.Formula - if prediction457 == 12 { - _t930 := p.parse_cast() - cast470 := _t930 - _t931 := &pb.Formula{} - _t931.FormulaType = &pb.Formula_Cast{Cast: cast470} - _t929 = _t931 + _t914 = -1 + } + prediction461 := _t914 + var _t937 *pb.Formula + if prediction461 == 12 { + _t938 := p.parse_cast() + cast474 := _t938 + _t939 := &pb.Formula{} + _t939.FormulaType = &pb.Formula_Cast{Cast: cast474} + _t937 = _t939 } else { - var _t932 *pb.Formula - if prediction457 == 11 { - _t933 := p.parse_rel_atom() - rel_atom469 := _t933 - _t934 := &pb.Formula{} - _t934.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom469} - _t932 = _t934 + var _t940 *pb.Formula + if prediction461 == 11 { + _t941 := p.parse_rel_atom() + rel_atom473 := _t941 + _t942 := &pb.Formula{} + _t942.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom473} + _t940 = _t942 } else { - var _t935 *pb.Formula - if prediction457 == 10 { - _t936 := p.parse_primitive() - primitive468 := _t936 - _t937 := &pb.Formula{} - _t937.FormulaType = &pb.Formula_Primitive{Primitive: primitive468} - _t935 = _t937 + var _t943 *pb.Formula + if prediction461 == 10 { + _t944 := p.parse_primitive() + primitive472 := _t944 + _t945 := &pb.Formula{} + _t945.FormulaType = &pb.Formula_Primitive{Primitive: primitive472} + _t943 = _t945 } else { - var _t938 *pb.Formula - if prediction457 == 9 { - _t939 := p.parse_pragma() - pragma467 := _t939 - _t940 := &pb.Formula{} - _t940.FormulaType = &pb.Formula_Pragma{Pragma: pragma467} - _t938 = _t940 + var _t946 *pb.Formula + if prediction461 == 9 { + _t947 := p.parse_pragma() + pragma471 := _t947 + _t948 := &pb.Formula{} + _t948.FormulaType = &pb.Formula_Pragma{Pragma: pragma471} + _t946 = _t948 } else { - var _t941 *pb.Formula - if prediction457 == 8 { - _t942 := p.parse_atom() - atom466 := _t942 - _t943 := &pb.Formula{} - _t943.FormulaType = &pb.Formula_Atom{Atom: atom466} - _t941 = _t943 + var _t949 *pb.Formula + if prediction461 == 8 { + _t950 := p.parse_atom() + atom470 := _t950 + _t951 := &pb.Formula{} + _t951.FormulaType = &pb.Formula_Atom{Atom: atom470} + _t949 = _t951 } else { - var _t944 *pb.Formula - if prediction457 == 7 { - _t945 := p.parse_ffi() - ffi465 := _t945 - _t946 := &pb.Formula{} - _t946.FormulaType = &pb.Formula_Ffi{Ffi: ffi465} - _t944 = _t946 + var _t952 *pb.Formula + if prediction461 == 7 { + _t953 := p.parse_ffi() + ffi469 := _t953 + _t954 := &pb.Formula{} + _t954.FormulaType = &pb.Formula_Ffi{Ffi: ffi469} + _t952 = _t954 } else { - var _t947 *pb.Formula - if prediction457 == 6 { - _t948 := p.parse_not() - not464 := _t948 - _t949 := &pb.Formula{} - _t949.FormulaType = &pb.Formula_Not{Not: not464} - _t947 = _t949 + var _t955 *pb.Formula + if prediction461 == 6 { + _t956 := p.parse_not() + not468 := _t956 + _t957 := &pb.Formula{} + _t957.FormulaType = &pb.Formula_Not{Not: not468} + _t955 = _t957 } else { - var _t950 *pb.Formula - if prediction457 == 5 { - _t951 := p.parse_disjunction() - disjunction463 := _t951 - _t952 := &pb.Formula{} - _t952.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction463} - _t950 = _t952 + var _t958 *pb.Formula + if prediction461 == 5 { + _t959 := p.parse_disjunction() + disjunction467 := _t959 + _t960 := &pb.Formula{} + _t960.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction467} + _t958 = _t960 } else { - var _t953 *pb.Formula - if prediction457 == 4 { - _t954 := p.parse_conjunction() - conjunction462 := _t954 - _t955 := &pb.Formula{} - _t955.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction462} - _t953 = _t955 + var _t961 *pb.Formula + if prediction461 == 4 { + _t962 := p.parse_conjunction() + conjunction466 := _t962 + _t963 := &pb.Formula{} + _t963.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction466} + _t961 = _t963 } else { - var _t956 *pb.Formula - if prediction457 == 3 { - _t957 := p.parse_reduce() - reduce461 := _t957 - _t958 := &pb.Formula{} - _t958.FormulaType = &pb.Formula_Reduce{Reduce: reduce461} - _t956 = _t958 + var _t964 *pb.Formula + if prediction461 == 3 { + _t965 := p.parse_reduce() + reduce465 := _t965 + _t966 := &pb.Formula{} + _t966.FormulaType = &pb.Formula_Reduce{Reduce: reduce465} + _t964 = _t966 } else { - var _t959 *pb.Formula - if prediction457 == 2 { - _t960 := p.parse_exists() - exists460 := _t960 - _t961 := &pb.Formula{} - _t961.FormulaType = &pb.Formula_Exists{Exists: exists460} - _t959 = _t961 + var _t967 *pb.Formula + if prediction461 == 2 { + _t968 := p.parse_exists() + exists464 := _t968 + _t969 := &pb.Formula{} + _t969.FormulaType = &pb.Formula_Exists{Exists: exists464} + _t967 = _t969 } else { - var _t962 *pb.Formula - if prediction457 == 1 { - _t963 := p.parse_false() - false459 := _t963 - _t964 := &pb.Formula{} - _t964.FormulaType = &pb.Formula_Disjunction{Disjunction: false459} - _t962 = _t964 + var _t970 *pb.Formula + if prediction461 == 1 { + _t971 := p.parse_false() + false463 := _t971 + _t972 := &pb.Formula{} + _t972.FormulaType = &pb.Formula_Disjunction{Disjunction: false463} + _t970 = _t972 } else { - var _t965 *pb.Formula - if prediction457 == 0 { - _t966 := p.parse_true() - true458 := _t966 - _t967 := &pb.Formula{} - _t967.FormulaType = &pb.Formula_Conjunction{Conjunction: true458} - _t965 = _t967 + var _t973 *pb.Formula + if prediction461 == 0 { + _t974 := p.parse_true() + true462 := _t974 + _t975 := &pb.Formula{} + _t975.FormulaType = &pb.Formula_Conjunction{Conjunction: true462} + _t973 = _t975 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t962 = _t965 + _t970 = _t973 } - _t959 = _t962 + _t967 = _t970 } - _t956 = _t959 + _t964 = _t967 } - _t953 = _t956 + _t961 = _t964 } - _t950 = _t953 + _t958 = _t961 } - _t947 = _t950 + _t955 = _t958 } - _t944 = _t947 + _t952 = _t955 } - _t941 = _t944 + _t949 = _t952 } - _t938 = _t941 + _t946 = _t949 } - _t935 = _t938 + _t943 = _t946 } - _t932 = _t935 + _t940 = _t943 } - _t929 = _t932 + _t937 = _t940 } - return _t929 + return _t937 } func (p *Parser) parse_true() *pb.Conjunction { p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t968 := &pb.Conjunction{Args: []*pb.Formula{}} - return _t968 + _t976 := &pb.Conjunction{Args: []*pb.Formula{}} + return _t976 } func (p *Parser) parse_false() *pb.Disjunction { p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t969 := &pb.Disjunction{Args: []*pb.Formula{}} - return _t969 + _t977 := &pb.Disjunction{Args: []*pb.Formula{}} + return _t977 } func (p *Parser) parse_exists() *pb.Exists { p.consumeLiteral("(") p.consumeLiteral("exists") - _t970 := p.parse_bindings() - bindings471 := _t970 - _t971 := p.parse_formula() - formula472 := _t971 + _t978 := p.parse_bindings() + bindings475 := _t978 + _t979 := p.parse_formula() + formula476 := _t979 p.consumeLiteral(")") - _t972 := &pb.Abstraction{Vars: listConcat(bindings471[0].([]*pb.Binding), bindings471[1].([]*pb.Binding)), Value: formula472} - _t973 := &pb.Exists{Body: _t972} - return _t973 + _t980 := &pb.Abstraction{Vars: listConcat(bindings475[0].([]*pb.Binding), bindings475[1].([]*pb.Binding)), Value: formula476} + _t981 := &pb.Exists{Body: _t980} + return _t981 } func (p *Parser) parse_reduce() *pb.Reduce { p.consumeLiteral("(") p.consumeLiteral("reduce") - _t974 := p.parse_abstraction() - abstraction473 := _t974 - _t975 := p.parse_abstraction() - abstraction_3474 := _t975 - _t976 := p.parse_terms() - terms475 := _t976 - p.consumeLiteral(")") - _t977 := &pb.Reduce{Op: abstraction473, Body: abstraction_3474, Terms: terms475} - return _t977 + _t982 := p.parse_abstraction() + abstraction477 := _t982 + _t983 := p.parse_abstraction() + abstraction_3478 := _t983 + _t984 := p.parse_terms() + terms479 := _t984 + p.consumeLiteral(")") + _t985 := &pb.Reduce{Op: abstraction477, Body: abstraction_3478, Terms: terms479} + return _t985 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs476 := []*pb.Term{} - cond477 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond477 { - _t978 := p.parse_term() - item478 := _t978 - xs476 = append(xs476, item478) - cond477 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + xs480 := []*pb.Term{} + cond481 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond481 { + _t986 := p.parse_term() + item482 := _t986 + xs480 = append(xs480, item482) + cond481 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - terms479 := xs476 + terms483 := xs480 p.consumeLiteral(")") - return terms479 + return terms483 } func (p *Parser) parse_term() *pb.Term { - var _t979 int64 + var _t987 int64 if p.matchLookaheadLiteral("true", 0) { - _t979 = 1 + _t987 = 1 } else { - var _t980 int64 + var _t988 int64 if p.matchLookaheadLiteral("missing", 0) { - _t980 = 1 + _t988 = 1 } else { - var _t981 int64 + var _t989 int64 if p.matchLookaheadLiteral("false", 0) { - _t981 = 1 + _t989 = 1 } else { - var _t982 int64 + var _t990 int64 if p.matchLookaheadLiteral("(", 0) { - _t982 = 1 + _t990 = 1 } else { - var _t983 int64 + var _t991 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t983 = 1 + _t991 = 1 } else { - var _t984 int64 + var _t992 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t984 = 0 + _t992 = 0 } else { - var _t985 int64 + var _t993 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t985 = 1 + _t993 = 1 } else { - var _t986 int64 + var _t994 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t986 = 1 + _t994 = 1 } else { - var _t987 int64 + var _t995 int64 if p.matchLookaheadTerminal("INT", 0) { - _t987 = 1 + _t995 = 1 } else { - var _t988 int64 + var _t996 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t988 = 1 + _t996 = 1 } else { - var _t989 int64 + var _t997 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t989 = 1 + _t997 = 1 } else { - _t989 = -1 + _t997 = -1 } - _t988 = _t989 + _t996 = _t997 } - _t987 = _t988 + _t995 = _t996 } - _t986 = _t987 + _t994 = _t995 } - _t985 = _t986 + _t993 = _t994 } - _t984 = _t985 + _t992 = _t993 } - _t983 = _t984 + _t991 = _t992 } - _t982 = _t983 + _t990 = _t991 } - _t981 = _t982 + _t989 = _t990 } - _t980 = _t981 + _t988 = _t989 } - _t979 = _t980 - } - prediction480 := _t979 - var _t990 *pb.Term - if prediction480 == 1 { - _t991 := p.parse_constant() - constant482 := _t991 - _t992 := &pb.Term{} - _t992.TermType = &pb.Term_Constant{Constant: constant482} - _t990 = _t992 + _t987 = _t988 + } + prediction484 := _t987 + var _t998 *pb.Term + if prediction484 == 1 { + _t999 := p.parse_constant() + constant486 := _t999 + _t1000 := &pb.Term{} + _t1000.TermType = &pb.Term_Constant{Constant: constant486} + _t998 = _t1000 } else { - var _t993 *pb.Term - if prediction480 == 0 { - _t994 := p.parse_var() - var481 := _t994 - _t995 := &pb.Term{} - _t995.TermType = &pb.Term_Var{Var: var481} - _t993 = _t995 + var _t1001 *pb.Term + if prediction484 == 0 { + _t1002 := p.parse_var() + var485 := _t1002 + _t1003 := &pb.Term{} + _t1003.TermType = &pb.Term_Var{Var: var485} + _t1001 = _t1003 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t990 = _t993 + _t998 = _t1001 } - return _t990 + return _t998 } func (p *Parser) parse_var() *pb.Var { - symbol483 := p.consumeTerminal("SYMBOL").Value.str - _t996 := &pb.Var{Name: symbol483} - return _t996 + symbol487 := p.consumeTerminal("SYMBOL").Value.str + _t1004 := &pb.Var{Name: symbol487} + return _t1004 } func (p *Parser) parse_constant() *pb.Value { - _t997 := p.parse_value() - value484 := _t997 - return value484 + _t1005 := p.parse_value() + value488 := _t1005 + return value488 } func (p *Parser) parse_conjunction() *pb.Conjunction { p.consumeLiteral("(") p.consumeLiteral("and") - xs485 := []*pb.Formula{} - cond486 := p.matchLookaheadLiteral("(", 0) - for cond486 { - _t998 := p.parse_formula() - item487 := _t998 - xs485 = append(xs485, item487) - cond486 = p.matchLookaheadLiteral("(", 0) + xs489 := []*pb.Formula{} + cond490 := p.matchLookaheadLiteral("(", 0) + for cond490 { + _t1006 := p.parse_formula() + item491 := _t1006 + xs489 = append(xs489, item491) + cond490 = p.matchLookaheadLiteral("(", 0) } - formulas488 := xs485 + formulas492 := xs489 p.consumeLiteral(")") - _t999 := &pb.Conjunction{Args: formulas488} - return _t999 + _t1007 := &pb.Conjunction{Args: formulas492} + return _t1007 } func (p *Parser) parse_disjunction() *pb.Disjunction { p.consumeLiteral("(") p.consumeLiteral("or") - xs489 := []*pb.Formula{} - cond490 := p.matchLookaheadLiteral("(", 0) - for cond490 { - _t1000 := p.parse_formula() - item491 := _t1000 - xs489 = append(xs489, item491) - cond490 = p.matchLookaheadLiteral("(", 0) + xs493 := []*pb.Formula{} + cond494 := p.matchLookaheadLiteral("(", 0) + for cond494 { + _t1008 := p.parse_formula() + item495 := _t1008 + xs493 = append(xs493, item495) + cond494 = p.matchLookaheadLiteral("(", 0) } - formulas492 := xs489 + formulas496 := xs493 p.consumeLiteral(")") - _t1001 := &pb.Disjunction{Args: formulas492} - return _t1001 + _t1009 := &pb.Disjunction{Args: formulas496} + return _t1009 } func (p *Parser) parse_not() *pb.Not { p.consumeLiteral("(") p.consumeLiteral("not") - _t1002 := p.parse_formula() - formula493 := _t1002 + _t1010 := p.parse_formula() + formula497 := _t1010 p.consumeLiteral(")") - _t1003 := &pb.Not{Arg: formula493} - return _t1003 + _t1011 := &pb.Not{Arg: formula497} + return _t1011 } func (p *Parser) parse_ffi() *pb.FFI { p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1004 := p.parse_name() - name494 := _t1004 - _t1005 := p.parse_ffi_args() - ffi_args495 := _t1005 - _t1006 := p.parse_terms() - terms496 := _t1006 - p.consumeLiteral(")") - _t1007 := &pb.FFI{Name: name494, Args: ffi_args495, Terms: terms496} - return _t1007 + _t1012 := p.parse_name() + name498 := _t1012 + _t1013 := p.parse_ffi_args() + ffi_args499 := _t1013 + _t1014 := p.parse_terms() + terms500 := _t1014 + p.consumeLiteral(")") + _t1015 := &pb.FFI{Name: name498, Args: ffi_args499, Terms: terms500} + return _t1015 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol497 := p.consumeTerminal("SYMBOL").Value.str - return symbol497 + symbol501 := p.consumeTerminal("SYMBOL").Value.str + return symbol501 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs498 := []*pb.Abstraction{} - cond499 := p.matchLookaheadLiteral("(", 0) - for cond499 { - _t1008 := p.parse_abstraction() - item500 := _t1008 - xs498 = append(xs498, item500) - cond499 = p.matchLookaheadLiteral("(", 0) + xs502 := []*pb.Abstraction{} + cond503 := p.matchLookaheadLiteral("(", 0) + for cond503 { + _t1016 := p.parse_abstraction() + item504 := _t1016 + xs502 = append(xs502, item504) + cond503 = p.matchLookaheadLiteral("(", 0) } - abstractions501 := xs498 + abstractions505 := xs502 p.consumeLiteral(")") - return abstractions501 + return abstractions505 } func (p *Parser) parse_atom() *pb.Atom { p.consumeLiteral("(") p.consumeLiteral("atom") - _t1009 := p.parse_relation_id() - relation_id502 := _t1009 - xs503 := []*pb.Term{} - cond504 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond504 { - _t1010 := p.parse_term() - item505 := _t1010 - xs503 = append(xs503, item505) - cond504 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - } - terms506 := xs503 - p.consumeLiteral(")") - _t1011 := &pb.Atom{Name: relation_id502, Terms: terms506} - return _t1011 + _t1017 := p.parse_relation_id() + relation_id506 := _t1017 + xs507 := []*pb.Term{} + cond508 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond508 { + _t1018 := p.parse_term() + item509 := _t1018 + xs507 = append(xs507, item509) + cond508 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + } + terms510 := xs507 + p.consumeLiteral(")") + _t1019 := &pb.Atom{Name: relation_id506, Terms: terms510} + return _t1019 } func (p *Parser) parse_pragma() *pb.Pragma { p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1012 := p.parse_name() - name507 := _t1012 - xs508 := []*pb.Term{} - cond509 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond509 { - _t1013 := p.parse_term() - item510 := _t1013 - xs508 = append(xs508, item510) - cond509 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1020 := p.parse_name() + name511 := _t1020 + xs512 := []*pb.Term{} + cond513 := ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond513 { + _t1021 := p.parse_term() + item514 := _t1021 + xs512 = append(xs512, item514) + cond513 = ((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - terms511 := xs508 + terms515 := xs512 p.consumeLiteral(")") - _t1014 := &pb.Pragma{Name: name507, Terms: terms511} - return _t1014 + _t1022 := &pb.Pragma{Name: name511, Terms: terms515} + return _t1022 } func (p *Parser) parse_primitive() *pb.Primitive { - var _t1015 int64 + var _t1023 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1016 int64 + var _t1024 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1016 = 9 + _t1024 = 9 } else { - var _t1017 int64 + var _t1025 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1017 = 4 + _t1025 = 4 } else { - var _t1018 int64 + var _t1026 int64 if p.matchLookaheadLiteral(">", 1) { - _t1018 = 3 + _t1026 = 3 } else { - var _t1019 int64 + var _t1027 int64 if p.matchLookaheadLiteral("=", 1) { - _t1019 = 0 + _t1027 = 0 } else { - var _t1020 int64 + var _t1028 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1020 = 2 + _t1028 = 2 } else { - var _t1021 int64 + var _t1029 int64 if p.matchLookaheadLiteral("<", 1) { - _t1021 = 1 + _t1029 = 1 } else { - var _t1022 int64 + var _t1030 int64 if p.matchLookaheadLiteral("/", 1) { - _t1022 = 8 + _t1030 = 8 } else { - var _t1023 int64 + var _t1031 int64 if p.matchLookaheadLiteral("-", 1) { - _t1023 = 6 + _t1031 = 6 } else { - var _t1024 int64 + var _t1032 int64 if p.matchLookaheadLiteral("+", 1) { - _t1024 = 5 + _t1032 = 5 } else { - var _t1025 int64 + var _t1033 int64 if p.matchLookaheadLiteral("*", 1) { - _t1025 = 7 + _t1033 = 7 } else { - _t1025 = -1 + _t1033 = -1 } - _t1024 = _t1025 + _t1032 = _t1033 } - _t1023 = _t1024 + _t1031 = _t1032 } - _t1022 = _t1023 + _t1030 = _t1031 } - _t1021 = _t1022 + _t1029 = _t1030 } - _t1020 = _t1021 + _t1028 = _t1029 } - _t1019 = _t1020 + _t1027 = _t1028 } - _t1018 = _t1019 + _t1026 = _t1027 } - _t1017 = _t1018 + _t1025 = _t1026 } - _t1016 = _t1017 + _t1024 = _t1025 } - _t1015 = _t1016 + _t1023 = _t1024 } else { - _t1015 = -1 + _t1023 = -1 } - prediction512 := _t1015 - var _t1026 *pb.Primitive - if prediction512 == 9 { + prediction516 := _t1023 + var _t1034 *pb.Primitive + if prediction516 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1027 := p.parse_name() - name522 := _t1027 - xs523 := []*pb.RelTerm{} - cond524 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond524 { - _t1028 := p.parse_rel_term() - item525 := _t1028 - xs523 = append(xs523, item525) - cond524 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1035 := p.parse_name() + name526 := _t1035 + xs527 := []*pb.RelTerm{} + cond528 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond528 { + _t1036 := p.parse_rel_term() + item529 := _t1036 + xs527 = append(xs527, item529) + cond528 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - rel_terms526 := xs523 + rel_terms530 := xs527 p.consumeLiteral(")") - _t1029 := &pb.Primitive{Name: name522, Terms: rel_terms526} - _t1026 = _t1029 + _t1037 := &pb.Primitive{Name: name526, Terms: rel_terms530} + _t1034 = _t1037 } else { - var _t1030 *pb.Primitive - if prediction512 == 8 { - _t1031 := p.parse_divide() - divide521 := _t1031 - _t1030 = divide521 + var _t1038 *pb.Primitive + if prediction516 == 8 { + _t1039 := p.parse_divide() + divide525 := _t1039 + _t1038 = divide525 } else { - var _t1032 *pb.Primitive - if prediction512 == 7 { - _t1033 := p.parse_multiply() - multiply520 := _t1033 - _t1032 = multiply520 + var _t1040 *pb.Primitive + if prediction516 == 7 { + _t1041 := p.parse_multiply() + multiply524 := _t1041 + _t1040 = multiply524 } else { - var _t1034 *pb.Primitive - if prediction512 == 6 { - _t1035 := p.parse_minus() - minus519 := _t1035 - _t1034 = minus519 + var _t1042 *pb.Primitive + if prediction516 == 6 { + _t1043 := p.parse_minus() + minus523 := _t1043 + _t1042 = minus523 } else { - var _t1036 *pb.Primitive - if prediction512 == 5 { - _t1037 := p.parse_add() - add518 := _t1037 - _t1036 = add518 + var _t1044 *pb.Primitive + if prediction516 == 5 { + _t1045 := p.parse_add() + add522 := _t1045 + _t1044 = add522 } else { - var _t1038 *pb.Primitive - if prediction512 == 4 { - _t1039 := p.parse_gt_eq() - gt_eq517 := _t1039 - _t1038 = gt_eq517 + var _t1046 *pb.Primitive + if prediction516 == 4 { + _t1047 := p.parse_gt_eq() + gt_eq521 := _t1047 + _t1046 = gt_eq521 } else { - var _t1040 *pb.Primitive - if prediction512 == 3 { - _t1041 := p.parse_gt() - gt516 := _t1041 - _t1040 = gt516 + var _t1048 *pb.Primitive + if prediction516 == 3 { + _t1049 := p.parse_gt() + gt520 := _t1049 + _t1048 = gt520 } else { - var _t1042 *pb.Primitive - if prediction512 == 2 { - _t1043 := p.parse_lt_eq() - lt_eq515 := _t1043 - _t1042 = lt_eq515 + var _t1050 *pb.Primitive + if prediction516 == 2 { + _t1051 := p.parse_lt_eq() + lt_eq519 := _t1051 + _t1050 = lt_eq519 } else { - var _t1044 *pb.Primitive - if prediction512 == 1 { - _t1045 := p.parse_lt() - lt514 := _t1045 - _t1044 = lt514 + var _t1052 *pb.Primitive + if prediction516 == 1 { + _t1053 := p.parse_lt() + lt518 := _t1053 + _t1052 = lt518 } else { - var _t1046 *pb.Primitive - if prediction512 == 0 { - _t1047 := p.parse_eq() - eq513 := _t1047 - _t1046 = eq513 + var _t1054 *pb.Primitive + if prediction516 == 0 { + _t1055 := p.parse_eq() + eq517 := _t1055 + _t1054 = eq517 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1044 = _t1046 + _t1052 = _t1054 } - _t1042 = _t1044 + _t1050 = _t1052 } - _t1040 = _t1042 + _t1048 = _t1050 } - _t1038 = _t1040 + _t1046 = _t1048 } - _t1036 = _t1038 + _t1044 = _t1046 } - _t1034 = _t1036 + _t1042 = _t1044 } - _t1032 = _t1034 + _t1040 = _t1042 } - _t1030 = _t1032 + _t1038 = _t1040 } - _t1026 = _t1030 + _t1034 = _t1038 } - return _t1026 + return _t1034 } func (p *Parser) parse_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("=") - _t1048 := p.parse_term() - term527 := _t1048 - _t1049 := p.parse_term() - term_3528 := _t1049 + _t1056 := p.parse_term() + term531 := _t1056 + _t1057 := p.parse_term() + term_3532 := _t1057 p.consumeLiteral(")") - _t1050 := &pb.RelTerm{} - _t1050.RelTermType = &pb.RelTerm_Term{Term: term527} - _t1051 := &pb.RelTerm{} - _t1051.RelTermType = &pb.RelTerm_Term{Term: term_3528} - _t1052 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1050, _t1051}} - return _t1052 + _t1058 := &pb.RelTerm{} + _t1058.RelTermType = &pb.RelTerm_Term{Term: term531} + _t1059 := &pb.RelTerm{} + _t1059.RelTermType = &pb.RelTerm_Term{Term: term_3532} + _t1060 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1058, _t1059}} + return _t1060 } func (p *Parser) parse_lt() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("<") - _t1053 := p.parse_term() - term529 := _t1053 - _t1054 := p.parse_term() - term_3530 := _t1054 + _t1061 := p.parse_term() + term533 := _t1061 + _t1062 := p.parse_term() + term_3534 := _t1062 p.consumeLiteral(")") - _t1055 := &pb.RelTerm{} - _t1055.RelTermType = &pb.RelTerm_Term{Term: term529} - _t1056 := &pb.RelTerm{} - _t1056.RelTermType = &pb.RelTerm_Term{Term: term_3530} - _t1057 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1055, _t1056}} - return _t1057 + _t1063 := &pb.RelTerm{} + _t1063.RelTermType = &pb.RelTerm_Term{Term: term533} + _t1064 := &pb.RelTerm{} + _t1064.RelTermType = &pb.RelTerm_Term{Term: term_3534} + _t1065 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1063, _t1064}} + return _t1065 } func (p *Parser) parse_lt_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("<=") - _t1058 := p.parse_term() - term531 := _t1058 - _t1059 := p.parse_term() - term_3532 := _t1059 + _t1066 := p.parse_term() + term535 := _t1066 + _t1067 := p.parse_term() + term_3536 := _t1067 p.consumeLiteral(")") - _t1060 := &pb.RelTerm{} - _t1060.RelTermType = &pb.RelTerm_Term{Term: term531} - _t1061 := &pb.RelTerm{} - _t1061.RelTermType = &pb.RelTerm_Term{Term: term_3532} - _t1062 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1060, _t1061}} - return _t1062 + _t1068 := &pb.RelTerm{} + _t1068.RelTermType = &pb.RelTerm_Term{Term: term535} + _t1069 := &pb.RelTerm{} + _t1069.RelTermType = &pb.RelTerm_Term{Term: term_3536} + _t1070 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1068, _t1069}} + return _t1070 } func (p *Parser) parse_gt() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral(">") - _t1063 := p.parse_term() - term533 := _t1063 - _t1064 := p.parse_term() - term_3534 := _t1064 + _t1071 := p.parse_term() + term537 := _t1071 + _t1072 := p.parse_term() + term_3538 := _t1072 p.consumeLiteral(")") - _t1065 := &pb.RelTerm{} - _t1065.RelTermType = &pb.RelTerm_Term{Term: term533} - _t1066 := &pb.RelTerm{} - _t1066.RelTermType = &pb.RelTerm_Term{Term: term_3534} - _t1067 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1065, _t1066}} - return _t1067 + _t1073 := &pb.RelTerm{} + _t1073.RelTermType = &pb.RelTerm_Term{Term: term537} + _t1074 := &pb.RelTerm{} + _t1074.RelTermType = &pb.RelTerm_Term{Term: term_3538} + _t1075 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1073, _t1074}} + return _t1075 } func (p *Parser) parse_gt_eq() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral(">=") - _t1068 := p.parse_term() - term535 := _t1068 - _t1069 := p.parse_term() - term_3536 := _t1069 + _t1076 := p.parse_term() + term539 := _t1076 + _t1077 := p.parse_term() + term_3540 := _t1077 p.consumeLiteral(")") - _t1070 := &pb.RelTerm{} - _t1070.RelTermType = &pb.RelTerm_Term{Term: term535} - _t1071 := &pb.RelTerm{} - _t1071.RelTermType = &pb.RelTerm_Term{Term: term_3536} - _t1072 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1070, _t1071}} - return _t1072 + _t1078 := &pb.RelTerm{} + _t1078.RelTermType = &pb.RelTerm_Term{Term: term539} + _t1079 := &pb.RelTerm{} + _t1079.RelTermType = &pb.RelTerm_Term{Term: term_3540} + _t1080 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1078, _t1079}} + return _t1080 } func (p *Parser) parse_add() *pb.Primitive { p.consumeLiteral("(") p.consumeLiteral("+") - _t1073 := p.parse_term() - term537 := _t1073 - _t1074 := p.parse_term() - term_3538 := _t1074 - _t1075 := p.parse_term() - term_4539 := _t1075 - p.consumeLiteral(")") - _t1076 := &pb.RelTerm{} - _t1076.RelTermType = &pb.RelTerm_Term{Term: term537} - _t1077 := &pb.RelTerm{} - _t1077.RelTermType = &pb.RelTerm_Term{Term: term_3538} - _t1078 := &pb.RelTerm{} - _t1078.RelTermType = &pb.RelTerm_Term{Term: term_4539} - _t1079 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1076, _t1077, _t1078}} - return _t1079 -} - -func (p *Parser) parse_minus() *pb.Primitive { - p.consumeLiteral("(") - p.consumeLiteral("-") - _t1080 := p.parse_term() - term540 := _t1080 _t1081 := p.parse_term() - term_3541 := _t1081 + term541 := _t1081 _t1082 := p.parse_term() - term_4542 := _t1082 + term_3542 := _t1082 + _t1083 := p.parse_term() + term_4543 := _t1083 p.consumeLiteral(")") - _t1083 := &pb.RelTerm{} - _t1083.RelTermType = &pb.RelTerm_Term{Term: term540} _t1084 := &pb.RelTerm{} - _t1084.RelTermType = &pb.RelTerm_Term{Term: term_3541} + _t1084.RelTermType = &pb.RelTerm_Term{Term: term541} _t1085 := &pb.RelTerm{} - _t1085.RelTermType = &pb.RelTerm_Term{Term: term_4542} - _t1086 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1083, _t1084, _t1085}} - return _t1086 + _t1085.RelTermType = &pb.RelTerm_Term{Term: term_3542} + _t1086 := &pb.RelTerm{} + _t1086.RelTermType = &pb.RelTerm_Term{Term: term_4543} + _t1087 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1084, _t1085, _t1086}} + return _t1087 } -func (p *Parser) parse_multiply() *pb.Primitive { +func (p *Parser) parse_minus() *pb.Primitive { p.consumeLiteral("(") - p.consumeLiteral("*") - _t1087 := p.parse_term() - term543 := _t1087 + p.consumeLiteral("-") _t1088 := p.parse_term() - term_3544 := _t1088 + term544 := _t1088 _t1089 := p.parse_term() - term_4545 := _t1089 + term_3545 := _t1089 + _t1090 := p.parse_term() + term_4546 := _t1090 p.consumeLiteral(")") - _t1090 := &pb.RelTerm{} - _t1090.RelTermType = &pb.RelTerm_Term{Term: term543} _t1091 := &pb.RelTerm{} - _t1091.RelTermType = &pb.RelTerm_Term{Term: term_3544} + _t1091.RelTermType = &pb.RelTerm_Term{Term: term544} _t1092 := &pb.RelTerm{} - _t1092.RelTermType = &pb.RelTerm_Term{Term: term_4545} - _t1093 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1090, _t1091, _t1092}} - return _t1093 + _t1092.RelTermType = &pb.RelTerm_Term{Term: term_3545} + _t1093 := &pb.RelTerm{} + _t1093.RelTermType = &pb.RelTerm_Term{Term: term_4546} + _t1094 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1091, _t1092, _t1093}} + return _t1094 } -func (p *Parser) parse_divide() *pb.Primitive { +func (p *Parser) parse_multiply() *pb.Primitive { p.consumeLiteral("(") - p.consumeLiteral("/") - _t1094 := p.parse_term() - term546 := _t1094 + p.consumeLiteral("*") _t1095 := p.parse_term() - term_3547 := _t1095 + term547 := _t1095 _t1096 := p.parse_term() - term_4548 := _t1096 + term_3548 := _t1096 + _t1097 := p.parse_term() + term_4549 := _t1097 p.consumeLiteral(")") - _t1097 := &pb.RelTerm{} - _t1097.RelTermType = &pb.RelTerm_Term{Term: term546} _t1098 := &pb.RelTerm{} - _t1098.RelTermType = &pb.RelTerm_Term{Term: term_3547} + _t1098.RelTermType = &pb.RelTerm_Term{Term: term547} _t1099 := &pb.RelTerm{} - _t1099.RelTermType = &pb.RelTerm_Term{Term: term_4548} - _t1100 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1097, _t1098, _t1099}} - return _t1100 + _t1099.RelTermType = &pb.RelTerm_Term{Term: term_3548} + _t1100 := &pb.RelTerm{} + _t1100.RelTermType = &pb.RelTerm_Term{Term: term_4549} + _t1101 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1098, _t1099, _t1100}} + return _t1101 +} + +func (p *Parser) parse_divide() *pb.Primitive { + p.consumeLiteral("(") + p.consumeLiteral("/") + _t1102 := p.parse_term() + term550 := _t1102 + _t1103 := p.parse_term() + term_3551 := _t1103 + _t1104 := p.parse_term() + term_4552 := _t1104 + p.consumeLiteral(")") + _t1105 := &pb.RelTerm{} + _t1105.RelTermType = &pb.RelTerm_Term{Term: term550} + _t1106 := &pb.RelTerm{} + _t1106.RelTermType = &pb.RelTerm_Term{Term: term_3551} + _t1107 := &pb.RelTerm{} + _t1107.RelTermType = &pb.RelTerm_Term{Term: term_4552} + _t1108 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1105, _t1106, _t1107}} + return _t1108 } func (p *Parser) parse_rel_term() *pb.RelTerm { - var _t1101 int64 + var _t1109 int64 if p.matchLookaheadLiteral("true", 0) { - _t1101 = 1 + _t1109 = 1 } else { - var _t1102 int64 + var _t1110 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1102 = 1 + _t1110 = 1 } else { - var _t1103 int64 + var _t1111 int64 if p.matchLookaheadLiteral("false", 0) { - _t1103 = 1 + _t1111 = 1 } else { - var _t1104 int64 + var _t1112 int64 if p.matchLookaheadLiteral("(", 0) { - _t1104 = 1 + _t1112 = 1 } else { - var _t1105 int64 + var _t1113 int64 if p.matchLookaheadLiteral("#", 0) { - _t1105 = 0 + _t1113 = 0 } else { - var _t1106 int64 + var _t1114 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1106 = 1 + _t1114 = 1 } else { - var _t1107 int64 + var _t1115 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1107 = 1 + _t1115 = 1 } else { - var _t1108 int64 + var _t1116 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1108 = 1 + _t1116 = 1 } else { - var _t1109 int64 + var _t1117 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1109 = 1 + _t1117 = 1 } else { - var _t1110 int64 + var _t1118 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1110 = 1 + _t1118 = 1 } else { - var _t1111 int64 + var _t1119 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1111 = 1 + _t1119 = 1 } else { - var _t1112 int64 + var _t1120 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1112 = 1 + _t1120 = 1 } else { - _t1112 = -1 + _t1120 = -1 } - _t1111 = _t1112 + _t1119 = _t1120 } - _t1110 = _t1111 + _t1118 = _t1119 } - _t1109 = _t1110 + _t1117 = _t1118 } - _t1108 = _t1109 + _t1116 = _t1117 } - _t1107 = _t1108 + _t1115 = _t1116 } - _t1106 = _t1107 + _t1114 = _t1115 } - _t1105 = _t1106 + _t1113 = _t1114 } - _t1104 = _t1105 + _t1112 = _t1113 } - _t1103 = _t1104 + _t1111 = _t1112 } - _t1102 = _t1103 + _t1110 = _t1111 } - _t1101 = _t1102 - } - prediction549 := _t1101 - var _t1113 *pb.RelTerm - if prediction549 == 1 { - _t1114 := p.parse_term() - term551 := _t1114 - _t1115 := &pb.RelTerm{} - _t1115.RelTermType = &pb.RelTerm_Term{Term: term551} - _t1113 = _t1115 + _t1109 = _t1110 + } + prediction553 := _t1109 + var _t1121 *pb.RelTerm + if prediction553 == 1 { + _t1122 := p.parse_term() + term555 := _t1122 + _t1123 := &pb.RelTerm{} + _t1123.RelTermType = &pb.RelTerm_Term{Term: term555} + _t1121 = _t1123 } else { - var _t1116 *pb.RelTerm - if prediction549 == 0 { - _t1117 := p.parse_specialized_value() - specialized_value550 := _t1117 - _t1118 := &pb.RelTerm{} - _t1118.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value550} - _t1116 = _t1118 + var _t1124 *pb.RelTerm + if prediction553 == 0 { + _t1125 := p.parse_specialized_value() + specialized_value554 := _t1125 + _t1126 := &pb.RelTerm{} + _t1126.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value554} + _t1124 = _t1126 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1113 = _t1116 + _t1121 = _t1124 } - return _t1113 + return _t1121 } func (p *Parser) parse_specialized_value() *pb.Value { p.consumeLiteral("#") - _t1119 := p.parse_value() - value552 := _t1119 - return value552 + _t1127 := p.parse_value() + value556 := _t1127 + return value556 } func (p *Parser) parse_rel_atom() *pb.RelAtom { p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1120 := p.parse_name() - name553 := _t1120 - xs554 := []*pb.RelTerm{} - cond555 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond555 { - _t1121 := p.parse_rel_term() - item556 := _t1121 - xs554 = append(xs554, item556) - cond555 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1128 := p.parse_name() + name557 := _t1128 + xs558 := []*pb.RelTerm{} + cond559 := (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond559 { + _t1129 := p.parse_rel_term() + item560 := _t1129 + xs558 = append(xs558, item560) + cond559 = (((((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - rel_terms557 := xs554 + rel_terms561 := xs558 p.consumeLiteral(")") - _t1122 := &pb.RelAtom{Name: name553, Terms: rel_terms557} - return _t1122 + _t1130 := &pb.RelAtom{Name: name557, Terms: rel_terms561} + return _t1130 } func (p *Parser) parse_cast() *pb.Cast { p.consumeLiteral("(") p.consumeLiteral("cast") - _t1123 := p.parse_term() - term558 := _t1123 - _t1124 := p.parse_term() - term_3559 := _t1124 + _t1131 := p.parse_term() + term562 := _t1131 + _t1132 := p.parse_term() + term_3563 := _t1132 p.consumeLiteral(")") - _t1125 := &pb.Cast{Input: term558, Result: term_3559} - return _t1125 + _t1133 := &pb.Cast{Input: term562, Result: term_3563} + return _t1133 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs560 := []*pb.Attribute{} - cond561 := p.matchLookaheadLiteral("(", 0) - for cond561 { - _t1126 := p.parse_attribute() - item562 := _t1126 - xs560 = append(xs560, item562) - cond561 = p.matchLookaheadLiteral("(", 0) + xs564 := []*pb.Attribute{} + cond565 := p.matchLookaheadLiteral("(", 0) + for cond565 { + _t1134 := p.parse_attribute() + item566 := _t1134 + xs564 = append(xs564, item566) + cond565 = p.matchLookaheadLiteral("(", 0) } - attributes563 := xs560 + attributes567 := xs564 p.consumeLiteral(")") - return attributes563 + return attributes567 } func (p *Parser) parse_attribute() *pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1127 := p.parse_name() - name564 := _t1127 - xs565 := []*pb.Value{} - cond566 := (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) - for cond566 { - _t1128 := p.parse_value() - item567 := _t1128 - xs565 = append(xs565, item567) - cond566 = (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + _t1135 := p.parse_name() + name568 := _t1135 + xs569 := []*pb.Value{} + cond570 := (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) + for cond570 { + _t1136 := p.parse_value() + item571 := _t1136 + xs569 = append(xs569, item571) + cond570 = (((((((((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("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) } - values568 := xs565 + values572 := xs569 p.consumeLiteral(")") - _t1129 := &pb.Attribute{Name: name564, Args: values568} - return _t1129 + _t1137 := &pb.Attribute{Name: name568, Args: values572} + return _t1137 } func (p *Parser) parse_algorithm() *pb.Algorithm { p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs569 := []*pb.RelationId{} - cond570 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond570 { - _t1130 := p.parse_relation_id() - item571 := _t1130 - xs569 = append(xs569, item571) - cond570 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + xs573 := []*pb.RelationId{} + cond574 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond574 { + _t1138 := p.parse_relation_id() + item575 := _t1138 + xs573 = append(xs573, item575) + cond574 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) } - relation_ids572 := xs569 - _t1131 := p.parse_script() - script573 := _t1131 + relation_ids576 := xs573 + _t1139 := p.parse_script() + script577 := _t1139 p.consumeLiteral(")") - _t1132 := &pb.Algorithm{Global: relation_ids572, Body: script573} - return _t1132 + _t1140 := &pb.Algorithm{Global: relation_ids576, Body: script577} + return _t1140 } func (p *Parser) parse_script() *pb.Script { p.consumeLiteral("(") p.consumeLiteral("script") - xs574 := []*pb.Construct{} - cond575 := p.matchLookaheadLiteral("(", 0) - for cond575 { - _t1133 := p.parse_construct() - item576 := _t1133 - xs574 = append(xs574, item576) - cond575 = p.matchLookaheadLiteral("(", 0) + xs578 := []*pb.Construct{} + cond579 := p.matchLookaheadLiteral("(", 0) + for cond579 { + _t1141 := p.parse_construct() + item580 := _t1141 + xs578 = append(xs578, item580) + cond579 = p.matchLookaheadLiteral("(", 0) } - constructs577 := xs574 + constructs581 := xs578 p.consumeLiteral(")") - _t1134 := &pb.Script{Constructs: constructs577} - return _t1134 + _t1142 := &pb.Script{Constructs: constructs581} + return _t1142 } func (p *Parser) parse_construct() *pb.Construct { - var _t1135 int64 + var _t1143 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1136 int64 + var _t1144 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1136 = 1 + _t1144 = 1 } else { - var _t1137 int64 + var _t1145 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1137 = 1 + _t1145 = 1 } else { - var _t1138 int64 + var _t1146 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1138 = 1 + _t1146 = 1 } else { - var _t1139 int64 + var _t1147 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1139 = 0 + _t1147 = 0 } else { - var _t1140 int64 + var _t1148 int64 if p.matchLookaheadLiteral("break", 1) { - _t1140 = 1 + _t1148 = 1 } else { - var _t1141 int64 + var _t1149 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1141 = 1 + _t1149 = 1 } else { - _t1141 = -1 + _t1149 = -1 } - _t1140 = _t1141 + _t1148 = _t1149 } - _t1139 = _t1140 + _t1147 = _t1148 } - _t1138 = _t1139 + _t1146 = _t1147 } - _t1137 = _t1138 + _t1145 = _t1146 } - _t1136 = _t1137 + _t1144 = _t1145 } - _t1135 = _t1136 + _t1143 = _t1144 } else { - _t1135 = -1 - } - prediction578 := _t1135 - var _t1142 *pb.Construct - if prediction578 == 1 { - _t1143 := p.parse_instruction() - instruction580 := _t1143 - _t1144 := &pb.Construct{} - _t1144.ConstructType = &pb.Construct_Instruction{Instruction: instruction580} - _t1142 = _t1144 + _t1143 = -1 + } + prediction582 := _t1143 + var _t1150 *pb.Construct + if prediction582 == 1 { + _t1151 := p.parse_instruction() + instruction584 := _t1151 + _t1152 := &pb.Construct{} + _t1152.ConstructType = &pb.Construct_Instruction{Instruction: instruction584} + _t1150 = _t1152 } else { - var _t1145 *pb.Construct - if prediction578 == 0 { - _t1146 := p.parse_loop() - loop579 := _t1146 - _t1147 := &pb.Construct{} - _t1147.ConstructType = &pb.Construct_Loop{Loop: loop579} - _t1145 = _t1147 + var _t1153 *pb.Construct + if prediction582 == 0 { + _t1154 := p.parse_loop() + loop583 := _t1154 + _t1155 := &pb.Construct{} + _t1155.ConstructType = &pb.Construct_Loop{Loop: loop583} + _t1153 = _t1155 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1142 = _t1145 + _t1150 = _t1153 } - return _t1142 + return _t1150 } func (p *Parser) parse_loop() *pb.Loop { p.consumeLiteral("(") p.consumeLiteral("loop") - _t1148 := p.parse_init() - init581 := _t1148 - _t1149 := p.parse_script() - script582 := _t1149 + _t1156 := p.parse_init() + init585 := _t1156 + _t1157 := p.parse_script() + script586 := _t1157 p.consumeLiteral(")") - _t1150 := &pb.Loop{Init: init581, Body: script582} - return _t1150 + _t1158 := &pb.Loop{Init: init585, Body: script586} + return _t1158 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs583 := []*pb.Instruction{} - cond584 := p.matchLookaheadLiteral("(", 0) - for cond584 { - _t1151 := p.parse_instruction() - item585 := _t1151 - xs583 = append(xs583, item585) - cond584 = p.matchLookaheadLiteral("(", 0) + xs587 := []*pb.Instruction{} + cond588 := p.matchLookaheadLiteral("(", 0) + for cond588 { + _t1159 := p.parse_instruction() + item589 := _t1159 + xs587 = append(xs587, item589) + cond588 = p.matchLookaheadLiteral("(", 0) } - instructions586 := xs583 + instructions590 := xs587 p.consumeLiteral(")") - return instructions586 + return instructions590 } func (p *Parser) parse_instruction() *pb.Instruction { - var _t1152 int64 + var _t1160 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1153 int64 + var _t1161 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1153 = 1 + _t1161 = 1 } else { - var _t1154 int64 + var _t1162 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1154 = 4 + _t1162 = 4 } else { - var _t1155 int64 + var _t1163 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1155 = 3 + _t1163 = 3 } else { - var _t1156 int64 + var _t1164 int64 if p.matchLookaheadLiteral("break", 1) { - _t1156 = 2 + _t1164 = 2 } else { - var _t1157 int64 + var _t1165 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1157 = 0 + _t1165 = 0 } else { - _t1157 = -1 + _t1165 = -1 } - _t1156 = _t1157 + _t1164 = _t1165 } - _t1155 = _t1156 + _t1163 = _t1164 } - _t1154 = _t1155 + _t1162 = _t1163 } - _t1153 = _t1154 + _t1161 = _t1162 } - _t1152 = _t1153 + _t1160 = _t1161 } else { - _t1152 = -1 - } - prediction587 := _t1152 - var _t1158 *pb.Instruction - if prediction587 == 4 { - _t1159 := p.parse_monus_def() - monus_def592 := _t1159 - _t1160 := &pb.Instruction{} - _t1160.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def592} - _t1158 = _t1160 + _t1160 = -1 + } + prediction591 := _t1160 + var _t1166 *pb.Instruction + if prediction591 == 4 { + _t1167 := p.parse_monus_def() + monus_def596 := _t1167 + _t1168 := &pb.Instruction{} + _t1168.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def596} + _t1166 = _t1168 } else { - var _t1161 *pb.Instruction - if prediction587 == 3 { - _t1162 := p.parse_monoid_def() - monoid_def591 := _t1162 - _t1163 := &pb.Instruction{} - _t1163.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def591} - _t1161 = _t1163 + var _t1169 *pb.Instruction + if prediction591 == 3 { + _t1170 := p.parse_monoid_def() + monoid_def595 := _t1170 + _t1171 := &pb.Instruction{} + _t1171.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def595} + _t1169 = _t1171 } else { - var _t1164 *pb.Instruction - if prediction587 == 2 { - _t1165 := p.parse_break() - break590 := _t1165 - _t1166 := &pb.Instruction{} - _t1166.InstrType = &pb.Instruction_Break{Break: break590} - _t1164 = _t1166 + var _t1172 *pb.Instruction + if prediction591 == 2 { + _t1173 := p.parse_break() + break594 := _t1173 + _t1174 := &pb.Instruction{} + _t1174.InstrType = &pb.Instruction_Break{Break: break594} + _t1172 = _t1174 } else { - var _t1167 *pb.Instruction - if prediction587 == 1 { - _t1168 := p.parse_upsert() - upsert589 := _t1168 - _t1169 := &pb.Instruction{} - _t1169.InstrType = &pb.Instruction_Upsert{Upsert: upsert589} - _t1167 = _t1169 + var _t1175 *pb.Instruction + if prediction591 == 1 { + _t1176 := p.parse_upsert() + upsert593 := _t1176 + _t1177 := &pb.Instruction{} + _t1177.InstrType = &pb.Instruction_Upsert{Upsert: upsert593} + _t1175 = _t1177 } else { - var _t1170 *pb.Instruction - if prediction587 == 0 { - _t1171 := p.parse_assign() - assign588 := _t1171 - _t1172 := &pb.Instruction{} - _t1172.InstrType = &pb.Instruction_Assign{Assign: assign588} - _t1170 = _t1172 + var _t1178 *pb.Instruction + if prediction591 == 0 { + _t1179 := p.parse_assign() + assign592 := _t1179 + _t1180 := &pb.Instruction{} + _t1180.InstrType = &pb.Instruction_Assign{Assign: assign592} + _t1178 = _t1180 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1167 = _t1170 + _t1175 = _t1178 } - _t1164 = _t1167 + _t1172 = _t1175 } - _t1161 = _t1164 + _t1169 = _t1172 } - _t1158 = _t1161 + _t1166 = _t1169 } - return _t1158 + return _t1166 } func (p *Parser) parse_assign() *pb.Assign { p.consumeLiteral("(") p.consumeLiteral("assign") - _t1173 := p.parse_relation_id() - relation_id593 := _t1173 - _t1174 := p.parse_abstraction() - abstraction594 := _t1174 - var _t1175 []*pb.Attribute + _t1181 := p.parse_relation_id() + relation_id597 := _t1181 + _t1182 := p.parse_abstraction() + abstraction598 := _t1182 + var _t1183 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1176 := p.parse_attrs() - _t1175 = _t1176 + _t1184 := p.parse_attrs() + _t1183 = _t1184 } - attrs595 := _t1175 + attrs599 := _t1183 p.consumeLiteral(")") - _t1177 := attrs595 - if attrs595 == nil { - _t1177 = []*pb.Attribute{} + _t1185 := attrs599 + if attrs599 == nil { + _t1185 = []*pb.Attribute{} } - _t1178 := &pb.Assign{Name: relation_id593, Body: abstraction594, Attrs: _t1177} - return _t1178 + _t1186 := &pb.Assign{Name: relation_id597, Body: abstraction598, Attrs: _t1185} + return _t1186 } func (p *Parser) parse_upsert() *pb.Upsert { p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1179 := p.parse_relation_id() - relation_id596 := _t1179 - _t1180 := p.parse_abstraction_with_arity() - abstraction_with_arity597 := _t1180 - var _t1181 []*pb.Attribute + _t1187 := p.parse_relation_id() + relation_id600 := _t1187 + _t1188 := p.parse_abstraction_with_arity() + abstraction_with_arity601 := _t1188 + var _t1189 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1182 := p.parse_attrs() - _t1181 = _t1182 + _t1190 := p.parse_attrs() + _t1189 = _t1190 } - attrs598 := _t1181 + attrs602 := _t1189 p.consumeLiteral(")") - _t1183 := attrs598 - if attrs598 == nil { - _t1183 = []*pb.Attribute{} + _t1191 := attrs602 + if attrs602 == nil { + _t1191 = []*pb.Attribute{} } - _t1184 := &pb.Upsert{Name: relation_id596, Body: abstraction_with_arity597[0].(*pb.Abstraction), Attrs: _t1183, ValueArity: abstraction_with_arity597[1].(int64)} - return _t1184 + _t1192 := &pb.Upsert{Name: relation_id600, Body: abstraction_with_arity601[0].(*pb.Abstraction), Attrs: _t1191, ValueArity: abstraction_with_arity601[1].(int64)} + return _t1192 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1185 := p.parse_bindings() - bindings599 := _t1185 - _t1186 := p.parse_formula() - formula600 := _t1186 + _t1193 := p.parse_bindings() + bindings603 := _t1193 + _t1194 := p.parse_formula() + formula604 := _t1194 p.consumeLiteral(")") - _t1187 := &pb.Abstraction{Vars: listConcat(bindings599[0].([]*pb.Binding), bindings599[1].([]*pb.Binding)), Value: formula600} - return []interface{}{_t1187, int64(len(bindings599[1].([]*pb.Binding)))} + _t1195 := &pb.Abstraction{Vars: listConcat(bindings603[0].([]*pb.Binding), bindings603[1].([]*pb.Binding)), Value: formula604} + return []interface{}{_t1195, int64(len(bindings603[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { p.consumeLiteral("(") p.consumeLiteral("break") - _t1188 := p.parse_relation_id() - relation_id601 := _t1188 - _t1189 := p.parse_abstraction() - abstraction602 := _t1189 - var _t1190 []*pb.Attribute + _t1196 := p.parse_relation_id() + relation_id605 := _t1196 + _t1197 := p.parse_abstraction() + abstraction606 := _t1197 + var _t1198 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1191 := p.parse_attrs() - _t1190 = _t1191 + _t1199 := p.parse_attrs() + _t1198 = _t1199 } - attrs603 := _t1190 + attrs607 := _t1198 p.consumeLiteral(")") - _t1192 := attrs603 - if attrs603 == nil { - _t1192 = []*pb.Attribute{} + _t1200 := attrs607 + if attrs607 == nil { + _t1200 = []*pb.Attribute{} } - _t1193 := &pb.Break{Name: relation_id601, Body: abstraction602, Attrs: _t1192} - return _t1193 + _t1201 := &pb.Break{Name: relation_id605, Body: abstraction606, Attrs: _t1200} + return _t1201 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1194 := p.parse_monoid() - monoid604 := _t1194 - _t1195 := p.parse_relation_id() - relation_id605 := _t1195 - _t1196 := p.parse_abstraction_with_arity() - abstraction_with_arity606 := _t1196 - var _t1197 []*pb.Attribute + _t1202 := p.parse_monoid() + monoid608 := _t1202 + _t1203 := p.parse_relation_id() + relation_id609 := _t1203 + _t1204 := p.parse_abstraction_with_arity() + abstraction_with_arity610 := _t1204 + var _t1205 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1198 := p.parse_attrs() - _t1197 = _t1198 + _t1206 := p.parse_attrs() + _t1205 = _t1206 } - attrs607 := _t1197 + attrs611 := _t1205 p.consumeLiteral(")") - _t1199 := attrs607 - if attrs607 == nil { - _t1199 = []*pb.Attribute{} + _t1207 := attrs611 + if attrs611 == nil { + _t1207 = []*pb.Attribute{} } - _t1200 := &pb.MonoidDef{Monoid: monoid604, Name: relation_id605, Body: abstraction_with_arity606[0].(*pb.Abstraction), Attrs: _t1199, ValueArity: abstraction_with_arity606[1].(int64)} - return _t1200 + _t1208 := &pb.MonoidDef{Monoid: monoid608, Name: relation_id609, Body: abstraction_with_arity610[0].(*pb.Abstraction), Attrs: _t1207, ValueArity: abstraction_with_arity610[1].(int64)} + return _t1208 } func (p *Parser) parse_monoid() *pb.Monoid { - var _t1201 int64 + var _t1209 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1202 int64 + var _t1210 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1202 = 3 + _t1210 = 3 } else { - var _t1203 int64 + var _t1211 int64 if p.matchLookaheadLiteral("or", 1) { - _t1203 = 0 + _t1211 = 0 } else { - var _t1204 int64 + var _t1212 int64 if p.matchLookaheadLiteral("min", 1) { - _t1204 = 1 + _t1212 = 1 } else { - var _t1205 int64 + var _t1213 int64 if p.matchLookaheadLiteral("max", 1) { - _t1205 = 2 + _t1213 = 2 } else { - _t1205 = -1 + _t1213 = -1 } - _t1204 = _t1205 + _t1212 = _t1213 } - _t1203 = _t1204 + _t1211 = _t1212 } - _t1202 = _t1203 + _t1210 = _t1211 } - _t1201 = _t1202 + _t1209 = _t1210 } else { - _t1201 = -1 - } - prediction608 := _t1201 - var _t1206 *pb.Monoid - if prediction608 == 3 { - _t1207 := p.parse_sum_monoid() - sum_monoid612 := _t1207 - _t1208 := &pb.Monoid{} - _t1208.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid612} - _t1206 = _t1208 + _t1209 = -1 + } + prediction612 := _t1209 + var _t1214 *pb.Monoid + if prediction612 == 3 { + _t1215 := p.parse_sum_monoid() + sum_monoid616 := _t1215 + _t1216 := &pb.Monoid{} + _t1216.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid616} + _t1214 = _t1216 } else { - var _t1209 *pb.Monoid - if prediction608 == 2 { - _t1210 := p.parse_max_monoid() - max_monoid611 := _t1210 - _t1211 := &pb.Monoid{} - _t1211.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid611} - _t1209 = _t1211 + var _t1217 *pb.Monoid + if prediction612 == 2 { + _t1218 := p.parse_max_monoid() + max_monoid615 := _t1218 + _t1219 := &pb.Monoid{} + _t1219.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid615} + _t1217 = _t1219 } else { - var _t1212 *pb.Monoid - if prediction608 == 1 { - _t1213 := p.parse_min_monoid() - min_monoid610 := _t1213 - _t1214 := &pb.Monoid{} - _t1214.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid610} - _t1212 = _t1214 + var _t1220 *pb.Monoid + if prediction612 == 1 { + _t1221 := p.parse_min_monoid() + min_monoid614 := _t1221 + _t1222 := &pb.Monoid{} + _t1222.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid614} + _t1220 = _t1222 } else { - var _t1215 *pb.Monoid - if prediction608 == 0 { - _t1216 := p.parse_or_monoid() - or_monoid609 := _t1216 - _t1217 := &pb.Monoid{} - _t1217.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid609} - _t1215 = _t1217 + var _t1223 *pb.Monoid + if prediction612 == 0 { + _t1224 := p.parse_or_monoid() + or_monoid613 := _t1224 + _t1225 := &pb.Monoid{} + _t1225.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid613} + _t1223 = _t1225 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1212 = _t1215 + _t1220 = _t1223 } - _t1209 = _t1212 + _t1217 = _t1220 } - _t1206 = _t1209 + _t1214 = _t1217 } - return _t1206 + return _t1214 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1218 := &pb.OrMonoid{} - return _t1218 + _t1226 := &pb.OrMonoid{} + return _t1226 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { p.consumeLiteral("(") p.consumeLiteral("min") - _t1219 := p.parse_type() - type613 := _t1219 + _t1227 := p.parse_type() + type617 := _t1227 p.consumeLiteral(")") - _t1220 := &pb.MinMonoid{Type: type613} - return _t1220 + _t1228 := &pb.MinMonoid{Type: type617} + return _t1228 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { p.consumeLiteral("(") p.consumeLiteral("max") - _t1221 := p.parse_type() - type614 := _t1221 + _t1229 := p.parse_type() + type618 := _t1229 p.consumeLiteral(")") - _t1222 := &pb.MaxMonoid{Type: type614} - return _t1222 + _t1230 := &pb.MaxMonoid{Type: type618} + return _t1230 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { p.consumeLiteral("(") p.consumeLiteral("sum") - _t1223 := p.parse_type() - type615 := _t1223 + _t1231 := p.parse_type() + type619 := _t1231 p.consumeLiteral(")") - _t1224 := &pb.SumMonoid{Type: type615} - return _t1224 + _t1232 := &pb.SumMonoid{Type: type619} + return _t1232 } func (p *Parser) parse_monus_def() *pb.MonusDef { p.consumeLiteral("(") p.consumeLiteral("monus") - _t1225 := p.parse_monoid() - monoid616 := _t1225 - _t1226 := p.parse_relation_id() - relation_id617 := _t1226 - _t1227 := p.parse_abstraction_with_arity() - abstraction_with_arity618 := _t1227 - var _t1228 []*pb.Attribute + _t1233 := p.parse_monoid() + monoid620 := _t1233 + _t1234 := p.parse_relation_id() + relation_id621 := _t1234 + _t1235 := p.parse_abstraction_with_arity() + abstraction_with_arity622 := _t1235 + var _t1236 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1229 := p.parse_attrs() - _t1228 = _t1229 + _t1237 := p.parse_attrs() + _t1236 = _t1237 } - attrs619 := _t1228 + attrs623 := _t1236 p.consumeLiteral(")") - _t1230 := attrs619 - if attrs619 == nil { - _t1230 = []*pb.Attribute{} + _t1238 := attrs623 + if attrs623 == nil { + _t1238 = []*pb.Attribute{} } - _t1231 := &pb.MonusDef{Monoid: monoid616, Name: relation_id617, Body: abstraction_with_arity618[0].(*pb.Abstraction), Attrs: _t1230, ValueArity: abstraction_with_arity618[1].(int64)} - return _t1231 + _t1239 := &pb.MonusDef{Monoid: monoid620, Name: relation_id621, Body: abstraction_with_arity622[0].(*pb.Abstraction), Attrs: _t1238, ValueArity: abstraction_with_arity622[1].(int64)} + return _t1239 } func (p *Parser) parse_constraint() *pb.Constraint { p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1232 := p.parse_relation_id() - relation_id620 := _t1232 - _t1233 := p.parse_abstraction() - abstraction621 := _t1233 - _t1234 := p.parse_functional_dependency_keys() - functional_dependency_keys622 := _t1234 - _t1235 := p.parse_functional_dependency_values() - functional_dependency_values623 := _t1235 + _t1240 := p.parse_relation_id() + relation_id624 := _t1240 + _t1241 := p.parse_abstraction() + abstraction625 := _t1241 + _t1242 := p.parse_functional_dependency_keys() + functional_dependency_keys626 := _t1242 + _t1243 := p.parse_functional_dependency_values() + functional_dependency_values627 := _t1243 p.consumeLiteral(")") - _t1236 := &pb.FunctionalDependency{Guard: abstraction621, Keys: functional_dependency_keys622, Values: functional_dependency_values623} - _t1237 := &pb.Constraint{Name: relation_id620} - _t1237.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1236} - return _t1237 + _t1244 := &pb.FunctionalDependency{Guard: abstraction625, Keys: functional_dependency_keys626, Values: functional_dependency_values627} + _t1245 := &pb.Constraint{Name: relation_id624} + _t1245.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1244} + return _t1245 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs624 := []*pb.Var{} - cond625 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond625 { - _t1238 := p.parse_var() - item626 := _t1238 - xs624 = append(xs624, item626) - cond625 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars627 := xs624 - p.consumeLiteral(")") - return vars627 -} - -func (p *Parser) parse_functional_dependency_values() []*pb.Var { - p.consumeLiteral("(") - p.consumeLiteral("values") xs628 := []*pb.Var{} cond629 := p.matchLookaheadTerminal("SYMBOL", 0) for cond629 { - _t1239 := p.parse_var() - item630 := _t1239 + _t1246 := p.parse_var() + item630 := _t1246 xs628 = append(xs628, item630) cond629 = p.matchLookaheadTerminal("SYMBOL", 0) } @@ -3205,158 +3189,158 @@ func (p *Parser) parse_functional_dependency_values() []*pb.Var { return vars631 } +func (p *Parser) parse_functional_dependency_values() []*pb.Var { + p.consumeLiteral("(") + p.consumeLiteral("values") + xs632 := []*pb.Var{} + cond633 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond633 { + _t1247 := p.parse_var() + item634 := _t1247 + xs632 = append(xs632, item634) + cond633 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars635 := xs632 + p.consumeLiteral(")") + return vars635 +} + func (p *Parser) parse_data() *pb.Data { - var _t1240 int64 + var _t1248 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1241 int64 + var _t1249 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1241 = 0 + _t1249 = 0 } else { - var _t1242 int64 + var _t1250 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1242 = 2 + _t1250 = 2 } else { - var _t1243 int64 + var _t1251 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1243 = 1 + _t1251 = 1 } else { - _t1243 = -1 + _t1251 = -1 } - _t1242 = _t1243 + _t1250 = _t1251 } - _t1241 = _t1242 + _t1249 = _t1250 } - _t1240 = _t1241 + _t1248 = _t1249 } else { - _t1240 = -1 - } - prediction632 := _t1240 - var _t1244 *pb.Data - if prediction632 == 2 { - _t1245 := p.parse_csv_data() - csv_data635 := _t1245 - _t1246 := &pb.Data{} - _t1246.DataType = &pb.Data_CsvData{CsvData: csv_data635} - _t1244 = _t1246 + _t1248 = -1 + } + prediction636 := _t1248 + var _t1252 *pb.Data + if prediction636 == 2 { + _t1253 := p.parse_csv_data() + csv_data639 := _t1253 + _t1254 := &pb.Data{} + _t1254.DataType = &pb.Data_CsvData{CsvData: csv_data639} + _t1252 = _t1254 } else { - var _t1247 *pb.Data - if prediction632 == 1 { - _t1248 := p.parse_betree_relation() - betree_relation634 := _t1248 - _t1249 := &pb.Data{} - _t1249.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation634} - _t1247 = _t1249 + var _t1255 *pb.Data + if prediction636 == 1 { + _t1256 := p.parse_betree_relation() + betree_relation638 := _t1256 + _t1257 := &pb.Data{} + _t1257.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation638} + _t1255 = _t1257 } else { - var _t1250 *pb.Data - if prediction632 == 0 { - _t1251 := p.parse_edb() - edb633 := _t1251 - _t1252 := &pb.Data{} - _t1252.DataType = &pb.Data_Edb{Edb: edb633} - _t1250 = _t1252 + var _t1258 *pb.Data + if prediction636 == 0 { + _t1259 := p.parse_edb() + edb637 := _t1259 + _t1260 := &pb.Data{} + _t1260.DataType = &pb.Data_Edb{Edb: edb637} + _t1258 = _t1260 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1247 = _t1250 + _t1255 = _t1258 } - _t1244 = _t1247 + _t1252 = _t1255 } - return _t1244 + return _t1252 } func (p *Parser) parse_edb() *pb.EDB { p.consumeLiteral("(") p.consumeLiteral("edb") - _t1253 := p.parse_relation_id() - relation_id636 := _t1253 - _t1254 := p.parse_edb_path() - edb_path637 := _t1254 - _t1255 := p.parse_edb_types() - edb_types638 := _t1255 - p.consumeLiteral(")") - _t1256 := &pb.EDB{TargetId: relation_id636, Path: edb_path637, Types: edb_types638} - return _t1256 + _t1261 := p.parse_relation_id() + relation_id640 := _t1261 + _t1262 := p.parse_edb_path() + edb_path641 := _t1262 + _t1263 := p.parse_edb_types() + edb_types642 := _t1263 + p.consumeLiteral(")") + _t1264 := &pb.EDB{TargetId: relation_id640, Path: edb_path641, Types: edb_types642} + return _t1264 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs639 := []string{} - cond640 := p.matchLookaheadTerminal("STRING", 0) - for cond640 { - item641 := p.consumeTerminal("STRING").Value.str - xs639 = append(xs639, item641) - cond640 = p.matchLookaheadTerminal("STRING", 0) - } - strings642 := xs639 + xs643 := []string{} + cond644 := p.matchLookaheadTerminal("STRING", 0) + for cond644 { + item645 := p.consumeTerminal("STRING").Value.str + xs643 = append(xs643, item645) + cond644 = p.matchLookaheadTerminal("STRING", 0) + } + strings646 := xs643 p.consumeLiteral("]") - return strings642 + return strings646 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs643 := []*pb.Type{} - cond644 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond644 { - _t1257 := p.parse_type() - item645 := _t1257 - xs643 = append(xs643, item645) - cond644 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + xs647 := []*pb.Type{} + cond648 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond648 { + _t1265 := p.parse_type() + item649 := _t1265 + xs647 = append(xs647, item649) + cond648 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } - types646 := xs643 + types650 := xs647 p.consumeLiteral("]") - return types646 + return types650 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1258 := p.parse_relation_id() - relation_id647 := _t1258 - _t1259 := p.parse_betree_info() - betree_info648 := _t1259 + _t1266 := p.parse_relation_id() + relation_id651 := _t1266 + _t1267 := p.parse_betree_info() + betree_info652 := _t1267 p.consumeLiteral(")") - _t1260 := &pb.BeTreeRelation{Name: relation_id647, RelationInfo: betree_info648} - return _t1260 + _t1268 := &pb.BeTreeRelation{Name: relation_id651, RelationInfo: betree_info652} + return _t1268 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1261 := p.parse_betree_info_key_types() - betree_info_key_types649 := _t1261 - _t1262 := p.parse_betree_info_value_types() - betree_info_value_types650 := _t1262 - _t1263 := p.parse_config_dict() - config_dict651 := _t1263 - p.consumeLiteral(")") - _t1264 := p.construct_betree_info(betree_info_key_types649, betree_info_value_types650, config_dict651) - return _t1264 + _t1269 := p.parse_betree_info_key_types() + betree_info_key_types653 := _t1269 + _t1270 := p.parse_betree_info_value_types() + betree_info_value_types654 := _t1270 + _t1271 := p.parse_config_dict() + config_dict655 := _t1271 + p.consumeLiteral(")") + _t1272 := p.construct_betree_info(betree_info_key_types653, betree_info_value_types654, config_dict655) + return _t1272 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs652 := []*pb.Type{} - cond653 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond653 { - _t1265 := p.parse_type() - item654 := _t1265 - xs652 = append(xs652, item654) - cond653 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types655 := xs652 - p.consumeLiteral(")") - return types655 -} - -func (p *Parser) parse_betree_info_value_types() []*pb.Type { - p.consumeLiteral("(") - p.consumeLiteral("value_types") xs656 := []*pb.Type{} cond657 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) for cond657 { - _t1266 := p.parse_type() - item658 := _t1266 + _t1273 := p.parse_type() + item658 := _t1273 xs656 = append(xs656, item658) cond657 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) } @@ -3365,425 +3349,455 @@ func (p *Parser) parse_betree_info_value_types() []*pb.Type { return types659 } +func (p *Parser) parse_betree_info_value_types() []*pb.Type { + p.consumeLiteral("(") + p.consumeLiteral("value_types") + xs660 := []*pb.Type{} + cond661 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond661 { + _t1274 := p.parse_type() + item662 := _t1274 + xs660 = append(xs660, item662) + cond661 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types663 := xs660 + p.consumeLiteral(")") + return types663 +} + func (p *Parser) parse_csv_data() *pb.CSVData { p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1267 := p.parse_csvlocator() - csvlocator660 := _t1267 - _t1268 := p.parse_csv_config() - csv_config661 := _t1268 - _t1269 := p.parse_gnf_columns() - gnf_columns662 := _t1269 - _t1270 := p.parse_csv_asof() - csv_asof663 := _t1270 - p.consumeLiteral(")") - _t1271 := &pb.CSVData{Locator: csvlocator660, Config: csv_config661, Columns: gnf_columns662, Asof: csv_asof663} - return _t1271 + _t1275 := p.parse_csvlocator() + csvlocator664 := _t1275 + _t1276 := p.parse_csv_config() + csv_config665 := _t1276 + _t1277 := p.parse_gnf_columns() + gnf_columns666 := _t1277 + _t1278 := p.parse_csv_asof() + csv_asof667 := _t1278 + p.consumeLiteral(")") + _t1279 := &pb.CSVData{Locator: csvlocator664, Config: csv_config665, Columns: gnf_columns666, Asof: csv_asof667} + return _t1279 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1272 []string + var _t1280 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1273 := p.parse_csv_locator_paths() - _t1272 = _t1273 + _t1281 := p.parse_csv_locator_paths() + _t1280 = _t1281 } - csv_locator_paths664 := _t1272 - var _t1274 *string + csv_locator_paths668 := _t1280 + var _t1282 *string if p.matchLookaheadLiteral("(", 0) { - _t1275 := p.parse_csv_locator_inline_data() - _t1274 = ptr(_t1275) + _t1283 := p.parse_csv_locator_inline_data() + _t1282 = ptr(_t1283) } - csv_locator_inline_data665 := _t1274 + csv_locator_inline_data669 := _t1282 p.consumeLiteral(")") - _t1276 := csv_locator_paths664 - if csv_locator_paths664 == nil { - _t1276 = []string{} + _t1284 := csv_locator_paths668 + if csv_locator_paths668 == nil { + _t1284 = []string{} } - _t1277 := &pb.CSVLocator{Paths: _t1276, InlineData: []byte(deref(csv_locator_inline_data665, ""))} - return _t1277 + _t1285 := &pb.CSVLocator{Paths: _t1284, InlineData: []byte(deref(csv_locator_inline_data669, ""))} + return _t1285 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs666 := []string{} - cond667 := p.matchLookaheadTerminal("STRING", 0) - for cond667 { - item668 := p.consumeTerminal("STRING").Value.str - xs666 = append(xs666, item668) - cond667 = p.matchLookaheadTerminal("STRING", 0) + xs670 := []string{} + cond671 := p.matchLookaheadTerminal("STRING", 0) + for cond671 { + item672 := p.consumeTerminal("STRING").Value.str + xs670 = append(xs670, item672) + cond671 = p.matchLookaheadTerminal("STRING", 0) } - strings669 := xs666 + strings673 := xs670 p.consumeLiteral(")") - return strings669 + return strings673 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - string670 := p.consumeTerminal("STRING").Value.str + string674 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string670 + return string674 } func (p *Parser) parse_csv_config() *pb.CSVConfig { p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1278 := p.parse_config_dict() - config_dict671 := _t1278 + _t1286 := p.parse_config_dict() + config_dict675 := _t1286 p.consumeLiteral(")") - _t1279 := p.construct_csv_config(config_dict671) - return _t1279 + _t1287 := p.construct_csv_config(config_dict675) + return _t1287 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs672 := []*pb.GNFColumn{} - cond673 := p.matchLookaheadLiteral("(", 0) - for cond673 { - _t1280 := p.parse_gnf_column() - item674 := _t1280 - xs672 = append(xs672, item674) - cond673 = p.matchLookaheadLiteral("(", 0) + xs676 := []*pb.GNFColumn{} + cond677 := p.matchLookaheadLiteral("(", 0) + for cond677 { + _t1288 := p.parse_gnf_column() + item678 := _t1288 + xs676 = append(xs676, item678) + cond677 = p.matchLookaheadLiteral("(", 0) } - gnf_columns675 := xs672 + gnf_columns679 := xs676 p.consumeLiteral(")") - return gnf_columns675 + return gnf_columns679 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("column") - _t1281 := p.parse_gnf_column_path() - gnf_column_path676 := _t1281 - var _t1282 *pb.RelationId + _t1289 := p.parse_gnf_column_path() + gnf_column_path680 := _t1289 + var _t1290 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t1283 := p.parse_relation_id() - _t1282 = _t1283 + _t1291 := p.parse_relation_id() + _t1290 = _t1291 } - relation_id677 := _t1282 + relation_id681 := _t1290 p.consumeLiteral("[") - xs678 := []*pb.Type{} - cond679 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond679 { - _t1284 := p.parse_type() - item680 := _t1284 - xs678 = append(xs678, item680) - cond679 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types681 := xs678 + xs682 := []*pb.Type{} + cond683 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond683 { + _t1292 := p.parse_type() + item684 := _t1292 + xs682 = append(xs682, item684) + cond683 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types685 := xs682 p.consumeLiteral("]") p.consumeLiteral(")") - _t1285 := &pb.GNFColumn{ColumnPath: gnf_column_path676, TargetId: relation_id677, Types: types681} - return _t1285 + _t1293 := &pb.GNFColumn{ColumnPath: gnf_column_path680, TargetId: relation_id681, Types: types685} + return _t1293 } func (p *Parser) parse_gnf_column_path() []string { - var _t1286 int64 + var _t1294 int64 if p.matchLookaheadLiteral("[", 0) { - _t1286 = 1 + _t1294 = 1 } else { - var _t1287 int64 + var _t1295 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1287 = 0 + _t1295 = 0 } else { - _t1287 = -1 + _t1295 = -1 } - _t1286 = _t1287 + _t1294 = _t1295 } - prediction682 := _t1286 - var _t1288 []string - if prediction682 == 1 { + prediction686 := _t1294 + var _t1296 []string + if prediction686 == 1 { p.consumeLiteral("[") - xs684 := []string{} - cond685 := p.matchLookaheadTerminal("STRING", 0) - for cond685 { - item686 := p.consumeTerminal("STRING").Value.str - xs684 = append(xs684, item686) - cond685 = p.matchLookaheadTerminal("STRING", 0) + xs688 := []string{} + cond689 := p.matchLookaheadTerminal("STRING", 0) + for cond689 { + item690 := p.consumeTerminal("STRING").Value.str + xs688 = append(xs688, item690) + cond689 = p.matchLookaheadTerminal("STRING", 0) } - strings687 := xs684 + strings691 := xs688 p.consumeLiteral("]") - _t1288 = strings687 + _t1296 = strings691 } else { - var _t1289 []string - if prediction682 == 0 { - string683 := p.consumeTerminal("STRING").Value.str - _ = string683 - _t1289 = []string{string683} + var _t1297 []string + if prediction686 == 0 { + string687 := p.consumeTerminal("STRING").Value.str + _ = string687 + _t1297 = []string{string687} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1288 = _t1289 + _t1296 = _t1297 } - return _t1288 + return _t1296 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string688 := p.consumeTerminal("STRING").Value.str + string692 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string688 + return string692 } func (p *Parser) parse_undefine() *pb.Undefine { p.consumeLiteral("(") p.consumeLiteral("undefine") - _t1290 := p.parse_fragment_id() - fragment_id689 := _t1290 + _t1298 := p.parse_fragment_id() + fragment_id693 := _t1298 p.consumeLiteral(")") - _t1291 := &pb.Undefine{FragmentId: fragment_id689} - return _t1291 + _t1299 := &pb.Undefine{FragmentId: fragment_id693} + return _t1299 } func (p *Parser) parse_context() *pb.Context { p.consumeLiteral("(") p.consumeLiteral("context") - xs690 := []*pb.RelationId{} - cond691 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond691 { - _t1292 := p.parse_relation_id() - item692 := _t1292 - xs690 = append(xs690, item692) - cond691 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + xs694 := []*pb.RelationId{} + cond695 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond695 { + _t1300 := p.parse_relation_id() + item696 := _t1300 + xs694 = append(xs694, item696) + cond695 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) } - relation_ids693 := xs690 + relation_ids697 := xs694 p.consumeLiteral(")") - _t1293 := &pb.Context{Relations: relation_ids693} - return _t1293 + _t1301 := &pb.Context{Relations: relation_ids697} + return _t1301 } func (p *Parser) parse_snapshot() *pb.Snapshot { p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t1294 := p.parse_edb_path() - edb_path694 := _t1294 - _t1295 := p.parse_relation_id() - relation_id695 := _t1295 + xs698 := []*pb.SnapshotMapping{} + cond699 := p.matchLookaheadLiteral("[", 0) + for cond699 { + _t1302 := p.parse_snapshot_mapping() + item700 := _t1302 + xs698 = append(xs698, item700) + cond699 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings701 := xs698 p.consumeLiteral(")") - _t1296 := &pb.Snapshot{DestinationPath: edb_path694, SourceRelation: relation_id695} - return _t1296 + _t1303 := &pb.Snapshot{Mappings: snapshot_mappings701} + return _t1303 +} + +func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { + _t1304 := p.parse_edb_path() + edb_path702 := _t1304 + _t1305 := p.parse_relation_id() + relation_id703 := _t1305 + _t1306 := &pb.SnapshotMapping{DestinationPath: edb_path702, SourceRelation: relation_id703} + return _t1306 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs696 := []*pb.Read{} - cond697 := p.matchLookaheadLiteral("(", 0) - for cond697 { - _t1297 := p.parse_read() - item698 := _t1297 - xs696 = append(xs696, item698) - cond697 = p.matchLookaheadLiteral("(", 0) + xs704 := []*pb.Read{} + cond705 := p.matchLookaheadLiteral("(", 0) + for cond705 { + _t1307 := p.parse_read() + item706 := _t1307 + xs704 = append(xs704, item706) + cond705 = p.matchLookaheadLiteral("(", 0) } - reads699 := xs696 + reads707 := xs704 p.consumeLiteral(")") - return reads699 + return reads707 } func (p *Parser) parse_read() *pb.Read { - var _t1298 int64 + var _t1308 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1299 int64 + var _t1309 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t1299 = 2 + _t1309 = 2 } else { - var _t1300 int64 + var _t1310 int64 if p.matchLookaheadLiteral("output", 1) { - _t1300 = 1 + _t1310 = 1 } else { - var _t1301 int64 + var _t1311 int64 if p.matchLookaheadLiteral("export", 1) { - _t1301 = 4 + _t1311 = 4 } else { - var _t1302 int64 + var _t1312 int64 if p.matchLookaheadLiteral("demand", 1) { - _t1302 = 0 + _t1312 = 0 } else { - var _t1303 int64 + var _t1313 int64 if p.matchLookaheadLiteral("abort", 1) { - _t1303 = 3 + _t1313 = 3 } else { - _t1303 = -1 + _t1313 = -1 } - _t1302 = _t1303 + _t1312 = _t1313 } - _t1301 = _t1302 + _t1311 = _t1312 } - _t1300 = _t1301 + _t1310 = _t1311 } - _t1299 = _t1300 + _t1309 = _t1310 } - _t1298 = _t1299 + _t1308 = _t1309 } else { - _t1298 = -1 - } - prediction700 := _t1298 - var _t1304 *pb.Read - if prediction700 == 4 { - _t1305 := p.parse_export() - export705 := _t1305 - _t1306 := &pb.Read{} - _t1306.ReadType = &pb.Read_Export{Export: export705} - _t1304 = _t1306 + _t1308 = -1 + } + prediction708 := _t1308 + var _t1314 *pb.Read + if prediction708 == 4 { + _t1315 := p.parse_export() + export713 := _t1315 + _t1316 := &pb.Read{} + _t1316.ReadType = &pb.Read_Export{Export: export713} + _t1314 = _t1316 } else { - var _t1307 *pb.Read - if prediction700 == 3 { - _t1308 := p.parse_abort() - abort704 := _t1308 - _t1309 := &pb.Read{} - _t1309.ReadType = &pb.Read_Abort{Abort: abort704} - _t1307 = _t1309 + var _t1317 *pb.Read + if prediction708 == 3 { + _t1318 := p.parse_abort() + abort712 := _t1318 + _t1319 := &pb.Read{} + _t1319.ReadType = &pb.Read_Abort{Abort: abort712} + _t1317 = _t1319 } else { - var _t1310 *pb.Read - if prediction700 == 2 { - _t1311 := p.parse_what_if() - what_if703 := _t1311 - _t1312 := &pb.Read{} - _t1312.ReadType = &pb.Read_WhatIf{WhatIf: what_if703} - _t1310 = _t1312 + var _t1320 *pb.Read + if prediction708 == 2 { + _t1321 := p.parse_what_if() + what_if711 := _t1321 + _t1322 := &pb.Read{} + _t1322.ReadType = &pb.Read_WhatIf{WhatIf: what_if711} + _t1320 = _t1322 } else { - var _t1313 *pb.Read - if prediction700 == 1 { - _t1314 := p.parse_output() - output702 := _t1314 - _t1315 := &pb.Read{} - _t1315.ReadType = &pb.Read_Output{Output: output702} - _t1313 = _t1315 + var _t1323 *pb.Read + if prediction708 == 1 { + _t1324 := p.parse_output() + output710 := _t1324 + _t1325 := &pb.Read{} + _t1325.ReadType = &pb.Read_Output{Output: output710} + _t1323 = _t1325 } else { - var _t1316 *pb.Read - if prediction700 == 0 { - _t1317 := p.parse_demand() - demand701 := _t1317 - _t1318 := &pb.Read{} - _t1318.ReadType = &pb.Read_Demand{Demand: demand701} - _t1316 = _t1318 + var _t1326 *pb.Read + if prediction708 == 0 { + _t1327 := p.parse_demand() + demand709 := _t1327 + _t1328 := &pb.Read{} + _t1328.ReadType = &pb.Read_Demand{Demand: demand709} + _t1326 = _t1328 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1313 = _t1316 + _t1323 = _t1326 } - _t1310 = _t1313 + _t1320 = _t1323 } - _t1307 = _t1310 + _t1317 = _t1320 } - _t1304 = _t1307 + _t1314 = _t1317 } - return _t1304 + return _t1314 } func (p *Parser) parse_demand() *pb.Demand { p.consumeLiteral("(") p.consumeLiteral("demand") - _t1319 := p.parse_relation_id() - relation_id706 := _t1319 + _t1329 := p.parse_relation_id() + relation_id714 := _t1329 p.consumeLiteral(")") - _t1320 := &pb.Demand{RelationId: relation_id706} - return _t1320 + _t1330 := &pb.Demand{RelationId: relation_id714} + return _t1330 } func (p *Parser) parse_output() *pb.Output { p.consumeLiteral("(") p.consumeLiteral("output") - _t1321 := p.parse_name() - name707 := _t1321 - _t1322 := p.parse_relation_id() - relation_id708 := _t1322 + _t1331 := p.parse_name() + name715 := _t1331 + _t1332 := p.parse_relation_id() + relation_id716 := _t1332 p.consumeLiteral(")") - _t1323 := &pb.Output{Name: name707, RelationId: relation_id708} - return _t1323 + _t1333 := &pb.Output{Name: name715, RelationId: relation_id716} + return _t1333 } func (p *Parser) parse_what_if() *pb.WhatIf { p.consumeLiteral("(") p.consumeLiteral("what_if") - _t1324 := p.parse_name() - name709 := _t1324 - _t1325 := p.parse_epoch() - epoch710 := _t1325 + _t1334 := p.parse_name() + name717 := _t1334 + _t1335 := p.parse_epoch() + epoch718 := _t1335 p.consumeLiteral(")") - _t1326 := &pb.WhatIf{Branch: name709, Epoch: epoch710} - return _t1326 + _t1336 := &pb.WhatIf{Branch: name717, Epoch: epoch718} + return _t1336 } func (p *Parser) parse_abort() *pb.Abort { p.consumeLiteral("(") p.consumeLiteral("abort") - var _t1327 *string + var _t1337 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t1328 := p.parse_name() - _t1327 = ptr(_t1328) + _t1338 := p.parse_name() + _t1337 = ptr(_t1338) } - name711 := _t1327 - _t1329 := p.parse_relation_id() - relation_id712 := _t1329 + name719 := _t1337 + _t1339 := p.parse_relation_id() + relation_id720 := _t1339 p.consumeLiteral(")") - _t1330 := &pb.Abort{Name: deref(name711, "abort"), RelationId: relation_id712} - return _t1330 + _t1340 := &pb.Abort{Name: deref(name719, "abort"), RelationId: relation_id720} + return _t1340 } func (p *Parser) parse_export() *pb.Export { p.consumeLiteral("(") p.consumeLiteral("export") - _t1331 := p.parse_export_csv_config() - export_csv_config713 := _t1331 + _t1341 := p.parse_export_csv_config() + export_csv_config721 := _t1341 p.consumeLiteral(")") - _t1332 := &pb.Export{} - _t1332.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config713} - return _t1332 + _t1342 := &pb.Export{} + _t1342.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config721} + return _t1342 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t1333 := p.parse_export_csv_path() - export_csv_path714 := _t1333 - _t1334 := p.parse_export_csv_columns() - export_csv_columns715 := _t1334 - _t1335 := p.parse_config_dict() - config_dict716 := _t1335 - p.consumeLiteral(")") - _t1336 := p.export_csv_config(export_csv_path714, export_csv_columns715, config_dict716) - return _t1336 + _t1343 := p.parse_export_csv_path() + export_csv_path722 := _t1343 + _t1344 := p.parse_export_csv_columns() + export_csv_columns723 := _t1344 + _t1345 := p.parse_config_dict() + config_dict724 := _t1345 + p.consumeLiteral(")") + _t1346 := p.export_csv_config(export_csv_path722, export_csv_columns723, config_dict724) + return _t1346 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string717 := p.consumeTerminal("STRING").Value.str + string725 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string717 + return string725 } func (p *Parser) parse_export_csv_columns() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs718 := []*pb.ExportCSVColumn{} - cond719 := p.matchLookaheadLiteral("(", 0) - for cond719 { - _t1337 := p.parse_export_csv_column() - item720 := _t1337 - xs718 = append(xs718, item720) - cond719 = p.matchLookaheadLiteral("(", 0) + xs726 := []*pb.ExportCSVColumn{} + cond727 := p.matchLookaheadLiteral("(", 0) + for cond727 { + _t1347 := p.parse_export_csv_column() + item728 := _t1347 + xs726 = append(xs726, item728) + cond727 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns721 := xs718 + export_csv_columns729 := xs726 p.consumeLiteral(")") - return export_csv_columns721 + return export_csv_columns729 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("column") - string722 := p.consumeTerminal("STRING").Value.str - _t1338 := p.parse_relation_id() - relation_id723 := _t1338 + string730 := p.consumeTerminal("STRING").Value.str + _t1348 := p.parse_relation_id() + relation_id731 := _t1348 p.consumeLiteral(")") - _t1339 := &pb.ExportCSVColumn{ColumnName: string722, ColumnData: relation_id723} - return _t1339 + _t1349 := &pb.ExportCSVColumn{ColumnName: string730, ColumnData: relation_id731} + return _t1349 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 49f7e094..37dddd30 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -311,153 +311,153 @@ func formatBool(b bool) string { // --- Helper functions --- func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1677 := &pb.Value{} - _t1677.Value = &pb.Value_IntValue{IntValue: int64(v)} - return _t1677 + _t1689 := &pb.Value{} + _t1689.Value = &pb.Value_IntValue{IntValue: int64(v)} + return _t1689 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1678 := &pb.Value{} - _t1678.Value = &pb.Value_IntValue{IntValue: v} - return _t1678 + _t1690 := &pb.Value{} + _t1690.Value = &pb.Value_IntValue{IntValue: v} + return _t1690 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1679 := &pb.Value{} - _t1679.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1679 + _t1691 := &pb.Value{} + _t1691.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1691 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1680 := &pb.Value{} - _t1680.Value = &pb.Value_StringValue{StringValue: v} - return _t1680 + _t1692 := &pb.Value{} + _t1692.Value = &pb.Value_StringValue{StringValue: v} + return _t1692 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1681 := &pb.Value{} - _t1681.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1681 + _t1693 := &pb.Value{} + _t1693.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1693 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1682 := &pb.Value{} - _t1682.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1682 + _t1694 := &pb.Value{} + _t1694.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1694 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1683 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1683}) + _t1695 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1695}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1684 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1684}) + _t1696 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1696}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1685 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1685}) + _t1697 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1697}) } } } - _t1686 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1686}) + _t1698 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1698}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1687 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1687}) - _t1688 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1688}) + _t1699 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1699}) + _t1700 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1700}) if msg.GetNewLine() != "" { - _t1689 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1689}) - } - _t1690 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1690}) - _t1691 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1691}) - _t1692 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1692}) + _t1701 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1701}) + } + _t1702 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1702}) + _t1703 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1703}) + _t1704 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1704}) if msg.GetComment() != "" { - _t1693 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1693}) + _t1705 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1705}) } for _, missing_string := range msg.GetMissingStrings() { - _t1694 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1694}) - } - _t1695 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1695}) - _t1696 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1696}) - _t1697 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1697}) + _t1706 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1706}) + } + _t1707 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1707}) + _t1708 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1708}) + _t1709 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1709}) return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1698 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1698}) - _t1699 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1699}) - _t1700 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1700}) - _t1701 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1701}) + _t1710 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1710}) + _t1711 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1711}) + _t1712 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1712}) + _t1713 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1713}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1702 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1702}) + _t1714 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1714}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1703 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1703}) + _t1715 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1715}) } } - _t1704 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1704}) - _t1705 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1705}) + _t1716 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1716}) + _t1717 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1717}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1706 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1706}) + _t1718 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1718}) } if msg.Compression != nil { - _t1707 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1707}) + _t1719 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1719}) } if msg.SyntaxHeaderRow != nil { - _t1708 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1708}) + _t1720 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1720}) } if msg.SyntaxMissingString != nil { - _t1709 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1709}) + _t1721 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1721}) } if msg.SyntaxDelim != nil { - _t1710 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1710}) + _t1722 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1722}) } if msg.SyntaxQuotechar != nil { - _t1711 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1711}) + _t1723 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1723}) } if msg.SyntaxEscapechar != nil { - _t1712 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1712}) + _t1724 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1724}) } return listSort(result) } @@ -469,11 +469,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 _t1713 interface{} + var _t1725 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1713 + _ = _t1725 return nil } @@ -491,48 +491,48 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat646 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat646 != nil { - p.write(*flat646) + flat651 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat651 != nil { + p.write(*flat651) return nil } else { - _t1274 := func(_dollar_dollar *pb.Transaction) []interface{} { - var _t1275 *pb.Configure + _t1284 := func(_dollar_dollar *pb.Transaction) []interface{} { + var _t1285 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1275 = _dollar_dollar.GetConfigure() + _t1285 = _dollar_dollar.GetConfigure() } - var _t1276 *pb.Sync + var _t1286 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1276 = _dollar_dollar.GetSync() + _t1286 = _dollar_dollar.GetSync() } - return []interface{}{_t1275, _t1276, _dollar_dollar.GetEpochs()} + return []interface{}{_t1285, _t1286, _dollar_dollar.GetEpochs()} } - _t1277 := _t1274(msg) - fields637 := _t1277 - unwrapped_fields638 := fields637 + _t1287 := _t1284(msg) + fields642 := _t1287 + unwrapped_fields643 := fields642 p.write("(") p.write("transaction") p.indentSexp() - field639 := unwrapped_fields638[0].(*pb.Configure) - if field639 != nil { + field644 := unwrapped_fields643[0].(*pb.Configure) + if field644 != nil { p.newline() - opt_val640 := field639 - p.pretty_configure(opt_val640) + opt_val645 := field644 + p.pretty_configure(opt_val645) } - field641 := unwrapped_fields638[1].(*pb.Sync) - if field641 != nil { + field646 := unwrapped_fields643[1].(*pb.Sync) + if field646 != nil { p.newline() - opt_val642 := field641 - p.pretty_sync(opt_val642) + opt_val647 := field646 + p.pretty_sync(opt_val647) } - field643 := unwrapped_fields638[2].([]*pb.Epoch) - if !(len(field643) == 0) { + field648 := unwrapped_fields643[2].([]*pb.Epoch) + if !(len(field648) == 0) { p.newline() - for i645, elem644 := range field643 { - if (i645 > 0) { + for i650, elem649 := range field648 { + if (i650 > 0) { p.newline() } - p.pretty_epoch(elem644) + p.pretty_epoch(elem649) } } p.dedent() @@ -542,23 +542,23 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat649 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat649 != nil { - p.write(*flat649) + flat654 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat654 != nil { + p.write(*flat654) return nil } else { - _t1278 := func(_dollar_dollar *pb.Configure) [][]interface{} { - _t1279 := p.deconstruct_configure(_dollar_dollar) - return _t1279 + _t1288 := func(_dollar_dollar *pb.Configure) [][]interface{} { + _t1289 := p.deconstruct_configure(_dollar_dollar) + return _t1289 } - _t1280 := _t1278(msg) - fields647 := _t1280 - unwrapped_fields648 := fields647 + _t1290 := _t1288(msg) + fields652 := _t1290 + unwrapped_fields653 := fields652 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields648) + p.pretty_config_dict(unwrapped_fields653) p.dedent() p.write(")") } @@ -566,21 +566,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat653 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat653 != nil { - p.write(*flat653) + flat658 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat658 != nil { + p.write(*flat658) return nil } else { - fields650 := msg + fields655 := msg p.write("{") p.indent() - if !(len(fields650) == 0) { + if !(len(fields655) == 0) { p.newline() - for i652, elem651 := range fields650 { - if (i652 > 0) { + for i657, elem656 := range fields655 { + if (i657 > 0) { p.newline() } - p.pretty_config_key_value(elem651) + p.pretty_config_key_value(elem656) } } p.dedent() @@ -590,152 +590,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat658 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat658 != nil { - p.write(*flat658) + flat663 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat663 != nil { + p.write(*flat663) return nil } else { - _t1281 := func(_dollar_dollar []interface{}) []interface{} { + _t1291 := func(_dollar_dollar []interface{}) []interface{} { return []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} } - _t1282 := _t1281(msg) - fields654 := _t1282 - unwrapped_fields655 := fields654 + _t1292 := _t1291(msg) + fields659 := _t1292 + unwrapped_fields660 := fields659 p.write(":") - field656 := unwrapped_fields655[0].(string) - p.write(field656) + field661 := unwrapped_fields660[0].(string) + p.write(field661) p.write(" ") - field657 := unwrapped_fields655[1].(*pb.Value) - p.pretty_value(field657) + field662 := unwrapped_fields660[1].(*pb.Value) + p.pretty_value(field662) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat678 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat678 != nil { - p.write(*flat678) + flat683 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat683 != nil { + p.write(*flat683) return nil } else { - _t1283 := func(_dollar_dollar *pb.Value) *pb.DateValue { - var _t1284 *pb.DateValue + _t1293 := func(_dollar_dollar *pb.Value) *pb.DateValue { + var _t1294 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1284 = _dollar_dollar.GetDateValue() + _t1294 = _dollar_dollar.GetDateValue() } - return _t1284 + return _t1294 } - _t1285 := _t1283(msg) - deconstruct_result676 := _t1285 - if deconstruct_result676 != nil { - unwrapped677 := deconstruct_result676 - p.pretty_date(unwrapped677) + _t1295 := _t1293(msg) + deconstruct_result681 := _t1295 + if deconstruct_result681 != nil { + unwrapped682 := deconstruct_result681 + p.pretty_date(unwrapped682) } else { - _t1286 := func(_dollar_dollar *pb.Value) *pb.DateTimeValue { - var _t1287 *pb.DateTimeValue + _t1296 := func(_dollar_dollar *pb.Value) *pb.DateTimeValue { + var _t1297 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1287 = _dollar_dollar.GetDatetimeValue() + _t1297 = _dollar_dollar.GetDatetimeValue() } - return _t1287 + return _t1297 } - _t1288 := _t1286(msg) - deconstruct_result674 := _t1288 - if deconstruct_result674 != nil { - unwrapped675 := deconstruct_result674 - p.pretty_datetime(unwrapped675) + _t1298 := _t1296(msg) + deconstruct_result679 := _t1298 + if deconstruct_result679 != nil { + unwrapped680 := deconstruct_result679 + p.pretty_datetime(unwrapped680) } else { - _t1289 := func(_dollar_dollar *pb.Value) *string { - var _t1290 *string + _t1299 := func(_dollar_dollar *pb.Value) *string { + var _t1300 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1290 = ptr(_dollar_dollar.GetStringValue()) + _t1300 = ptr(_dollar_dollar.GetStringValue()) } - return _t1290 + return _t1300 } - _t1291 := _t1289(msg) - deconstruct_result672 := _t1291 - if deconstruct_result672 != nil { - unwrapped673 := *deconstruct_result672 - p.write(p.formatStringValue(unwrapped673)) + _t1301 := _t1299(msg) + deconstruct_result677 := _t1301 + if deconstruct_result677 != nil { + unwrapped678 := *deconstruct_result677 + p.write(p.formatStringValue(unwrapped678)) } else { - _t1292 := func(_dollar_dollar *pb.Value) *int64 { - var _t1293 *int64 + _t1302 := func(_dollar_dollar *pb.Value) *int64 { + var _t1303 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1293 = ptr(_dollar_dollar.GetIntValue()) + _t1303 = ptr(_dollar_dollar.GetIntValue()) } - return _t1293 + return _t1303 } - _t1294 := _t1292(msg) - deconstruct_result670 := _t1294 - if deconstruct_result670 != nil { - unwrapped671 := *deconstruct_result670 - p.write(fmt.Sprintf("%d", unwrapped671)) + _t1304 := _t1302(msg) + deconstruct_result675 := _t1304 + if deconstruct_result675 != nil { + unwrapped676 := *deconstruct_result675 + p.write(fmt.Sprintf("%d", unwrapped676)) } else { - _t1295 := func(_dollar_dollar *pb.Value) *float64 { - var _t1296 *float64 + _t1305 := func(_dollar_dollar *pb.Value) *float64 { + var _t1306 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1296 = ptr(_dollar_dollar.GetFloatValue()) + _t1306 = ptr(_dollar_dollar.GetFloatValue()) } - return _t1296 + return _t1306 } - _t1297 := _t1295(msg) - deconstruct_result668 := _t1297 - if deconstruct_result668 != nil { - unwrapped669 := *deconstruct_result668 - p.write(formatFloat64(unwrapped669)) + _t1307 := _t1305(msg) + deconstruct_result673 := _t1307 + if deconstruct_result673 != nil { + unwrapped674 := *deconstruct_result673 + p.write(formatFloat64(unwrapped674)) } else { - _t1298 := func(_dollar_dollar *pb.Value) *pb.UInt128Value { - var _t1299 *pb.UInt128Value + _t1308 := func(_dollar_dollar *pb.Value) *pb.UInt128Value { + var _t1309 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1299 = _dollar_dollar.GetUint128Value() + _t1309 = _dollar_dollar.GetUint128Value() } - return _t1299 + return _t1309 } - _t1300 := _t1298(msg) - deconstruct_result666 := _t1300 - if deconstruct_result666 != nil { - unwrapped667 := deconstruct_result666 - p.write(p.formatUint128(unwrapped667)) + _t1310 := _t1308(msg) + deconstruct_result671 := _t1310 + if deconstruct_result671 != nil { + unwrapped672 := deconstruct_result671 + p.write(p.formatUint128(unwrapped672)) } else { - _t1301 := func(_dollar_dollar *pb.Value) *pb.Int128Value { - var _t1302 *pb.Int128Value + _t1311 := func(_dollar_dollar *pb.Value) *pb.Int128Value { + var _t1312 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1302 = _dollar_dollar.GetInt128Value() + _t1312 = _dollar_dollar.GetInt128Value() } - return _t1302 + return _t1312 } - _t1303 := _t1301(msg) - deconstruct_result664 := _t1303 - if deconstruct_result664 != nil { - unwrapped665 := deconstruct_result664 - p.write(p.formatInt128(unwrapped665)) + _t1313 := _t1311(msg) + deconstruct_result669 := _t1313 + if deconstruct_result669 != nil { + unwrapped670 := deconstruct_result669 + p.write(p.formatInt128(unwrapped670)) } else { - _t1304 := func(_dollar_dollar *pb.Value) *pb.DecimalValue { - var _t1305 *pb.DecimalValue + _t1314 := func(_dollar_dollar *pb.Value) *pb.DecimalValue { + var _t1315 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1305 = _dollar_dollar.GetDecimalValue() + _t1315 = _dollar_dollar.GetDecimalValue() } - return _t1305 + return _t1315 } - _t1306 := _t1304(msg) - deconstruct_result662 := _t1306 - if deconstruct_result662 != nil { - unwrapped663 := deconstruct_result662 - p.write(p.formatDecimal(unwrapped663)) + _t1316 := _t1314(msg) + deconstruct_result667 := _t1316 + if deconstruct_result667 != nil { + unwrapped668 := deconstruct_result667 + p.write(p.formatDecimal(unwrapped668)) } else { - _t1307 := func(_dollar_dollar *pb.Value) *bool { - var _t1308 *bool + _t1317 := func(_dollar_dollar *pb.Value) *bool { + var _t1318 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1308 = ptr(_dollar_dollar.GetBooleanValue()) + _t1318 = ptr(_dollar_dollar.GetBooleanValue()) } - return _t1308 + return _t1318 } - _t1309 := _t1307(msg) - deconstruct_result660 := _t1309 - if deconstruct_result660 != nil { - unwrapped661 := *deconstruct_result660 - p.pretty_boolean_value(unwrapped661) + _t1319 := _t1317(msg) + deconstruct_result665 := _t1319 + if deconstruct_result665 != nil { + unwrapped666 := *deconstruct_result665 + p.pretty_boolean_value(unwrapped666) } else { - fields659 := msg - _ = fields659 + fields664 := msg + _ = fields664 p.write("missing") } } @@ -751,29 +751,29 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat684 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat684 != nil { - p.write(*flat684) + flat689 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat689 != nil { + p.write(*flat689) return nil } else { - _t1310 := func(_dollar_dollar *pb.DateValue) []interface{} { + _t1320 := func(_dollar_dollar *pb.DateValue) []interface{} { return []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} } - _t1311 := _t1310(msg) - fields679 := _t1311 - unwrapped_fields680 := fields679 + _t1321 := _t1320(msg) + fields684 := _t1321 + unwrapped_fields685 := fields684 p.write("(") p.write("date") p.indentSexp() p.newline() - field681 := unwrapped_fields680[0].(int64) - p.write(fmt.Sprintf("%d", field681)) + field686 := unwrapped_fields685[0].(int64) + p.write(fmt.Sprintf("%d", field686)) p.newline() - field682 := unwrapped_fields680[1].(int64) - p.write(fmt.Sprintf("%d", field682)) + field687 := unwrapped_fields685[1].(int64) + p.write(fmt.Sprintf("%d", field687)) p.newline() - field683 := unwrapped_fields680[2].(int64) - p.write(fmt.Sprintf("%d", field683)) + field688 := unwrapped_fields685[2].(int64) + p.write(fmt.Sprintf("%d", field688)) p.dedent() p.write(")") } @@ -781,43 +781,43 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat695 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat695 != nil { - p.write(*flat695) + flat700 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat700 != nil { + p.write(*flat700) return nil } else { - _t1312 := func(_dollar_dollar *pb.DateTimeValue) []interface{} { + _t1322 := func(_dollar_dollar *pb.DateTimeValue) []interface{} { return []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()))} } - _t1313 := _t1312(msg) - fields685 := _t1313 - unwrapped_fields686 := fields685 + _t1323 := _t1322(msg) + fields690 := _t1323 + unwrapped_fields691 := fields690 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field687 := unwrapped_fields686[0].(int64) - p.write(fmt.Sprintf("%d", field687)) + field692 := unwrapped_fields691[0].(int64) + p.write(fmt.Sprintf("%d", field692)) p.newline() - field688 := unwrapped_fields686[1].(int64) - p.write(fmt.Sprintf("%d", field688)) + field693 := unwrapped_fields691[1].(int64) + p.write(fmt.Sprintf("%d", field693)) p.newline() - field689 := unwrapped_fields686[2].(int64) - p.write(fmt.Sprintf("%d", field689)) + field694 := unwrapped_fields691[2].(int64) + p.write(fmt.Sprintf("%d", field694)) p.newline() - field690 := unwrapped_fields686[3].(int64) - p.write(fmt.Sprintf("%d", field690)) + field695 := unwrapped_fields691[3].(int64) + p.write(fmt.Sprintf("%d", field695)) p.newline() - field691 := unwrapped_fields686[4].(int64) - p.write(fmt.Sprintf("%d", field691)) + field696 := unwrapped_fields691[4].(int64) + p.write(fmt.Sprintf("%d", field696)) p.newline() - field692 := unwrapped_fields686[5].(int64) - p.write(fmt.Sprintf("%d", field692)) - field693 := unwrapped_fields686[6].(*int64) - if field693 != nil { + field697 := unwrapped_fields691[5].(int64) + p.write(fmt.Sprintf("%d", field697)) + field698 := unwrapped_fields691[6].(*int64) + if field698 != nil { p.newline() - opt_val694 := *field693 - p.write(fmt.Sprintf("%d", opt_val694)) + opt_val699 := *field698 + p.write(fmt.Sprintf("%d", opt_val699)) } p.dedent() p.write(")") @@ -826,32 +826,32 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { - _t1314 := func(_dollar_dollar bool) []interface{} { - var _t1315 []interface{} + _t1324 := func(_dollar_dollar bool) []interface{} { + var _t1325 []interface{} if _dollar_dollar { - _t1315 = []interface{}{} + _t1325 = []interface{}{} } - return _t1315 + return _t1325 } - _t1316 := _t1314(msg) - deconstruct_result698 := _t1316 - if deconstruct_result698 != nil { - unwrapped699 := deconstruct_result698 - _ = unwrapped699 + _t1326 := _t1324(msg) + deconstruct_result703 := _t1326 + if deconstruct_result703 != nil { + unwrapped704 := deconstruct_result703 + _ = unwrapped704 p.write("true") } else { - _t1317 := func(_dollar_dollar bool) []interface{} { - var _t1318 []interface{} + _t1327 := func(_dollar_dollar bool) []interface{} { + var _t1328 []interface{} if !(_dollar_dollar) { - _t1318 = []interface{}{} + _t1328 = []interface{}{} } - return _t1318 + return _t1328 } - _t1319 := _t1317(msg) - deconstruct_result696 := _t1319 - if deconstruct_result696 != nil { - unwrapped697 := deconstruct_result696 - _ = unwrapped697 + _t1329 := _t1327(msg) + deconstruct_result701 := _t1329 + if deconstruct_result701 != nil { + unwrapped702 := deconstruct_result701 + _ = unwrapped702 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -861,27 +861,27 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat704 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat704 != nil { - p.write(*flat704) + flat709 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat709 != nil { + p.write(*flat709) return nil } else { - _t1320 := func(_dollar_dollar *pb.Sync) []*pb.FragmentId { + _t1330 := func(_dollar_dollar *pb.Sync) []*pb.FragmentId { return _dollar_dollar.GetFragments() } - _t1321 := _t1320(msg) - fields700 := _t1321 - unwrapped_fields701 := fields700 + _t1331 := _t1330(msg) + fields705 := _t1331 + unwrapped_fields706 := fields705 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields701) == 0) { + if !(len(unwrapped_fields706) == 0) { p.newline() - for i703, elem702 := range unwrapped_fields701 { - if (i703 > 0) { + for i708, elem707 := range unwrapped_fields706 { + if (i708 > 0) { p.newline() } - p.pretty_fragment_id(elem702) + p.pretty_fragment_id(elem707) } } p.dedent() @@ -891,57 +891,57 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat707 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat707 != nil { - p.write(*flat707) + flat712 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat712 != nil { + p.write(*flat712) return nil } else { - _t1322 := func(_dollar_dollar *pb.FragmentId) string { + _t1332 := func(_dollar_dollar *pb.FragmentId) string { return p.fragmentIdToString(_dollar_dollar) } - _t1323 := _t1322(msg) - fields705 := _t1323 - unwrapped_fields706 := fields705 + _t1333 := _t1332(msg) + fields710 := _t1333 + unwrapped_fields711 := fields710 p.write(":") - p.write(unwrapped_fields706) + p.write(unwrapped_fields711) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat714 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat714 != nil { - p.write(*flat714) + flat719 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat719 != nil { + p.write(*flat719) return nil } else { - _t1324 := func(_dollar_dollar *pb.Epoch) []interface{} { - var _t1325 []*pb.Write + _t1334 := func(_dollar_dollar *pb.Epoch) []interface{} { + var _t1335 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1325 = _dollar_dollar.GetWrites() + _t1335 = _dollar_dollar.GetWrites() } - var _t1326 []*pb.Read + var _t1336 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1326 = _dollar_dollar.GetReads() + _t1336 = _dollar_dollar.GetReads() } - return []interface{}{_t1325, _t1326} + return []interface{}{_t1335, _t1336} } - _t1327 := _t1324(msg) - fields708 := _t1327 - unwrapped_fields709 := fields708 + _t1337 := _t1334(msg) + fields713 := _t1337 + unwrapped_fields714 := fields713 p.write("(") p.write("epoch") p.indentSexp() - field710 := unwrapped_fields709[0].([]*pb.Write) - if field710 != nil { + field715 := unwrapped_fields714[0].([]*pb.Write) + if field715 != nil { p.newline() - opt_val711 := field710 - p.pretty_epoch_writes(opt_val711) + opt_val716 := field715 + p.pretty_epoch_writes(opt_val716) } - field712 := unwrapped_fields709[1].([]*pb.Read) - if field712 != nil { + field717 := unwrapped_fields714[1].([]*pb.Read) + if field717 != nil { p.newline() - opt_val713 := field712 - p.pretty_epoch_reads(opt_val713) + opt_val718 := field717 + p.pretty_epoch_reads(opt_val718) } p.dedent() p.write(")") @@ -950,22 +950,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat718 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat718 != nil { - p.write(*flat718) + flat723 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat723 != nil { + p.write(*flat723) return nil } else { - fields715 := msg + fields720 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields715) == 0) { + if !(len(fields720) == 0) { p.newline() - for i717, elem716 := range fields715 { - if (i717 > 0) { + for i722, elem721 := range fields720 { + if (i722 > 0) { p.newline() } - p.pretty_write(elem716) + p.pretty_write(elem721) } } p.dedent() @@ -975,62 +975,62 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat727 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat727 != nil { - p.write(*flat727) + flat732 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat732 != nil { + p.write(*flat732) return nil } else { - _t1328 := func(_dollar_dollar *pb.Write) *pb.Define { - var _t1329 *pb.Define + _t1338 := func(_dollar_dollar *pb.Write) *pb.Define { + var _t1339 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1329 = _dollar_dollar.GetDefine() + _t1339 = _dollar_dollar.GetDefine() } - return _t1329 + return _t1339 } - _t1330 := _t1328(msg) - deconstruct_result725 := _t1330 - if deconstruct_result725 != nil { - unwrapped726 := deconstruct_result725 - p.pretty_define(unwrapped726) + _t1340 := _t1338(msg) + deconstruct_result730 := _t1340 + if deconstruct_result730 != nil { + unwrapped731 := deconstruct_result730 + p.pretty_define(unwrapped731) } else { - _t1331 := func(_dollar_dollar *pb.Write) *pb.Undefine { - var _t1332 *pb.Undefine + _t1341 := func(_dollar_dollar *pb.Write) *pb.Undefine { + var _t1342 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1332 = _dollar_dollar.GetUndefine() + _t1342 = _dollar_dollar.GetUndefine() } - return _t1332 + return _t1342 } - _t1333 := _t1331(msg) - deconstruct_result723 := _t1333 - if deconstruct_result723 != nil { - unwrapped724 := deconstruct_result723 - p.pretty_undefine(unwrapped724) + _t1343 := _t1341(msg) + deconstruct_result728 := _t1343 + if deconstruct_result728 != nil { + unwrapped729 := deconstruct_result728 + p.pretty_undefine(unwrapped729) } else { - _t1334 := func(_dollar_dollar *pb.Write) *pb.Context { - var _t1335 *pb.Context + _t1344 := func(_dollar_dollar *pb.Write) *pb.Context { + var _t1345 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1335 = _dollar_dollar.GetContext() + _t1345 = _dollar_dollar.GetContext() } - return _t1335 + return _t1345 } - _t1336 := _t1334(msg) - deconstruct_result721 := _t1336 - if deconstruct_result721 != nil { - unwrapped722 := deconstruct_result721 - p.pretty_context(unwrapped722) + _t1346 := _t1344(msg) + deconstruct_result726 := _t1346 + if deconstruct_result726 != nil { + unwrapped727 := deconstruct_result726 + p.pretty_context(unwrapped727) } else { - _t1337 := func(_dollar_dollar *pb.Write) *pb.Snapshot { - var _t1338 *pb.Snapshot + _t1347 := func(_dollar_dollar *pb.Write) *pb.Snapshot { + var _t1348 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1338 = _dollar_dollar.GetSnapshot() + _t1348 = _dollar_dollar.GetSnapshot() } - return _t1338 + return _t1348 } - _t1339 := _t1337(msg) - deconstruct_result719 := _t1339 - if deconstruct_result719 != nil { - unwrapped720 := deconstruct_result719 - p.pretty_snapshot(unwrapped720) + _t1349 := _t1347(msg) + deconstruct_result724 := _t1349 + if deconstruct_result724 != nil { + unwrapped725 := deconstruct_result724 + p.pretty_snapshot(unwrapped725) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1042,22 +1042,22 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat730 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat730 != nil { - p.write(*flat730) + flat735 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat735 != nil { + p.write(*flat735) return nil } else { - _t1340 := func(_dollar_dollar *pb.Define) *pb.Fragment { + _t1350 := func(_dollar_dollar *pb.Define) *pb.Fragment { return _dollar_dollar.GetFragment() } - _t1341 := _t1340(msg) - fields728 := _t1341 - unwrapped_fields729 := fields728 + _t1351 := _t1350(msg) + fields733 := _t1351 + unwrapped_fields734 := fields733 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields729) + p.pretty_fragment(unwrapped_fields734) p.dedent() p.write(")") } @@ -1065,32 +1065,32 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat737 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat737 != nil { - p.write(*flat737) + flat742 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat742 != nil { + p.write(*flat742) return nil } else { - _t1342 := func(_dollar_dollar *pb.Fragment) []interface{} { + _t1352 := func(_dollar_dollar *pb.Fragment) []interface{} { p.startPrettyFragment(_dollar_dollar) return []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} } - _t1343 := _t1342(msg) - fields731 := _t1343 - unwrapped_fields732 := fields731 + _t1353 := _t1352(msg) + fields736 := _t1353 + unwrapped_fields737 := fields736 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field733 := unwrapped_fields732[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field733) - field734 := unwrapped_fields732[1].([]*pb.Declaration) - if !(len(field734) == 0) { + field738 := unwrapped_fields737[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field738) + field739 := unwrapped_fields737[1].([]*pb.Declaration) + if !(len(field739) == 0) { p.newline() - for i736, elem735 := range field734 { - if (i736 > 0) { + for i741, elem740 := range field739 { + if (i741 > 0) { p.newline() } - p.pretty_declaration(elem735) + p.pretty_declaration(elem740) } } p.dedent() @@ -1100,74 +1100,74 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat739 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat739 != nil { - p.write(*flat739) + flat744 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat744 != nil { + p.write(*flat744) return nil } else { - fields738 := msg - p.pretty_fragment_id(fields738) + fields743 := msg + p.pretty_fragment_id(fields743) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat748 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat748 != nil { - p.write(*flat748) + flat753 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat753 != nil { + p.write(*flat753) return nil } else { - _t1344 := func(_dollar_dollar *pb.Declaration) *pb.Def { - var _t1345 *pb.Def + _t1354 := func(_dollar_dollar *pb.Declaration) *pb.Def { + var _t1355 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1345 = _dollar_dollar.GetDef() + _t1355 = _dollar_dollar.GetDef() } - return _t1345 + return _t1355 } - _t1346 := _t1344(msg) - deconstruct_result746 := _t1346 - if deconstruct_result746 != nil { - unwrapped747 := deconstruct_result746 - p.pretty_def(unwrapped747) + _t1356 := _t1354(msg) + deconstruct_result751 := _t1356 + if deconstruct_result751 != nil { + unwrapped752 := deconstruct_result751 + p.pretty_def(unwrapped752) } else { - _t1347 := func(_dollar_dollar *pb.Declaration) *pb.Algorithm { - var _t1348 *pb.Algorithm + _t1357 := func(_dollar_dollar *pb.Declaration) *pb.Algorithm { + var _t1358 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1348 = _dollar_dollar.GetAlgorithm() + _t1358 = _dollar_dollar.GetAlgorithm() } - return _t1348 + return _t1358 } - _t1349 := _t1347(msg) - deconstruct_result744 := _t1349 - if deconstruct_result744 != nil { - unwrapped745 := deconstruct_result744 - p.pretty_algorithm(unwrapped745) + _t1359 := _t1357(msg) + deconstruct_result749 := _t1359 + if deconstruct_result749 != nil { + unwrapped750 := deconstruct_result749 + p.pretty_algorithm(unwrapped750) } else { - _t1350 := func(_dollar_dollar *pb.Declaration) *pb.Constraint { - var _t1351 *pb.Constraint + _t1360 := func(_dollar_dollar *pb.Declaration) *pb.Constraint { + var _t1361 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1351 = _dollar_dollar.GetConstraint() + _t1361 = _dollar_dollar.GetConstraint() } - return _t1351 + return _t1361 } - _t1352 := _t1350(msg) - deconstruct_result742 := _t1352 - if deconstruct_result742 != nil { - unwrapped743 := deconstruct_result742 - p.pretty_constraint(unwrapped743) + _t1362 := _t1360(msg) + deconstruct_result747 := _t1362 + if deconstruct_result747 != nil { + unwrapped748 := deconstruct_result747 + p.pretty_constraint(unwrapped748) } else { - _t1353 := func(_dollar_dollar *pb.Declaration) *pb.Data { - var _t1354 *pb.Data + _t1363 := func(_dollar_dollar *pb.Declaration) *pb.Data { + var _t1364 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1354 = _dollar_dollar.GetData() + _t1364 = _dollar_dollar.GetData() } - return _t1354 + return _t1364 } - _t1355 := _t1353(msg) - deconstruct_result740 := _t1355 - if deconstruct_result740 != nil { - unwrapped741 := deconstruct_result740 - p.pretty_data(unwrapped741) + _t1365 := _t1363(msg) + deconstruct_result745 := _t1365 + if deconstruct_result745 != nil { + unwrapped746 := deconstruct_result745 + p.pretty_data(unwrapped746) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1179,35 +1179,35 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat755 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat755 != nil { - p.write(*flat755) + flat760 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat760 != nil { + p.write(*flat760) return nil } else { - _t1356 := func(_dollar_dollar *pb.Def) []interface{} { - var _t1357 []*pb.Attribute + _t1366 := func(_dollar_dollar *pb.Def) []interface{} { + var _t1367 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1357 = _dollar_dollar.GetAttrs() + _t1367 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1357} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1367} } - _t1358 := _t1356(msg) - fields749 := _t1358 - unwrapped_fields750 := fields749 + _t1368 := _t1366(msg) + fields754 := _t1368 + unwrapped_fields755 := fields754 p.write("(") p.write("def") p.indentSexp() p.newline() - field751 := unwrapped_fields750[0].(*pb.RelationId) - p.pretty_relation_id(field751) + field756 := unwrapped_fields755[0].(*pb.RelationId) + p.pretty_relation_id(field756) p.newline() - field752 := unwrapped_fields750[1].(*pb.Abstraction) - p.pretty_abstraction(field752) - field753 := unwrapped_fields750[2].([]*pb.Attribute) - if field753 != nil { + field757 := unwrapped_fields755[1].(*pb.Abstraction) + p.pretty_abstraction(field757) + field758 := unwrapped_fields755[2].([]*pb.Attribute) + if field758 != nil { p.newline() - opt_val754 := field753 - p.pretty_attrs(opt_val754) + opt_val759 := field758 + p.pretty_attrs(opt_val759) } p.dedent() p.write(")") @@ -1216,35 +1216,35 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat760 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat760 != nil { - p.write(*flat760) + flat765 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat765 != nil { + p.write(*flat765) return nil } else { - _t1359 := func(_dollar_dollar *pb.RelationId) *string { - var _t1360 *string + _t1369 := func(_dollar_dollar *pb.RelationId) *string { + var _t1370 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1361 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1360 = ptr(_t1361) + _t1371 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1370 = ptr(_t1371) } - return _t1360 + return _t1370 } - _t1362 := _t1359(msg) - deconstruct_result758 := _t1362 - if deconstruct_result758 != nil { - unwrapped759 := *deconstruct_result758 + _t1372 := _t1369(msg) + deconstruct_result763 := _t1372 + if deconstruct_result763 != nil { + unwrapped764 := *deconstruct_result763 p.write(":") - p.write(unwrapped759) + p.write(unwrapped764) } else { - _t1363 := func(_dollar_dollar *pb.RelationId) *pb.UInt128Value { - _t1364 := p.deconstruct_relation_id_uint128(_dollar_dollar) - return _t1364 + _t1373 := func(_dollar_dollar *pb.RelationId) *pb.UInt128Value { + _t1374 := p.deconstruct_relation_id_uint128(_dollar_dollar) + return _t1374 } - _t1365 := _t1363(msg) - deconstruct_result756 := _t1365 - if deconstruct_result756 != nil { - unwrapped757 := deconstruct_result756 - p.write(p.formatUint128(unwrapped757)) + _t1375 := _t1373(msg) + deconstruct_result761 := _t1375 + if deconstruct_result761 != nil { + unwrapped762 := deconstruct_result761 + p.write(p.formatUint128(unwrapped762)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1254,25 +1254,25 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat765 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat765 != nil { - p.write(*flat765) + flat770 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat770 != nil { + p.write(*flat770) return nil } else { - _t1366 := func(_dollar_dollar *pb.Abstraction) []interface{} { - _t1367 := p.deconstruct_bindings(_dollar_dollar) - return []interface{}{_t1367, _dollar_dollar.GetValue()} + _t1376 := func(_dollar_dollar *pb.Abstraction) []interface{} { + _t1377 := p.deconstruct_bindings(_dollar_dollar) + return []interface{}{_t1377, _dollar_dollar.GetValue()} } - _t1368 := _t1366(msg) - fields761 := _t1368 - unwrapped_fields762 := fields761 + _t1378 := _t1376(msg) + fields766 := _t1378 + unwrapped_fields767 := fields766 p.write("(") p.indent() - field763 := unwrapped_fields762[0].([]interface{}) - p.pretty_bindings(field763) + field768 := unwrapped_fields767[0].([]interface{}) + p.pretty_bindings(field768) p.newline() - field764 := unwrapped_fields762[1].(*pb.Formula) - p.pretty_formula(field764) + field769 := unwrapped_fields767[1].(*pb.Formula) + p.pretty_formula(field769) p.dedent() p.write(")") } @@ -1280,35 +1280,35 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat773 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat773 != nil { - p.write(*flat773) + flat778 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat778 != nil { + p.write(*flat778) return nil } else { - _t1369 := func(_dollar_dollar []interface{}) []interface{} { - var _t1370 []*pb.Binding + _t1379 := func(_dollar_dollar []interface{}) []interface{} { + var _t1380 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1370 = _dollar_dollar[1].([]*pb.Binding) + _t1380 = _dollar_dollar[1].([]*pb.Binding) } - return []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1370} + return []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1380} } - _t1371 := _t1369(msg) - fields766 := _t1371 - unwrapped_fields767 := fields766 + _t1381 := _t1379(msg) + fields771 := _t1381 + unwrapped_fields772 := fields771 p.write("[") p.indent() - field768 := unwrapped_fields767[0].([]*pb.Binding) - for i770, elem769 := range field768 { - if (i770 > 0) { + field773 := unwrapped_fields772[0].([]*pb.Binding) + for i775, elem774 := range field773 { + if (i775 > 0) { p.newline() } - p.pretty_binding(elem769) + p.pretty_binding(elem774) } - field771 := unwrapped_fields767[1].([]*pb.Binding) - if field771 != nil { + field776 := unwrapped_fields772[1].([]*pb.Binding) + if field776 != nil { p.newline() - opt_val772 := field771 - p.pretty_value_bindings(opt_val772) + opt_val777 := field776 + p.pretty_value_bindings(opt_val777) } p.dedent() p.write("]") @@ -1317,174 +1317,174 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat778 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat778 != nil { - p.write(*flat778) + flat783 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat783 != nil { + p.write(*flat783) return nil } else { - _t1372 := func(_dollar_dollar *pb.Binding) []interface{} { + _t1382 := func(_dollar_dollar *pb.Binding) []interface{} { return []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} } - _t1373 := _t1372(msg) - fields774 := _t1373 - unwrapped_fields775 := fields774 - field776 := unwrapped_fields775[0].(string) - p.write(field776) + _t1383 := _t1382(msg) + fields779 := _t1383 + unwrapped_fields780 := fields779 + field781 := unwrapped_fields780[0].(string) + p.write(field781) p.write("::") - field777 := unwrapped_fields775[1].(*pb.Type) - p.pretty_type(field777) + field782 := unwrapped_fields780[1].(*pb.Type) + p.pretty_type(field782) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat801 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat801 != nil { - p.write(*flat801) + flat806 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat806 != nil { + p.write(*flat806) return nil } else { - _t1374 := func(_dollar_dollar *pb.Type) *pb.UnspecifiedType { - var _t1375 *pb.UnspecifiedType + _t1384 := func(_dollar_dollar *pb.Type) *pb.UnspecifiedType { + var _t1385 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1375 = _dollar_dollar.GetUnspecifiedType() + _t1385 = _dollar_dollar.GetUnspecifiedType() } - return _t1375 + return _t1385 } - _t1376 := _t1374(msg) - deconstruct_result799 := _t1376 - if deconstruct_result799 != nil { - unwrapped800 := deconstruct_result799 - p.pretty_unspecified_type(unwrapped800) + _t1386 := _t1384(msg) + deconstruct_result804 := _t1386 + if deconstruct_result804 != nil { + unwrapped805 := deconstruct_result804 + p.pretty_unspecified_type(unwrapped805) } else { - _t1377 := func(_dollar_dollar *pb.Type) *pb.StringType { - var _t1378 *pb.StringType + _t1387 := func(_dollar_dollar *pb.Type) *pb.StringType { + var _t1388 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1378 = _dollar_dollar.GetStringType() + _t1388 = _dollar_dollar.GetStringType() } - return _t1378 + return _t1388 } - _t1379 := _t1377(msg) - deconstruct_result797 := _t1379 - if deconstruct_result797 != nil { - unwrapped798 := deconstruct_result797 - p.pretty_string_type(unwrapped798) + _t1389 := _t1387(msg) + deconstruct_result802 := _t1389 + if deconstruct_result802 != nil { + unwrapped803 := deconstruct_result802 + p.pretty_string_type(unwrapped803) } else { - _t1380 := func(_dollar_dollar *pb.Type) *pb.IntType { - var _t1381 *pb.IntType + _t1390 := func(_dollar_dollar *pb.Type) *pb.IntType { + var _t1391 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1381 = _dollar_dollar.GetIntType() + _t1391 = _dollar_dollar.GetIntType() } - return _t1381 + return _t1391 } - _t1382 := _t1380(msg) - deconstruct_result795 := _t1382 - if deconstruct_result795 != nil { - unwrapped796 := deconstruct_result795 - p.pretty_int_type(unwrapped796) + _t1392 := _t1390(msg) + deconstruct_result800 := _t1392 + if deconstruct_result800 != nil { + unwrapped801 := deconstruct_result800 + p.pretty_int_type(unwrapped801) } else { - _t1383 := func(_dollar_dollar *pb.Type) *pb.FloatType { - var _t1384 *pb.FloatType + _t1393 := func(_dollar_dollar *pb.Type) *pb.FloatType { + var _t1394 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1384 = _dollar_dollar.GetFloatType() + _t1394 = _dollar_dollar.GetFloatType() } - return _t1384 + return _t1394 } - _t1385 := _t1383(msg) - deconstruct_result793 := _t1385 - if deconstruct_result793 != nil { - unwrapped794 := deconstruct_result793 - p.pretty_float_type(unwrapped794) + _t1395 := _t1393(msg) + deconstruct_result798 := _t1395 + if deconstruct_result798 != nil { + unwrapped799 := deconstruct_result798 + p.pretty_float_type(unwrapped799) } else { - _t1386 := func(_dollar_dollar *pb.Type) *pb.UInt128Type { - var _t1387 *pb.UInt128Type + _t1396 := func(_dollar_dollar *pb.Type) *pb.UInt128Type { + var _t1397 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1387 = _dollar_dollar.GetUint128Type() + _t1397 = _dollar_dollar.GetUint128Type() } - return _t1387 + return _t1397 } - _t1388 := _t1386(msg) - deconstruct_result791 := _t1388 - if deconstruct_result791 != nil { - unwrapped792 := deconstruct_result791 - p.pretty_uint128_type(unwrapped792) + _t1398 := _t1396(msg) + deconstruct_result796 := _t1398 + if deconstruct_result796 != nil { + unwrapped797 := deconstruct_result796 + p.pretty_uint128_type(unwrapped797) } else { - _t1389 := func(_dollar_dollar *pb.Type) *pb.Int128Type { - var _t1390 *pb.Int128Type + _t1399 := func(_dollar_dollar *pb.Type) *pb.Int128Type { + var _t1400 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1390 = _dollar_dollar.GetInt128Type() + _t1400 = _dollar_dollar.GetInt128Type() } - return _t1390 + return _t1400 } - _t1391 := _t1389(msg) - deconstruct_result789 := _t1391 - if deconstruct_result789 != nil { - unwrapped790 := deconstruct_result789 - p.pretty_int128_type(unwrapped790) + _t1401 := _t1399(msg) + deconstruct_result794 := _t1401 + if deconstruct_result794 != nil { + unwrapped795 := deconstruct_result794 + p.pretty_int128_type(unwrapped795) } else { - _t1392 := func(_dollar_dollar *pb.Type) *pb.DateType { - var _t1393 *pb.DateType + _t1402 := func(_dollar_dollar *pb.Type) *pb.DateType { + var _t1403 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1393 = _dollar_dollar.GetDateType() + _t1403 = _dollar_dollar.GetDateType() } - return _t1393 + return _t1403 } - _t1394 := _t1392(msg) - deconstruct_result787 := _t1394 - if deconstruct_result787 != nil { - unwrapped788 := deconstruct_result787 - p.pretty_date_type(unwrapped788) + _t1404 := _t1402(msg) + deconstruct_result792 := _t1404 + if deconstruct_result792 != nil { + unwrapped793 := deconstruct_result792 + p.pretty_date_type(unwrapped793) } else { - _t1395 := func(_dollar_dollar *pb.Type) *pb.DateTimeType { - var _t1396 *pb.DateTimeType + _t1405 := func(_dollar_dollar *pb.Type) *pb.DateTimeType { + var _t1406 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1396 = _dollar_dollar.GetDatetimeType() + _t1406 = _dollar_dollar.GetDatetimeType() } - return _t1396 + return _t1406 } - _t1397 := _t1395(msg) - deconstruct_result785 := _t1397 - if deconstruct_result785 != nil { - unwrapped786 := deconstruct_result785 - p.pretty_datetime_type(unwrapped786) + _t1407 := _t1405(msg) + deconstruct_result790 := _t1407 + if deconstruct_result790 != nil { + unwrapped791 := deconstruct_result790 + p.pretty_datetime_type(unwrapped791) } else { - _t1398 := func(_dollar_dollar *pb.Type) *pb.MissingType { - var _t1399 *pb.MissingType + _t1408 := func(_dollar_dollar *pb.Type) *pb.MissingType { + var _t1409 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1399 = _dollar_dollar.GetMissingType() + _t1409 = _dollar_dollar.GetMissingType() } - return _t1399 + return _t1409 } - _t1400 := _t1398(msg) - deconstruct_result783 := _t1400 - if deconstruct_result783 != nil { - unwrapped784 := deconstruct_result783 - p.pretty_missing_type(unwrapped784) + _t1410 := _t1408(msg) + deconstruct_result788 := _t1410 + if deconstruct_result788 != nil { + unwrapped789 := deconstruct_result788 + p.pretty_missing_type(unwrapped789) } else { - _t1401 := func(_dollar_dollar *pb.Type) *pb.DecimalType { - var _t1402 *pb.DecimalType + _t1411 := func(_dollar_dollar *pb.Type) *pb.DecimalType { + var _t1412 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1402 = _dollar_dollar.GetDecimalType() + _t1412 = _dollar_dollar.GetDecimalType() } - return _t1402 + return _t1412 } - _t1403 := _t1401(msg) - deconstruct_result781 := _t1403 - if deconstruct_result781 != nil { - unwrapped782 := deconstruct_result781 - p.pretty_decimal_type(unwrapped782) + _t1413 := _t1411(msg) + deconstruct_result786 := _t1413 + if deconstruct_result786 != nil { + unwrapped787 := deconstruct_result786 + p.pretty_decimal_type(unwrapped787) } else { - _t1404 := func(_dollar_dollar *pb.Type) *pb.BooleanType { - var _t1405 *pb.BooleanType + _t1414 := func(_dollar_dollar *pb.Type) *pb.BooleanType { + var _t1415 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1405 = _dollar_dollar.GetBooleanType() + _t1415 = _dollar_dollar.GetBooleanType() } - return _t1405 + return _t1415 } - _t1406 := _t1404(msg) - deconstruct_result779 := _t1406 - if deconstruct_result779 != nil { - unwrapped780 := deconstruct_result779 - p.pretty_boolean_type(unwrapped780) + _t1416 := _t1414(msg) + deconstruct_result784 := _t1416 + if deconstruct_result784 != nil { + unwrapped785 := deconstruct_result784 + p.pretty_boolean_type(unwrapped785) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1503,89 +1503,89 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields802 := msg - _ = fields802 + fields807 := msg + _ = fields807 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields803 := msg - _ = fields803 + fields808 := msg + _ = fields808 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields804 := msg - _ = fields804 + fields809 := msg + _ = fields809 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields805 := msg - _ = fields805 + fields810 := msg + _ = fields810 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields806 := msg - _ = fields806 + fields811 := msg + _ = fields811 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields807 := msg - _ = fields807 + fields812 := msg + _ = fields812 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields808 := msg - _ = fields808 + fields813 := msg + _ = fields813 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields809 := msg - _ = fields809 + fields814 := msg + _ = fields814 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields810 := msg - _ = fields810 + fields815 := msg + _ = fields815 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat815 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat815 != nil { - p.write(*flat815) + flat820 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat820 != nil { + p.write(*flat820) return nil } else { - _t1407 := func(_dollar_dollar *pb.DecimalType) []interface{} { + _t1417 := func(_dollar_dollar *pb.DecimalType) []interface{} { return []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} } - _t1408 := _t1407(msg) - fields811 := _t1408 - unwrapped_fields812 := fields811 + _t1418 := _t1417(msg) + fields816 := _t1418 + unwrapped_fields817 := fields816 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field813 := unwrapped_fields812[0].(int64) - p.write(fmt.Sprintf("%d", field813)) + field818 := unwrapped_fields817[0].(int64) + p.write(fmt.Sprintf("%d", field818)) p.newline() - field814 := unwrapped_fields812[1].(int64) - p.write(fmt.Sprintf("%d", field814)) + field819 := unwrapped_fields817[1].(int64) + p.write(fmt.Sprintf("%d", field819)) p.dedent() p.write(")") } @@ -1593,27 +1593,27 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields816 := msg - _ = fields816 + fields821 := msg + _ = fields821 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat820 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat820 != nil { - p.write(*flat820) + flat825 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat825 != nil { + p.write(*flat825) return nil } else { - fields817 := msg + fields822 := msg p.write("|") - if !(len(fields817) == 0) { + if !(len(fields822) == 0) { p.write(" ") - for i819, elem818 := range fields817 { - if (i819 > 0) { + for i824, elem823 := range fields822 { + if (i824 > 0) { p.newline() } - p.pretty_binding(elem818) + p.pretty_binding(elem823) } } } @@ -1621,179 +1621,179 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat847 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat847 != nil { - p.write(*flat847) + flat852 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat852 != nil { + p.write(*flat852) return nil } else { - _t1409 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { - var _t1410 *pb.Conjunction + _t1419 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { + var _t1420 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1410 = _dollar_dollar.GetConjunction() + _t1420 = _dollar_dollar.GetConjunction() } - return _t1410 + return _t1420 } - _t1411 := _t1409(msg) - deconstruct_result845 := _t1411 - if deconstruct_result845 != nil { - unwrapped846 := deconstruct_result845 - p.pretty_true(unwrapped846) + _t1421 := _t1419(msg) + deconstruct_result850 := _t1421 + if deconstruct_result850 != nil { + unwrapped851 := deconstruct_result850 + p.pretty_true(unwrapped851) } else { - _t1412 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { - var _t1413 *pb.Disjunction + _t1422 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { + var _t1423 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1413 = _dollar_dollar.GetDisjunction() + _t1423 = _dollar_dollar.GetDisjunction() } - return _t1413 + return _t1423 } - _t1414 := _t1412(msg) - deconstruct_result843 := _t1414 - if deconstruct_result843 != nil { - unwrapped844 := deconstruct_result843 - p.pretty_false(unwrapped844) + _t1424 := _t1422(msg) + deconstruct_result848 := _t1424 + if deconstruct_result848 != nil { + unwrapped849 := deconstruct_result848 + p.pretty_false(unwrapped849) } else { - _t1415 := func(_dollar_dollar *pb.Formula) *pb.Exists { - var _t1416 *pb.Exists + _t1425 := func(_dollar_dollar *pb.Formula) *pb.Exists { + var _t1426 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1416 = _dollar_dollar.GetExists() + _t1426 = _dollar_dollar.GetExists() } - return _t1416 + return _t1426 } - _t1417 := _t1415(msg) - deconstruct_result841 := _t1417 - if deconstruct_result841 != nil { - unwrapped842 := deconstruct_result841 - p.pretty_exists(unwrapped842) + _t1427 := _t1425(msg) + deconstruct_result846 := _t1427 + if deconstruct_result846 != nil { + unwrapped847 := deconstruct_result846 + p.pretty_exists(unwrapped847) } else { - _t1418 := func(_dollar_dollar *pb.Formula) *pb.Reduce { - var _t1419 *pb.Reduce + _t1428 := func(_dollar_dollar *pb.Formula) *pb.Reduce { + var _t1429 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1419 = _dollar_dollar.GetReduce() + _t1429 = _dollar_dollar.GetReduce() } - return _t1419 + return _t1429 } - _t1420 := _t1418(msg) - deconstruct_result839 := _t1420 - if deconstruct_result839 != nil { - unwrapped840 := deconstruct_result839 - p.pretty_reduce(unwrapped840) + _t1430 := _t1428(msg) + deconstruct_result844 := _t1430 + if deconstruct_result844 != nil { + unwrapped845 := deconstruct_result844 + p.pretty_reduce(unwrapped845) } else { - _t1421 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { - var _t1422 *pb.Conjunction + _t1431 := func(_dollar_dollar *pb.Formula) *pb.Conjunction { + var _t1432 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1422 = _dollar_dollar.GetConjunction() + _t1432 = _dollar_dollar.GetConjunction() } - return _t1422 + return _t1432 } - _t1423 := _t1421(msg) - deconstruct_result837 := _t1423 - if deconstruct_result837 != nil { - unwrapped838 := deconstruct_result837 - p.pretty_conjunction(unwrapped838) + _t1433 := _t1431(msg) + deconstruct_result842 := _t1433 + if deconstruct_result842 != nil { + unwrapped843 := deconstruct_result842 + p.pretty_conjunction(unwrapped843) } else { - _t1424 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { - var _t1425 *pb.Disjunction + _t1434 := func(_dollar_dollar *pb.Formula) *pb.Disjunction { + var _t1435 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1425 = _dollar_dollar.GetDisjunction() + _t1435 = _dollar_dollar.GetDisjunction() } - return _t1425 + return _t1435 } - _t1426 := _t1424(msg) - deconstruct_result835 := _t1426 - if deconstruct_result835 != nil { - unwrapped836 := deconstruct_result835 - p.pretty_disjunction(unwrapped836) + _t1436 := _t1434(msg) + deconstruct_result840 := _t1436 + if deconstruct_result840 != nil { + unwrapped841 := deconstruct_result840 + p.pretty_disjunction(unwrapped841) } else { - _t1427 := func(_dollar_dollar *pb.Formula) *pb.Not { - var _t1428 *pb.Not + _t1437 := func(_dollar_dollar *pb.Formula) *pb.Not { + var _t1438 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1428 = _dollar_dollar.GetNot() + _t1438 = _dollar_dollar.GetNot() } - return _t1428 + return _t1438 } - _t1429 := _t1427(msg) - deconstruct_result833 := _t1429 - if deconstruct_result833 != nil { - unwrapped834 := deconstruct_result833 - p.pretty_not(unwrapped834) + _t1439 := _t1437(msg) + deconstruct_result838 := _t1439 + if deconstruct_result838 != nil { + unwrapped839 := deconstruct_result838 + p.pretty_not(unwrapped839) } else { - _t1430 := func(_dollar_dollar *pb.Formula) *pb.FFI { - var _t1431 *pb.FFI + _t1440 := func(_dollar_dollar *pb.Formula) *pb.FFI { + var _t1441 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1431 = _dollar_dollar.GetFfi() + _t1441 = _dollar_dollar.GetFfi() } - return _t1431 + return _t1441 } - _t1432 := _t1430(msg) - deconstruct_result831 := _t1432 - if deconstruct_result831 != nil { - unwrapped832 := deconstruct_result831 - p.pretty_ffi(unwrapped832) + _t1442 := _t1440(msg) + deconstruct_result836 := _t1442 + if deconstruct_result836 != nil { + unwrapped837 := deconstruct_result836 + p.pretty_ffi(unwrapped837) } else { - _t1433 := func(_dollar_dollar *pb.Formula) *pb.Atom { - var _t1434 *pb.Atom + _t1443 := func(_dollar_dollar *pb.Formula) *pb.Atom { + var _t1444 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1434 = _dollar_dollar.GetAtom() + _t1444 = _dollar_dollar.GetAtom() } - return _t1434 + return _t1444 } - _t1435 := _t1433(msg) - deconstruct_result829 := _t1435 - if deconstruct_result829 != nil { - unwrapped830 := deconstruct_result829 - p.pretty_atom(unwrapped830) + _t1445 := _t1443(msg) + deconstruct_result834 := _t1445 + if deconstruct_result834 != nil { + unwrapped835 := deconstruct_result834 + p.pretty_atom(unwrapped835) } else { - _t1436 := func(_dollar_dollar *pb.Formula) *pb.Pragma { - var _t1437 *pb.Pragma + _t1446 := func(_dollar_dollar *pb.Formula) *pb.Pragma { + var _t1447 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1437 = _dollar_dollar.GetPragma() + _t1447 = _dollar_dollar.GetPragma() } - return _t1437 + return _t1447 } - _t1438 := _t1436(msg) - deconstruct_result827 := _t1438 - if deconstruct_result827 != nil { - unwrapped828 := deconstruct_result827 - p.pretty_pragma(unwrapped828) + _t1448 := _t1446(msg) + deconstruct_result832 := _t1448 + if deconstruct_result832 != nil { + unwrapped833 := deconstruct_result832 + p.pretty_pragma(unwrapped833) } else { - _t1439 := func(_dollar_dollar *pb.Formula) *pb.Primitive { - var _t1440 *pb.Primitive + _t1449 := func(_dollar_dollar *pb.Formula) *pb.Primitive { + var _t1450 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1440 = _dollar_dollar.GetPrimitive() + _t1450 = _dollar_dollar.GetPrimitive() } - return _t1440 + return _t1450 } - _t1441 := _t1439(msg) - deconstruct_result825 := _t1441 - if deconstruct_result825 != nil { - unwrapped826 := deconstruct_result825 - p.pretty_primitive(unwrapped826) + _t1451 := _t1449(msg) + deconstruct_result830 := _t1451 + if deconstruct_result830 != nil { + unwrapped831 := deconstruct_result830 + p.pretty_primitive(unwrapped831) } else { - _t1442 := func(_dollar_dollar *pb.Formula) *pb.RelAtom { - var _t1443 *pb.RelAtom + _t1452 := func(_dollar_dollar *pb.Formula) *pb.RelAtom { + var _t1453 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1443 = _dollar_dollar.GetRelAtom() + _t1453 = _dollar_dollar.GetRelAtom() } - return _t1443 + return _t1453 } - _t1444 := _t1442(msg) - deconstruct_result823 := _t1444 - if deconstruct_result823 != nil { - unwrapped824 := deconstruct_result823 - p.pretty_rel_atom(unwrapped824) + _t1454 := _t1452(msg) + deconstruct_result828 := _t1454 + if deconstruct_result828 != nil { + unwrapped829 := deconstruct_result828 + p.pretty_rel_atom(unwrapped829) } else { - _t1445 := func(_dollar_dollar *pb.Formula) *pb.Cast { - var _t1446 *pb.Cast + _t1455 := func(_dollar_dollar *pb.Formula) *pb.Cast { + var _t1456 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1446 = _dollar_dollar.GetCast() + _t1456 = _dollar_dollar.GetCast() } - return _t1446 + return _t1456 } - _t1447 := _t1445(msg) - deconstruct_result821 := _t1447 - if deconstruct_result821 != nil { - unwrapped822 := deconstruct_result821 - p.pretty_cast(unwrapped822) + _t1457 := _t1455(msg) + deconstruct_result826 := _t1457 + if deconstruct_result826 != nil { + unwrapped827 := deconstruct_result826 + p.pretty_cast(unwrapped827) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1814,8 +1814,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields848 := msg - _ = fields848 + fields853 := msg + _ = fields853 p.write("(") p.write("true") p.write(")") @@ -1823,8 +1823,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields849 := msg - _ = fields849 + fields854 := msg + _ = fields854 p.write("(") p.write("false") p.write(")") @@ -1832,27 +1832,27 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat854 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat854 != nil { - p.write(*flat854) + flat859 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat859 != nil { + p.write(*flat859) return nil } else { - _t1448 := func(_dollar_dollar *pb.Exists) []interface{} { - _t1449 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - return []interface{}{_t1449, _dollar_dollar.GetBody().GetValue()} + _t1458 := func(_dollar_dollar *pb.Exists) []interface{} { + _t1459 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + return []interface{}{_t1459, _dollar_dollar.GetBody().GetValue()} } - _t1450 := _t1448(msg) - fields850 := _t1450 - unwrapped_fields851 := fields850 + _t1460 := _t1458(msg) + fields855 := _t1460 + unwrapped_fields856 := fields855 p.write("(") p.write("exists") p.indentSexp() p.newline() - field852 := unwrapped_fields851[0].([]interface{}) - p.pretty_bindings(field852) + field857 := unwrapped_fields856[0].([]interface{}) + p.pretty_bindings(field857) p.newline() - field853 := unwrapped_fields851[1].(*pb.Formula) - p.pretty_formula(field853) + field858 := unwrapped_fields856[1].(*pb.Formula) + p.pretty_formula(field858) p.dedent() p.write(")") } @@ -1860,29 +1860,29 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat860 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat860 != nil { - p.write(*flat860) + flat865 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat865 != nil { + p.write(*flat865) return nil } else { - _t1451 := func(_dollar_dollar *pb.Reduce) []interface{} { + _t1461 := func(_dollar_dollar *pb.Reduce) []interface{} { return []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} } - _t1452 := _t1451(msg) - fields855 := _t1452 - unwrapped_fields856 := fields855 + _t1462 := _t1461(msg) + fields860 := _t1462 + unwrapped_fields861 := fields860 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field857 := unwrapped_fields856[0].(*pb.Abstraction) - p.pretty_abstraction(field857) + field862 := unwrapped_fields861[0].(*pb.Abstraction) + p.pretty_abstraction(field862) p.newline() - field858 := unwrapped_fields856[1].(*pb.Abstraction) - p.pretty_abstraction(field858) + field863 := unwrapped_fields861[1].(*pb.Abstraction) + p.pretty_abstraction(field863) p.newline() - field859 := unwrapped_fields856[2].([]*pb.Term) - p.pretty_terms(field859) + field864 := unwrapped_fields861[2].([]*pb.Term) + p.pretty_terms(field864) p.dedent() p.write(")") } @@ -1890,22 +1890,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat864 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat864 != nil { - p.write(*flat864) + flat869 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat869 != nil { + p.write(*flat869) return nil } else { - fields861 := msg + fields866 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields861) == 0) { + if !(len(fields866) == 0) { p.newline() - for i863, elem862 := range fields861 { - if (i863 > 0) { + for i868, elem867 := range fields866 { + if (i868 > 0) { p.newline() } - p.pretty_term(elem862) + p.pretty_term(elem867) } } p.dedent() @@ -1915,36 +1915,36 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat869 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat869 != nil { - p.write(*flat869) + flat874 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat874 != nil { + p.write(*flat874) return nil } else { - _t1453 := func(_dollar_dollar *pb.Term) *pb.Var { - var _t1454 *pb.Var + _t1463 := func(_dollar_dollar *pb.Term) *pb.Var { + var _t1464 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1454 = _dollar_dollar.GetVar() + _t1464 = _dollar_dollar.GetVar() } - return _t1454 + return _t1464 } - _t1455 := _t1453(msg) - deconstruct_result867 := _t1455 - if deconstruct_result867 != nil { - unwrapped868 := deconstruct_result867 - p.pretty_var(unwrapped868) + _t1465 := _t1463(msg) + deconstruct_result872 := _t1465 + if deconstruct_result872 != nil { + unwrapped873 := deconstruct_result872 + p.pretty_var(unwrapped873) } else { - _t1456 := func(_dollar_dollar *pb.Term) *pb.Value { - var _t1457 *pb.Value + _t1466 := func(_dollar_dollar *pb.Term) *pb.Value { + var _t1467 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1457 = _dollar_dollar.GetConstant() + _t1467 = _dollar_dollar.GetConstant() } - return _t1457 + return _t1467 } - _t1458 := _t1456(msg) - deconstruct_result865 := _t1458 - if deconstruct_result865 != nil { - unwrapped866 := deconstruct_result865 - p.pretty_constant(unwrapped866) + _t1468 := _t1466(msg) + deconstruct_result870 := _t1468 + if deconstruct_result870 != nil { + unwrapped871 := deconstruct_result870 + p.pretty_constant(unwrapped871) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1954,56 +1954,56 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat872 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat872 != nil { - p.write(*flat872) + flat877 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat877 != nil { + p.write(*flat877) return nil } else { - _t1459 := func(_dollar_dollar *pb.Var) string { + _t1469 := func(_dollar_dollar *pb.Var) string { return _dollar_dollar.GetName() } - _t1460 := _t1459(msg) - fields870 := _t1460 - unwrapped_fields871 := fields870 - p.write(unwrapped_fields871) + _t1470 := _t1469(msg) + fields875 := _t1470 + unwrapped_fields876 := fields875 + p.write(unwrapped_fields876) } return nil } func (p *PrettyPrinter) pretty_constant(msg *pb.Value) interface{} { - flat874 := p.tryFlat(msg, func() { p.pretty_constant(msg) }) - if flat874 != nil { - p.write(*flat874) + flat879 := p.tryFlat(msg, func() { p.pretty_constant(msg) }) + if flat879 != nil { + p.write(*flat879) return nil } else { - fields873 := msg - p.pretty_value(fields873) + fields878 := msg + p.pretty_value(fields878) } return nil } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat879 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat879 != nil { - p.write(*flat879) + flat884 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat884 != nil { + p.write(*flat884) return nil } else { - _t1461 := func(_dollar_dollar *pb.Conjunction) []*pb.Formula { + _t1471 := func(_dollar_dollar *pb.Conjunction) []*pb.Formula { return _dollar_dollar.GetArgs() } - _t1462 := _t1461(msg) - fields875 := _t1462 - unwrapped_fields876 := fields875 + _t1472 := _t1471(msg) + fields880 := _t1472 + unwrapped_fields881 := fields880 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields876) == 0) { + if !(len(unwrapped_fields881) == 0) { p.newline() - for i878, elem877 := range unwrapped_fields876 { - if (i878 > 0) { + for i883, elem882 := range unwrapped_fields881 { + if (i883 > 0) { p.newline() } - p.pretty_formula(elem877) + p.pretty_formula(elem882) } } p.dedent() @@ -2013,27 +2013,27 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat884 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat884 != nil { - p.write(*flat884) + flat889 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat889 != nil { + p.write(*flat889) return nil } else { - _t1463 := func(_dollar_dollar *pb.Disjunction) []*pb.Formula { + _t1473 := func(_dollar_dollar *pb.Disjunction) []*pb.Formula { return _dollar_dollar.GetArgs() } - _t1464 := _t1463(msg) - fields880 := _t1464 - unwrapped_fields881 := fields880 + _t1474 := _t1473(msg) + fields885 := _t1474 + unwrapped_fields886 := fields885 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields881) == 0) { + if !(len(unwrapped_fields886) == 0) { p.newline() - for i883, elem882 := range unwrapped_fields881 { - if (i883 > 0) { + for i888, elem887 := range unwrapped_fields886 { + if (i888 > 0) { p.newline() } - p.pretty_formula(elem882) + p.pretty_formula(elem887) } } p.dedent() @@ -2043,22 +2043,22 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat887 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat887 != nil { - p.write(*flat887) + flat892 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat892 != nil { + p.write(*flat892) return nil } else { - _t1465 := func(_dollar_dollar *pb.Not) *pb.Formula { + _t1475 := func(_dollar_dollar *pb.Not) *pb.Formula { return _dollar_dollar.GetArg() } - _t1466 := _t1465(msg) - fields885 := _t1466 - unwrapped_fields886 := fields885 + _t1476 := _t1475(msg) + fields890 := _t1476 + unwrapped_fields891 := fields890 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields886) + p.pretty_formula(unwrapped_fields891) p.dedent() p.write(")") } @@ -2066,29 +2066,29 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat893 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat893 != nil { - p.write(*flat893) + flat898 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat898 != nil { + p.write(*flat898) return nil } else { - _t1467 := func(_dollar_dollar *pb.FFI) []interface{} { + _t1477 := func(_dollar_dollar *pb.FFI) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} } - _t1468 := _t1467(msg) - fields888 := _t1468 - unwrapped_fields889 := fields888 + _t1478 := _t1477(msg) + fields893 := _t1478 + unwrapped_fields894 := fields893 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field890 := unwrapped_fields889[0].(string) - p.pretty_name(field890) + field895 := unwrapped_fields894[0].(string) + p.pretty_name(field895) p.newline() - field891 := unwrapped_fields889[1].([]*pb.Abstraction) - p.pretty_ffi_args(field891) + field896 := unwrapped_fields894[1].([]*pb.Abstraction) + p.pretty_ffi_args(field896) p.newline() - field892 := unwrapped_fields889[2].([]*pb.Term) - p.pretty_terms(field892) + field897 := unwrapped_fields894[2].([]*pb.Term) + p.pretty_terms(field897) p.dedent() p.write(")") } @@ -2096,35 +2096,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat895 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat895 != nil { - p.write(*flat895) + flat900 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat900 != nil { + p.write(*flat900) return nil } else { - fields894 := msg + fields899 := msg p.write(":") - p.write(fields894) + p.write(fields899) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat899 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat899 != nil { - p.write(*flat899) + flat904 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat904 != nil { + p.write(*flat904) return nil } else { - fields896 := msg + fields901 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields896) == 0) { + if !(len(fields901) == 0) { p.newline() - for i898, elem897 := range fields896 { - if (i898 > 0) { + for i903, elem902 := range fields901 { + if (i903 > 0) { p.newline() } - p.pretty_abstraction(elem897) + p.pretty_abstraction(elem902) } } p.dedent() @@ -2134,31 +2134,31 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat906 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat906 != nil { - p.write(*flat906) + flat911 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat911 != nil { + p.write(*flat911) return nil } else { - _t1469 := func(_dollar_dollar *pb.Atom) []interface{} { + _t1479 := func(_dollar_dollar *pb.Atom) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1470 := _t1469(msg) - fields900 := _t1470 - unwrapped_fields901 := fields900 + _t1480 := _t1479(msg) + fields905 := _t1480 + unwrapped_fields906 := fields905 p.write("(") p.write("atom") p.indentSexp() p.newline() - field902 := unwrapped_fields901[0].(*pb.RelationId) - p.pretty_relation_id(field902) - field903 := unwrapped_fields901[1].([]*pb.Term) - if !(len(field903) == 0) { + field907 := unwrapped_fields906[0].(*pb.RelationId) + p.pretty_relation_id(field907) + field908 := unwrapped_fields906[1].([]*pb.Term) + if !(len(field908) == 0) { p.newline() - for i905, elem904 := range field903 { - if (i905 > 0) { + for i910, elem909 := range field908 { + if (i910 > 0) { p.newline() } - p.pretty_term(elem904) + p.pretty_term(elem909) } } p.dedent() @@ -2168,31 +2168,31 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat913 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat913 != nil { - p.write(*flat913) + flat918 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat918 != nil { + p.write(*flat918) return nil } else { - _t1471 := func(_dollar_dollar *pb.Pragma) []interface{} { + _t1481 := func(_dollar_dollar *pb.Pragma) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1472 := _t1471(msg) - fields907 := _t1472 - unwrapped_fields908 := fields907 + _t1482 := _t1481(msg) + fields912 := _t1482 + unwrapped_fields913 := fields912 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field909 := unwrapped_fields908[0].(string) - p.pretty_name(field909) - field910 := unwrapped_fields908[1].([]*pb.Term) - if !(len(field910) == 0) { + field914 := unwrapped_fields913[0].(string) + p.pretty_name(field914) + field915 := unwrapped_fields913[1].([]*pb.Term) + if !(len(field915) == 0) { p.newline() - for i912, elem911 := range field910 { - if (i912 > 0) { + for i917, elem916 := range field915 { + if (i917 > 0) { p.newline() } - p.pretty_term(elem911) + p.pretty_term(elem916) } } p.dedent() @@ -2202,139 +2202,139 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat929 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat929 != nil { - p.write(*flat929) + flat934 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat934 != nil { + p.write(*flat934) return nil } else { - _t1473 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1474 []interface{} + _t1483 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1484 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1474 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1484 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1474 + return _t1484 } - _t1475 := _t1473(msg) - guard_result928 := _t1475 - if guard_result928 != nil { + _t1485 := _t1483(msg) + guard_result933 := _t1485 + if guard_result933 != nil { p.pretty_eq(msg) } else { - _t1476 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1477 []interface{} + _t1486 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1487 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1477 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1487 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1477 + return _t1487 } - _t1478 := _t1476(msg) - guard_result927 := _t1478 - if guard_result927 != nil { + _t1488 := _t1486(msg) + guard_result932 := _t1488 + if guard_result932 != nil { p.pretty_lt(msg) } else { - _t1479 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1480 []interface{} + _t1489 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1490 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1480 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1490 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1480 + return _t1490 } - _t1481 := _t1479(msg) - guard_result926 := _t1481 - if guard_result926 != nil { + _t1491 := _t1489(msg) + guard_result931 := _t1491 + if guard_result931 != nil { p.pretty_lt_eq(msg) } else { - _t1482 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1483 []interface{} + _t1492 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1493 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1483 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1493 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1483 + return _t1493 } - _t1484 := _t1482(msg) - guard_result925 := _t1484 - if guard_result925 != nil { + _t1494 := _t1492(msg) + guard_result930 := _t1494 + if guard_result930 != nil { p.pretty_gt(msg) } else { - _t1485 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1486 []interface{} + _t1495 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1496 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1486 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1496 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1486 + return _t1496 } - _t1487 := _t1485(msg) - guard_result924 := _t1487 - if guard_result924 != nil { + _t1497 := _t1495(msg) + guard_result929 := _t1497 + if guard_result929 != nil { p.pretty_gt_eq(msg) } else { - _t1488 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1489 []interface{} + _t1498 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1499 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1489 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1499 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1489 + return _t1499 } - _t1490 := _t1488(msg) - guard_result923 := _t1490 - if guard_result923 != nil { + _t1500 := _t1498(msg) + guard_result928 := _t1500 + if guard_result928 != nil { p.pretty_add(msg) } else { - _t1491 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1492 []interface{} + _t1501 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1502 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1492 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1502 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1492 + return _t1502 } - _t1493 := _t1491(msg) - guard_result922 := _t1493 - if guard_result922 != nil { + _t1503 := _t1501(msg) + guard_result927 := _t1503 + if guard_result927 != nil { p.pretty_minus(msg) } else { - _t1494 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1495 []interface{} + _t1504 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1505 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1495 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1505 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1495 + return _t1505 } - _t1496 := _t1494(msg) - guard_result921 := _t1496 - if guard_result921 != nil { + _t1506 := _t1504(msg) + guard_result926 := _t1506 + if guard_result926 != nil { p.pretty_multiply(msg) } else { - _t1497 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1498 []interface{} + _t1507 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1508 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1498 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1508 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1498 + return _t1508 } - _t1499 := _t1497(msg) - guard_result920 := _t1499 - if guard_result920 != nil { + _t1509 := _t1507(msg) + guard_result925 := _t1509 + if guard_result925 != nil { p.pretty_divide(msg) } else { - _t1500 := func(_dollar_dollar *pb.Primitive) []interface{} { + _t1510 := func(_dollar_dollar *pb.Primitive) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1501 := _t1500(msg) - fields914 := _t1501 - unwrapped_fields915 := fields914 + _t1511 := _t1510(msg) + fields919 := _t1511 + unwrapped_fields920 := fields919 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field916 := unwrapped_fields915[0].(string) - p.pretty_name(field916) - field917 := unwrapped_fields915[1].([]*pb.RelTerm) - if !(len(field917) == 0) { + field921 := unwrapped_fields920[0].(string) + p.pretty_name(field921) + field922 := unwrapped_fields920[1].([]*pb.RelTerm) + if !(len(field922) == 0) { p.newline() - for i919, elem918 := range field917 { - if (i919 > 0) { + for i924, elem923 := range field922 { + if (i924 > 0) { p.newline() } - p.pretty_rel_term(elem918) + p.pretty_rel_term(elem923) } } p.dedent() @@ -2353,54 +2353,23 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat934 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat934 != nil { - p.write(*flat934) - return nil - } else { - _t1502 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1503 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1503 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - return _t1503 - } - _t1504 := _t1502(msg) - fields930 := _t1504 - unwrapped_fields931 := fields930 - p.write("(") - p.write("=") - p.indentSexp() - p.newline() - field932 := unwrapped_fields931[0].(*pb.Term) - p.pretty_term(field932) - p.newline() - field933 := unwrapped_fields931[1].(*pb.Term) - p.pretty_term(field933) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat939 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + flat939 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) if flat939 != nil { p.write(*flat939) return nil } else { - _t1505 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1506 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1506 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1512 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1513 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_eq" { + _t1513 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1506 + return _t1513 } - _t1507 := _t1505(msg) - fields935 := _t1507 + _t1514 := _t1512(msg) + fields935 := _t1514 unwrapped_fields936 := fields935 p.write("(") - p.write("<") + p.write("=") p.indentSexp() p.newline() field937 := unwrapped_fields936[0].(*pb.Term) @@ -2414,24 +2383,24 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat944 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) +func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { + flat944 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) if flat944 != nil { p.write(*flat944) return nil } else { - _t1508 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1509 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1509 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1515 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1516 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { + _t1516 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1509 + return _t1516 } - _t1510 := _t1508(msg) - fields940 := _t1510 + _t1517 := _t1515(msg) + fields940 := _t1517 unwrapped_fields941 := fields940 p.write("(") - p.write("<=") + p.write("<") p.indentSexp() p.newline() field942 := unwrapped_fields941[0].(*pb.Term) @@ -2445,24 +2414,24 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat949 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) +func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { + flat949 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) if flat949 != nil { p.write(*flat949) return nil } else { - _t1511 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1512 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1512 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1518 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1519 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { + _t1519 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1512 + return _t1519 } - _t1513 := _t1511(msg) - fields945 := _t1513 + _t1520 := _t1518(msg) + fields945 := _t1520 unwrapped_fields946 := fields945 p.write("(") - p.write(">") + p.write("<=") p.indentSexp() p.newline() field947 := unwrapped_fields946[0].(*pb.Term) @@ -2476,24 +2445,24 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat954 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) +func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { + flat954 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) if flat954 != nil { p.write(*flat954) return nil } else { - _t1514 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1515 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1515 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1521 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1522 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { + _t1522 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1515 + return _t1522 } - _t1516 := _t1514(msg) - fields950 := _t1516 + _t1523 := _t1521(msg) + fields950 := _t1523 unwrapped_fields951 := fields950 p.write("(") - p.write(">=") + p.write(">") p.indentSexp() p.newline() field952 := unwrapped_fields951[0].(*pb.Term) @@ -2507,24 +2476,24 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat960 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat960 != nil { - p.write(*flat960) +func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { + flat959 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat959 != nil { + p.write(*flat959) return nil } else { - _t1517 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1518 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1518 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1524 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1525 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { + _t1525 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - return _t1518 + return _t1525 } - _t1519 := _t1517(msg) - fields955 := _t1519 + _t1526 := _t1524(msg) + fields955 := _t1526 unwrapped_fields956 := fields955 p.write("(") - p.write("+") + p.write(">=") p.indentSexp() p.newline() field957 := unwrapped_fields956[0].(*pb.Term) @@ -2532,9 +2501,40 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { p.newline() field958 := unwrapped_fields956[1].(*pb.Term) p.pretty_term(field958) + p.dedent() + p.write(")") + } + return nil +} + +func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { + flat965 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat965 != nil { + p.write(*flat965) + return nil + } else { + _t1527 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1528 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { + _t1528 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + } + return _t1528 + } + _t1529 := _t1527(msg) + fields960 := _t1529 + unwrapped_fields961 := fields960 + p.write("(") + p.write("+") + p.indentSexp() + p.newline() + field962 := unwrapped_fields961[0].(*pb.Term) + p.pretty_term(field962) p.newline() - field959 := unwrapped_fields956[2].(*pb.Term) - p.pretty_term(field959) + field963 := unwrapped_fields961[1].(*pb.Term) + p.pretty_term(field963) + p.newline() + field964 := unwrapped_fields961[2].(*pb.Term) + p.pretty_term(field964) p.dedent() p.write(")") } @@ -2542,33 +2542,33 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat966 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat966 != nil { - p.write(*flat966) + flat971 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat971 != nil { + p.write(*flat971) return nil } else { - _t1520 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1521 []interface{} + _t1530 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1531 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1521 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1531 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1521 + return _t1531 } - _t1522 := _t1520(msg) - fields961 := _t1522 - unwrapped_fields962 := fields961 + _t1532 := _t1530(msg) + fields966 := _t1532 + unwrapped_fields967 := fields966 p.write("(") p.write("-") p.indentSexp() p.newline() - field963 := unwrapped_fields962[0].(*pb.Term) - p.pretty_term(field963) + field968 := unwrapped_fields967[0].(*pb.Term) + p.pretty_term(field968) p.newline() - field964 := unwrapped_fields962[1].(*pb.Term) - p.pretty_term(field964) + field969 := unwrapped_fields967[1].(*pb.Term) + p.pretty_term(field969) p.newline() - field965 := unwrapped_fields962[2].(*pb.Term) - p.pretty_term(field965) + field970 := unwrapped_fields967[2].(*pb.Term) + p.pretty_term(field970) p.dedent() p.write(")") } @@ -2576,33 +2576,33 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat972 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat972 != nil { - p.write(*flat972) + flat977 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat977 != nil { + p.write(*flat977) return nil } else { - _t1523 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1524 []interface{} + _t1533 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1534 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1524 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1534 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1524 + return _t1534 } - _t1525 := _t1523(msg) - fields967 := _t1525 - unwrapped_fields968 := fields967 + _t1535 := _t1533(msg) + fields972 := _t1535 + unwrapped_fields973 := fields972 p.write("(") p.write("*") p.indentSexp() p.newline() - field969 := unwrapped_fields968[0].(*pb.Term) - p.pretty_term(field969) + field974 := unwrapped_fields973[0].(*pb.Term) + p.pretty_term(field974) p.newline() - field970 := unwrapped_fields968[1].(*pb.Term) - p.pretty_term(field970) + field975 := unwrapped_fields973[1].(*pb.Term) + p.pretty_term(field975) p.newline() - field971 := unwrapped_fields968[2].(*pb.Term) - p.pretty_term(field971) + field976 := unwrapped_fields973[2].(*pb.Term) + p.pretty_term(field976) p.dedent() p.write(")") } @@ -2610,33 +2610,33 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat978 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat978 != nil { - p.write(*flat978) + flat983 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat983 != nil { + p.write(*flat983) return nil } else { - _t1526 := func(_dollar_dollar *pb.Primitive) []interface{} { - var _t1527 []interface{} + _t1536 := func(_dollar_dollar *pb.Primitive) []interface{} { + var _t1537 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1527 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1537 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - return _t1527 + return _t1537 } - _t1528 := _t1526(msg) - fields973 := _t1528 - unwrapped_fields974 := fields973 + _t1538 := _t1536(msg) + fields978 := _t1538 + unwrapped_fields979 := fields978 p.write("(") p.write("/") p.indentSexp() p.newline() - field975 := unwrapped_fields974[0].(*pb.Term) - p.pretty_term(field975) + field980 := unwrapped_fields979[0].(*pb.Term) + p.pretty_term(field980) p.newline() - field976 := unwrapped_fields974[1].(*pb.Term) - p.pretty_term(field976) + field981 := unwrapped_fields979[1].(*pb.Term) + p.pretty_term(field981) p.newline() - field977 := unwrapped_fields974[2].(*pb.Term) - p.pretty_term(field977) + field982 := unwrapped_fields979[2].(*pb.Term) + p.pretty_term(field982) p.dedent() p.write(")") } @@ -2644,36 +2644,36 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat983 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat983 != nil { - p.write(*flat983) + flat988 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat988 != nil { + p.write(*flat988) return nil } else { - _t1529 := func(_dollar_dollar *pb.RelTerm) *pb.Value { - var _t1530 *pb.Value + _t1539 := func(_dollar_dollar *pb.RelTerm) *pb.Value { + var _t1540 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1530 = _dollar_dollar.GetSpecializedValue() + _t1540 = _dollar_dollar.GetSpecializedValue() } - return _t1530 + return _t1540 } - _t1531 := _t1529(msg) - deconstruct_result981 := _t1531 - if deconstruct_result981 != nil { - unwrapped982 := deconstruct_result981 - p.pretty_specialized_value(unwrapped982) + _t1541 := _t1539(msg) + deconstruct_result986 := _t1541 + if deconstruct_result986 != nil { + unwrapped987 := deconstruct_result986 + p.pretty_specialized_value(unwrapped987) } else { - _t1532 := func(_dollar_dollar *pb.RelTerm) *pb.Term { - var _t1533 *pb.Term + _t1542 := func(_dollar_dollar *pb.RelTerm) *pb.Term { + var _t1543 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1533 = _dollar_dollar.GetTerm() + _t1543 = _dollar_dollar.GetTerm() } - return _t1533 + return _t1543 } - _t1534 := _t1532(msg) - deconstruct_result979 := _t1534 - if deconstruct_result979 != nil { - unwrapped980 := deconstruct_result979 - p.pretty_term(unwrapped980) + _t1544 := _t1542(msg) + deconstruct_result984 := _t1544 + if deconstruct_result984 != nil { + unwrapped985 := deconstruct_result984 + p.pretty_term(unwrapped985) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2683,44 +2683,44 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat985 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat985 != nil { - p.write(*flat985) + flat990 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat990 != nil { + p.write(*flat990) return nil } else { - fields984 := msg + fields989 := msg p.write("#") - p.pretty_value(fields984) + p.pretty_value(fields989) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat992 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat992 != nil { - p.write(*flat992) + flat997 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat997 != nil { + p.write(*flat997) return nil } else { - _t1535 := func(_dollar_dollar *pb.RelAtom) []interface{} { + _t1545 := func(_dollar_dollar *pb.RelAtom) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} } - _t1536 := _t1535(msg) - fields986 := _t1536 - unwrapped_fields987 := fields986 + _t1546 := _t1545(msg) + fields991 := _t1546 + unwrapped_fields992 := fields991 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field988 := unwrapped_fields987[0].(string) - p.pretty_name(field988) - field989 := unwrapped_fields987[1].([]*pb.RelTerm) - if !(len(field989) == 0) { + field993 := unwrapped_fields992[0].(string) + p.pretty_name(field993) + field994 := unwrapped_fields992[1].([]*pb.RelTerm) + if !(len(field994) == 0) { p.newline() - for i991, elem990 := range field989 { - if (i991 > 0) { + for i996, elem995 := range field994 { + if (i996 > 0) { p.newline() } - p.pretty_rel_term(elem990) + p.pretty_rel_term(elem995) } } p.dedent() @@ -2730,26 +2730,26 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat997 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat997 != nil { - p.write(*flat997) + flat1002 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1002 != nil { + p.write(*flat1002) return nil } else { - _t1537 := func(_dollar_dollar *pb.Cast) []interface{} { + _t1547 := func(_dollar_dollar *pb.Cast) []interface{} { return []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} } - _t1538 := _t1537(msg) - fields993 := _t1538 - unwrapped_fields994 := fields993 + _t1548 := _t1547(msg) + fields998 := _t1548 + unwrapped_fields999 := fields998 p.write("(") p.write("cast") p.indentSexp() p.newline() - field995 := unwrapped_fields994[0].(*pb.Term) - p.pretty_term(field995) + field1000 := unwrapped_fields999[0].(*pb.Term) + p.pretty_term(field1000) p.newline() - field996 := unwrapped_fields994[1].(*pb.Term) - p.pretty_term(field996) + field1001 := unwrapped_fields999[1].(*pb.Term) + p.pretty_term(field1001) p.dedent() p.write(")") } @@ -2757,22 +2757,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1001 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1001 != nil { - p.write(*flat1001) + flat1006 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1006 != nil { + p.write(*flat1006) return nil } else { - fields998 := msg + fields1003 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields998) == 0) { + if !(len(fields1003) == 0) { p.newline() - for i1000, elem999 := range fields998 { - if (i1000 > 0) { + for i1005, elem1004 := range fields1003 { + if (i1005 > 0) { p.newline() } - p.pretty_attribute(elem999) + p.pretty_attribute(elem1004) } } p.dedent() @@ -2782,31 +2782,31 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1008 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1008 != nil { - p.write(*flat1008) + flat1013 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1013 != nil { + p.write(*flat1013) return nil } else { - _t1539 := func(_dollar_dollar *pb.Attribute) []interface{} { + _t1549 := func(_dollar_dollar *pb.Attribute) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} } - _t1540 := _t1539(msg) - fields1002 := _t1540 - unwrapped_fields1003 := fields1002 + _t1550 := _t1549(msg) + fields1007 := _t1550 + unwrapped_fields1008 := fields1007 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1004 := unwrapped_fields1003[0].(string) - p.pretty_name(field1004) - field1005 := unwrapped_fields1003[1].([]*pb.Value) - if !(len(field1005) == 0) { + field1009 := unwrapped_fields1008[0].(string) + p.pretty_name(field1009) + field1010 := unwrapped_fields1008[1].([]*pb.Value) + if !(len(field1010) == 0) { p.newline() - for i1007, elem1006 := range field1005 { - if (i1007 > 0) { + for i1012, elem1011 := range field1010 { + if (i1012 > 0) { p.newline() } - p.pretty_value(elem1006) + p.pretty_value(elem1011) } } p.dedent() @@ -2816,33 +2816,33 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1015 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1015 != nil { - p.write(*flat1015) + flat1020 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1020 != nil { + p.write(*flat1020) return nil } else { - _t1541 := func(_dollar_dollar *pb.Algorithm) []interface{} { + _t1551 := func(_dollar_dollar *pb.Algorithm) []interface{} { return []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()} } - _t1542 := _t1541(msg) - fields1009 := _t1542 - unwrapped_fields1010 := fields1009 + _t1552 := _t1551(msg) + fields1014 := _t1552 + unwrapped_fields1015 := fields1014 p.write("(") p.write("algorithm") p.indentSexp() - field1011 := unwrapped_fields1010[0].([]*pb.RelationId) - if !(len(field1011) == 0) { + field1016 := unwrapped_fields1015[0].([]*pb.RelationId) + if !(len(field1016) == 0) { p.newline() - for i1013, elem1012 := range field1011 { - if (i1013 > 0) { + for i1018, elem1017 := range field1016 { + if (i1018 > 0) { p.newline() } - p.pretty_relation_id(elem1012) + p.pretty_relation_id(elem1017) } } p.newline() - field1014 := unwrapped_fields1010[1].(*pb.Script) - p.pretty_script(field1014) + field1019 := unwrapped_fields1015[1].(*pb.Script) + p.pretty_script(field1019) p.dedent() p.write(")") } @@ -2850,27 +2850,27 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1020 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1020 != nil { - p.write(*flat1020) + flat1025 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1025 != nil { + p.write(*flat1025) return nil } else { - _t1543 := func(_dollar_dollar *pb.Script) []*pb.Construct { + _t1553 := func(_dollar_dollar *pb.Script) []*pb.Construct { return _dollar_dollar.GetConstructs() } - _t1544 := _t1543(msg) - fields1016 := _t1544 - unwrapped_fields1017 := fields1016 + _t1554 := _t1553(msg) + fields1021 := _t1554 + unwrapped_fields1022 := fields1021 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1017) == 0) { + if !(len(unwrapped_fields1022) == 0) { p.newline() - for i1019, elem1018 := range unwrapped_fields1017 { - if (i1019 > 0) { + for i1024, elem1023 := range unwrapped_fields1022 { + if (i1024 > 0) { p.newline() } - p.pretty_construct(elem1018) + p.pretty_construct(elem1023) } } p.dedent() @@ -2880,36 +2880,36 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1025 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1025 != nil { - p.write(*flat1025) + flat1030 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1030 != nil { + p.write(*flat1030) return nil } else { - _t1545 := func(_dollar_dollar *pb.Construct) *pb.Loop { - var _t1546 *pb.Loop + _t1555 := func(_dollar_dollar *pb.Construct) *pb.Loop { + var _t1556 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1546 = _dollar_dollar.GetLoop() + _t1556 = _dollar_dollar.GetLoop() } - return _t1546 + return _t1556 } - _t1547 := _t1545(msg) - deconstruct_result1023 := _t1547 - if deconstruct_result1023 != nil { - unwrapped1024 := deconstruct_result1023 - p.pretty_loop(unwrapped1024) + _t1557 := _t1555(msg) + deconstruct_result1028 := _t1557 + if deconstruct_result1028 != nil { + unwrapped1029 := deconstruct_result1028 + p.pretty_loop(unwrapped1029) } else { - _t1548 := func(_dollar_dollar *pb.Construct) *pb.Instruction { - var _t1549 *pb.Instruction + _t1558 := func(_dollar_dollar *pb.Construct) *pb.Instruction { + var _t1559 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1549 = _dollar_dollar.GetInstruction() + _t1559 = _dollar_dollar.GetInstruction() } - return _t1549 + return _t1559 } - _t1550 := _t1548(msg) - deconstruct_result1021 := _t1550 - if deconstruct_result1021 != nil { - unwrapped1022 := deconstruct_result1021 - p.pretty_instruction(unwrapped1022) + _t1560 := _t1558(msg) + deconstruct_result1026 := _t1560 + if deconstruct_result1026 != nil { + unwrapped1027 := deconstruct_result1026 + p.pretty_instruction(unwrapped1027) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -2919,26 +2919,26 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1030 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1030 != nil { - p.write(*flat1030) + flat1035 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1035 != nil { + p.write(*flat1035) return nil } else { - _t1551 := func(_dollar_dollar *pb.Loop) []interface{} { + _t1561 := func(_dollar_dollar *pb.Loop) []interface{} { return []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()} } - _t1552 := _t1551(msg) - fields1026 := _t1552 - unwrapped_fields1027 := fields1026 + _t1562 := _t1561(msg) + fields1031 := _t1562 + unwrapped_fields1032 := fields1031 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1028 := unwrapped_fields1027[0].([]*pb.Instruction) - p.pretty_init(field1028) + field1033 := unwrapped_fields1032[0].([]*pb.Instruction) + p.pretty_init(field1033) p.newline() - field1029 := unwrapped_fields1027[1].(*pb.Script) - p.pretty_script(field1029) + field1034 := unwrapped_fields1032[1].(*pb.Script) + p.pretty_script(field1034) p.dedent() p.write(")") } @@ -2946,22 +2946,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1034 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1034 != nil { - p.write(*flat1034) + flat1039 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1039 != nil { + p.write(*flat1039) return nil } else { - fields1031 := msg + fields1036 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1031) == 0) { + if !(len(fields1036) == 0) { p.newline() - for i1033, elem1032 := range fields1031 { - if (i1033 > 0) { + for i1038, elem1037 := range fields1036 { + if (i1038 > 0) { p.newline() } - p.pretty_instruction(elem1032) + p.pretty_instruction(elem1037) } } p.dedent() @@ -2971,75 +2971,75 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1045 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1045 != nil { - p.write(*flat1045) + flat1050 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1050 != nil { + p.write(*flat1050) return nil } else { - _t1553 := func(_dollar_dollar *pb.Instruction) *pb.Assign { - var _t1554 *pb.Assign + _t1563 := func(_dollar_dollar *pb.Instruction) *pb.Assign { + var _t1564 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1554 = _dollar_dollar.GetAssign() + _t1564 = _dollar_dollar.GetAssign() } - return _t1554 + return _t1564 } - _t1555 := _t1553(msg) - deconstruct_result1043 := _t1555 - if deconstruct_result1043 != nil { - unwrapped1044 := deconstruct_result1043 - p.pretty_assign(unwrapped1044) + _t1565 := _t1563(msg) + deconstruct_result1048 := _t1565 + if deconstruct_result1048 != nil { + unwrapped1049 := deconstruct_result1048 + p.pretty_assign(unwrapped1049) } else { - _t1556 := func(_dollar_dollar *pb.Instruction) *pb.Upsert { - var _t1557 *pb.Upsert + _t1566 := func(_dollar_dollar *pb.Instruction) *pb.Upsert { + var _t1567 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1557 = _dollar_dollar.GetUpsert() + _t1567 = _dollar_dollar.GetUpsert() } - return _t1557 + return _t1567 } - _t1558 := _t1556(msg) - deconstruct_result1041 := _t1558 - if deconstruct_result1041 != nil { - unwrapped1042 := deconstruct_result1041 - p.pretty_upsert(unwrapped1042) + _t1568 := _t1566(msg) + deconstruct_result1046 := _t1568 + if deconstruct_result1046 != nil { + unwrapped1047 := deconstruct_result1046 + p.pretty_upsert(unwrapped1047) } else { - _t1559 := func(_dollar_dollar *pb.Instruction) *pb.Break { - var _t1560 *pb.Break + _t1569 := func(_dollar_dollar *pb.Instruction) *pb.Break { + var _t1570 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1560 = _dollar_dollar.GetBreak() + _t1570 = _dollar_dollar.GetBreak() } - return _t1560 + return _t1570 } - _t1561 := _t1559(msg) - deconstruct_result1039 := _t1561 - if deconstruct_result1039 != nil { - unwrapped1040 := deconstruct_result1039 - p.pretty_break(unwrapped1040) + _t1571 := _t1569(msg) + deconstruct_result1044 := _t1571 + if deconstruct_result1044 != nil { + unwrapped1045 := deconstruct_result1044 + p.pretty_break(unwrapped1045) } else { - _t1562 := func(_dollar_dollar *pb.Instruction) *pb.MonoidDef { - var _t1563 *pb.MonoidDef + _t1572 := func(_dollar_dollar *pb.Instruction) *pb.MonoidDef { + var _t1573 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1563 = _dollar_dollar.GetMonoidDef() + _t1573 = _dollar_dollar.GetMonoidDef() } - return _t1563 + return _t1573 } - _t1564 := _t1562(msg) - deconstruct_result1037 := _t1564 - if deconstruct_result1037 != nil { - unwrapped1038 := deconstruct_result1037 - p.pretty_monoid_def(unwrapped1038) + _t1574 := _t1572(msg) + deconstruct_result1042 := _t1574 + if deconstruct_result1042 != nil { + unwrapped1043 := deconstruct_result1042 + p.pretty_monoid_def(unwrapped1043) } else { - _t1565 := func(_dollar_dollar *pb.Instruction) *pb.MonusDef { - var _t1566 *pb.MonusDef + _t1575 := func(_dollar_dollar *pb.Instruction) *pb.MonusDef { + var _t1576 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1566 = _dollar_dollar.GetMonusDef() + _t1576 = _dollar_dollar.GetMonusDef() } - return _t1566 + return _t1576 } - _t1567 := _t1565(msg) - deconstruct_result1035 := _t1567 - if deconstruct_result1035 != nil { - unwrapped1036 := deconstruct_result1035 - p.pretty_monus_def(unwrapped1036) + _t1577 := _t1575(msg) + deconstruct_result1040 := _t1577 + if deconstruct_result1040 != nil { + unwrapped1041 := deconstruct_result1040 + p.pretty_monus_def(unwrapped1041) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3052,35 +3052,35 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1052 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1052 != nil { - p.write(*flat1052) + flat1057 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1057 != nil { + p.write(*flat1057) return nil } else { - _t1568 := func(_dollar_dollar *pb.Assign) []interface{} { - var _t1569 []*pb.Attribute + _t1578 := func(_dollar_dollar *pb.Assign) []interface{} { + var _t1579 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1569 = _dollar_dollar.GetAttrs() + _t1579 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1569} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1579} } - _t1570 := _t1568(msg) - fields1046 := _t1570 - unwrapped_fields1047 := fields1046 + _t1580 := _t1578(msg) + fields1051 := _t1580 + unwrapped_fields1052 := fields1051 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1048 := unwrapped_fields1047[0].(*pb.RelationId) - p.pretty_relation_id(field1048) + field1053 := unwrapped_fields1052[0].(*pb.RelationId) + p.pretty_relation_id(field1053) p.newline() - field1049 := unwrapped_fields1047[1].(*pb.Abstraction) - p.pretty_abstraction(field1049) - field1050 := unwrapped_fields1047[2].([]*pb.Attribute) - if field1050 != nil { + field1054 := unwrapped_fields1052[1].(*pb.Abstraction) + p.pretty_abstraction(field1054) + field1055 := unwrapped_fields1052[2].([]*pb.Attribute) + if field1055 != nil { p.newline() - opt_val1051 := field1050 - p.pretty_attrs(opt_val1051) + opt_val1056 := field1055 + p.pretty_attrs(opt_val1056) } p.dedent() p.write(")") @@ -3089,35 +3089,35 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1059 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1059 != nil { - p.write(*flat1059) + flat1064 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1064 != nil { + p.write(*flat1064) return nil } else { - _t1571 := func(_dollar_dollar *pb.Upsert) []interface{} { - var _t1572 []*pb.Attribute + _t1581 := func(_dollar_dollar *pb.Upsert) []interface{} { + var _t1582 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1572 = _dollar_dollar.GetAttrs() + _t1582 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1572} + return []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1582} } - _t1573 := _t1571(msg) - fields1053 := _t1573 - unwrapped_fields1054 := fields1053 + _t1583 := _t1581(msg) + fields1058 := _t1583 + unwrapped_fields1059 := fields1058 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1055 := unwrapped_fields1054[0].(*pb.RelationId) - p.pretty_relation_id(field1055) + field1060 := unwrapped_fields1059[0].(*pb.RelationId) + p.pretty_relation_id(field1060) p.newline() - field1056 := unwrapped_fields1054[1].([]interface{}) - p.pretty_abstraction_with_arity(field1056) - field1057 := unwrapped_fields1054[2].([]*pb.Attribute) - if field1057 != nil { + field1061 := unwrapped_fields1059[1].([]interface{}) + p.pretty_abstraction_with_arity(field1061) + field1062 := unwrapped_fields1059[2].([]*pb.Attribute) + if field1062 != nil { p.newline() - opt_val1058 := field1057 - p.pretty_attrs(opt_val1058) + opt_val1063 := field1062 + p.pretty_attrs(opt_val1063) } p.dedent() p.write(")") @@ -3126,25 +3126,25 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1064 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1064 != nil { - p.write(*flat1064) + flat1069 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1069 != nil { + p.write(*flat1069) return nil } else { - _t1574 := func(_dollar_dollar []interface{}) []interface{} { - _t1575 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - return []interface{}{_t1575, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + _t1584 := func(_dollar_dollar []interface{}) []interface{} { + _t1585 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + return []interface{}{_t1585, _dollar_dollar[0].(*pb.Abstraction).GetValue()} } - _t1576 := _t1574(msg) - fields1060 := _t1576 - unwrapped_fields1061 := fields1060 + _t1586 := _t1584(msg) + fields1065 := _t1586 + unwrapped_fields1066 := fields1065 p.write("(") p.indent() - field1062 := unwrapped_fields1061[0].([]interface{}) - p.pretty_bindings(field1062) + field1067 := unwrapped_fields1066[0].([]interface{}) + p.pretty_bindings(field1067) p.newline() - field1063 := unwrapped_fields1061[1].(*pb.Formula) - p.pretty_formula(field1063) + field1068 := unwrapped_fields1066[1].(*pb.Formula) + p.pretty_formula(field1068) p.dedent() p.write(")") } @@ -3152,35 +3152,35 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1071 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1071 != nil { - p.write(*flat1071) + flat1076 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1076 != nil { + p.write(*flat1076) return nil } else { - _t1577 := func(_dollar_dollar *pb.Break) []interface{} { - var _t1578 []*pb.Attribute + _t1587 := func(_dollar_dollar *pb.Break) []interface{} { + var _t1588 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1578 = _dollar_dollar.GetAttrs() + _t1588 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1578} + return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1588} } - _t1579 := _t1577(msg) - fields1065 := _t1579 - unwrapped_fields1066 := fields1065 + _t1589 := _t1587(msg) + fields1070 := _t1589 + unwrapped_fields1071 := fields1070 p.write("(") p.write("break") p.indentSexp() p.newline() - field1067 := unwrapped_fields1066[0].(*pb.RelationId) - p.pretty_relation_id(field1067) + field1072 := unwrapped_fields1071[0].(*pb.RelationId) + p.pretty_relation_id(field1072) p.newline() - field1068 := unwrapped_fields1066[1].(*pb.Abstraction) - p.pretty_abstraction(field1068) - field1069 := unwrapped_fields1066[2].([]*pb.Attribute) - if field1069 != nil { + field1073 := unwrapped_fields1071[1].(*pb.Abstraction) + p.pretty_abstraction(field1073) + field1074 := unwrapped_fields1071[2].([]*pb.Attribute) + if field1074 != nil { p.newline() - opt_val1070 := field1069 - p.pretty_attrs(opt_val1070) + opt_val1075 := field1074 + p.pretty_attrs(opt_val1075) } p.dedent() p.write(")") @@ -3189,38 +3189,38 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1079 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1079 != nil { - p.write(*flat1079) + flat1084 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1084 != nil { + p.write(*flat1084) return nil } else { - _t1580 := func(_dollar_dollar *pb.MonoidDef) []interface{} { - var _t1581 []*pb.Attribute + _t1590 := func(_dollar_dollar *pb.MonoidDef) []interface{} { + var _t1591 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1581 = _dollar_dollar.GetAttrs() + _t1591 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1581} + return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1591} } - _t1582 := _t1580(msg) - fields1072 := _t1582 - unwrapped_fields1073 := fields1072 + _t1592 := _t1590(msg) + fields1077 := _t1592 + unwrapped_fields1078 := fields1077 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1074 := unwrapped_fields1073[0].(*pb.Monoid) - p.pretty_monoid(field1074) + field1079 := unwrapped_fields1078[0].(*pb.Monoid) + p.pretty_monoid(field1079) p.newline() - field1075 := unwrapped_fields1073[1].(*pb.RelationId) - p.pretty_relation_id(field1075) + field1080 := unwrapped_fields1078[1].(*pb.RelationId) + p.pretty_relation_id(field1080) p.newline() - field1076 := unwrapped_fields1073[2].([]interface{}) - p.pretty_abstraction_with_arity(field1076) - field1077 := unwrapped_fields1073[3].([]*pb.Attribute) - if field1077 != nil { + field1081 := unwrapped_fields1078[2].([]interface{}) + p.pretty_abstraction_with_arity(field1081) + field1082 := unwrapped_fields1078[3].([]*pb.Attribute) + if field1082 != nil { p.newline() - opt_val1078 := field1077 - p.pretty_attrs(opt_val1078) + opt_val1083 := field1082 + p.pretty_attrs(opt_val1083) } p.dedent() p.write(")") @@ -3229,62 +3229,62 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1088 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1088 != nil { - p.write(*flat1088) + flat1093 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1093 != nil { + p.write(*flat1093) return nil } else { - _t1583 := func(_dollar_dollar *pb.Monoid) *pb.OrMonoid { - var _t1584 *pb.OrMonoid + _t1593 := func(_dollar_dollar *pb.Monoid) *pb.OrMonoid { + var _t1594 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1584 = _dollar_dollar.GetOrMonoid() + _t1594 = _dollar_dollar.GetOrMonoid() } - return _t1584 + return _t1594 } - _t1585 := _t1583(msg) - deconstruct_result1086 := _t1585 - if deconstruct_result1086 != nil { - unwrapped1087 := deconstruct_result1086 - p.pretty_or_monoid(unwrapped1087) + _t1595 := _t1593(msg) + deconstruct_result1091 := _t1595 + if deconstruct_result1091 != nil { + unwrapped1092 := deconstruct_result1091 + p.pretty_or_monoid(unwrapped1092) } else { - _t1586 := func(_dollar_dollar *pb.Monoid) *pb.MinMonoid { - var _t1587 *pb.MinMonoid + _t1596 := func(_dollar_dollar *pb.Monoid) *pb.MinMonoid { + var _t1597 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1587 = _dollar_dollar.GetMinMonoid() + _t1597 = _dollar_dollar.GetMinMonoid() } - return _t1587 + return _t1597 } - _t1588 := _t1586(msg) - deconstruct_result1084 := _t1588 - if deconstruct_result1084 != nil { - unwrapped1085 := deconstruct_result1084 - p.pretty_min_monoid(unwrapped1085) + _t1598 := _t1596(msg) + deconstruct_result1089 := _t1598 + if deconstruct_result1089 != nil { + unwrapped1090 := deconstruct_result1089 + p.pretty_min_monoid(unwrapped1090) } else { - _t1589 := func(_dollar_dollar *pb.Monoid) *pb.MaxMonoid { - var _t1590 *pb.MaxMonoid + _t1599 := func(_dollar_dollar *pb.Monoid) *pb.MaxMonoid { + var _t1600 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1590 = _dollar_dollar.GetMaxMonoid() + _t1600 = _dollar_dollar.GetMaxMonoid() } - return _t1590 + return _t1600 } - _t1591 := _t1589(msg) - deconstruct_result1082 := _t1591 - if deconstruct_result1082 != nil { - unwrapped1083 := deconstruct_result1082 - p.pretty_max_monoid(unwrapped1083) + _t1601 := _t1599(msg) + deconstruct_result1087 := _t1601 + if deconstruct_result1087 != nil { + unwrapped1088 := deconstruct_result1087 + p.pretty_max_monoid(unwrapped1088) } else { - _t1592 := func(_dollar_dollar *pb.Monoid) *pb.SumMonoid { - var _t1593 *pb.SumMonoid + _t1602 := func(_dollar_dollar *pb.Monoid) *pb.SumMonoid { + var _t1603 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1593 = _dollar_dollar.GetSumMonoid() + _t1603 = _dollar_dollar.GetSumMonoid() } - return _t1593 + return _t1603 } - _t1594 := _t1592(msg) - deconstruct_result1080 := _t1594 - if deconstruct_result1080 != nil { - unwrapped1081 := deconstruct_result1080 - p.pretty_sum_monoid(unwrapped1081) + _t1604 := _t1602(msg) + deconstruct_result1085 := _t1604 + if deconstruct_result1085 != nil { + unwrapped1086 := deconstruct_result1085 + p.pretty_sum_monoid(unwrapped1086) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3296,8 +3296,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1089 := msg - _ = fields1089 + fields1094 := msg + _ = fields1094 p.write("(") p.write("or") p.write(")") @@ -3305,22 +3305,22 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1092 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1092 != nil { - p.write(*flat1092) + flat1097 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1097 != nil { + p.write(*flat1097) return nil } else { - _t1595 := func(_dollar_dollar *pb.MinMonoid) *pb.Type { + _t1605 := func(_dollar_dollar *pb.MinMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1596 := _t1595(msg) - fields1090 := _t1596 - unwrapped_fields1091 := fields1090 + _t1606 := _t1605(msg) + fields1095 := _t1606 + unwrapped_fields1096 := fields1095 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1091) + p.pretty_type(unwrapped_fields1096) p.dedent() p.write(")") } @@ -3328,22 +3328,22 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1095 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1095 != nil { - p.write(*flat1095) + flat1100 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1100 != nil { + p.write(*flat1100) return nil } else { - _t1597 := func(_dollar_dollar *pb.MaxMonoid) *pb.Type { + _t1607 := func(_dollar_dollar *pb.MaxMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1598 := _t1597(msg) - fields1093 := _t1598 - unwrapped_fields1094 := fields1093 + _t1608 := _t1607(msg) + fields1098 := _t1608 + unwrapped_fields1099 := fields1098 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1094) + p.pretty_type(unwrapped_fields1099) p.dedent() p.write(")") } @@ -3351,22 +3351,22 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1098 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1098 != nil { - p.write(*flat1098) + flat1103 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1103 != nil { + p.write(*flat1103) return nil } else { - _t1599 := func(_dollar_dollar *pb.SumMonoid) *pb.Type { + _t1609 := func(_dollar_dollar *pb.SumMonoid) *pb.Type { return _dollar_dollar.GetType() } - _t1600 := _t1599(msg) - fields1096 := _t1600 - unwrapped_fields1097 := fields1096 + _t1610 := _t1609(msg) + fields1101 := _t1610 + unwrapped_fields1102 := fields1101 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1097) + p.pretty_type(unwrapped_fields1102) p.dedent() p.write(")") } @@ -3374,38 +3374,38 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1106 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1106 != nil { - p.write(*flat1106) + flat1111 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1111 != nil { + p.write(*flat1111) return nil } else { - _t1601 := func(_dollar_dollar *pb.MonusDef) []interface{} { - var _t1602 []*pb.Attribute + _t1611 := func(_dollar_dollar *pb.MonusDef) []interface{} { + var _t1612 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1602 = _dollar_dollar.GetAttrs() + _t1612 = _dollar_dollar.GetAttrs() } - return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1602} + return []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1612} } - _t1603 := _t1601(msg) - fields1099 := _t1603 - unwrapped_fields1100 := fields1099 + _t1613 := _t1611(msg) + fields1104 := _t1613 + unwrapped_fields1105 := fields1104 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1101 := unwrapped_fields1100[0].(*pb.Monoid) - p.pretty_monoid(field1101) + field1106 := unwrapped_fields1105[0].(*pb.Monoid) + p.pretty_monoid(field1106) p.newline() - field1102 := unwrapped_fields1100[1].(*pb.RelationId) - p.pretty_relation_id(field1102) + field1107 := unwrapped_fields1105[1].(*pb.RelationId) + p.pretty_relation_id(field1107) p.newline() - field1103 := unwrapped_fields1100[2].([]interface{}) - p.pretty_abstraction_with_arity(field1103) - field1104 := unwrapped_fields1100[3].([]*pb.Attribute) - if field1104 != nil { + field1108 := unwrapped_fields1105[2].([]interface{}) + p.pretty_abstraction_with_arity(field1108) + field1109 := unwrapped_fields1105[3].([]*pb.Attribute) + if field1109 != nil { p.newline() - opt_val1105 := field1104 - p.pretty_attrs(opt_val1105) + opt_val1110 := field1109 + p.pretty_attrs(opt_val1110) } p.dedent() p.write(")") @@ -3414,32 +3414,32 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1113 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1113 != nil { - p.write(*flat1113) + flat1118 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1118 != nil { + p.write(*flat1118) return nil } else { - _t1604 := func(_dollar_dollar *pb.Constraint) []interface{} { + _t1614 := func(_dollar_dollar *pb.Constraint) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} } - _t1605 := _t1604(msg) - fields1107 := _t1605 - unwrapped_fields1108 := fields1107 + _t1615 := _t1614(msg) + fields1112 := _t1615 + unwrapped_fields1113 := fields1112 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1109 := unwrapped_fields1108[0].(*pb.RelationId) - p.pretty_relation_id(field1109) + field1114 := unwrapped_fields1113[0].(*pb.RelationId) + p.pretty_relation_id(field1114) p.newline() - field1110 := unwrapped_fields1108[1].(*pb.Abstraction) - p.pretty_abstraction(field1110) + field1115 := unwrapped_fields1113[1].(*pb.Abstraction) + p.pretty_abstraction(field1115) p.newline() - field1111 := unwrapped_fields1108[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1111) + field1116 := unwrapped_fields1113[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1116) p.newline() - field1112 := unwrapped_fields1108[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1112) + field1117 := unwrapped_fields1113[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1117) p.dedent() p.write(")") } @@ -3447,22 +3447,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1117 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1117 != nil { - p.write(*flat1117) + flat1122 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1122 != nil { + p.write(*flat1122) return nil } else { - fields1114 := msg + fields1119 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1114) == 0) { + if !(len(fields1119) == 0) { p.newline() - for i1116, elem1115 := range fields1114 { - if (i1116 > 0) { + for i1121, elem1120 := range fields1119 { + if (i1121 > 0) { p.newline() } - p.pretty_var(elem1115) + p.pretty_var(elem1120) } } p.dedent() @@ -3472,22 +3472,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1121 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1121 != nil { - p.write(*flat1121) + flat1126 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1126 != nil { + p.write(*flat1126) return nil } else { - fields1118 := msg + fields1123 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1118) == 0) { + if !(len(fields1123) == 0) { p.newline() - for i1120, elem1119 := range fields1118 { - if (i1120 > 0) { + for i1125, elem1124 := range fields1123 { + if (i1125 > 0) { p.newline() } - p.pretty_var(elem1119) + p.pretty_var(elem1124) } } p.dedent() @@ -3497,49 +3497,49 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1128 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1128 != nil { - p.write(*flat1128) + flat1133 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1133 != nil { + p.write(*flat1133) return nil } else { - _t1606 := func(_dollar_dollar *pb.Data) *pb.EDB { - var _t1607 *pb.EDB + _t1616 := func(_dollar_dollar *pb.Data) *pb.EDB { + var _t1617 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1607 = _dollar_dollar.GetEdb() + _t1617 = _dollar_dollar.GetEdb() } - return _t1607 + return _t1617 } - _t1608 := _t1606(msg) - deconstruct_result1126 := _t1608 - if deconstruct_result1126 != nil { - unwrapped1127 := deconstruct_result1126 - p.pretty_edb(unwrapped1127) + _t1618 := _t1616(msg) + deconstruct_result1131 := _t1618 + if deconstruct_result1131 != nil { + unwrapped1132 := deconstruct_result1131 + p.pretty_edb(unwrapped1132) } else { - _t1609 := func(_dollar_dollar *pb.Data) *pb.BeTreeRelation { - var _t1610 *pb.BeTreeRelation + _t1619 := func(_dollar_dollar *pb.Data) *pb.BeTreeRelation { + var _t1620 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1610 = _dollar_dollar.GetBetreeRelation() + _t1620 = _dollar_dollar.GetBetreeRelation() } - return _t1610 + return _t1620 } - _t1611 := _t1609(msg) - deconstruct_result1124 := _t1611 - if deconstruct_result1124 != nil { - unwrapped1125 := deconstruct_result1124 - p.pretty_betree_relation(unwrapped1125) + _t1621 := _t1619(msg) + deconstruct_result1129 := _t1621 + if deconstruct_result1129 != nil { + unwrapped1130 := deconstruct_result1129 + p.pretty_betree_relation(unwrapped1130) } else { - _t1612 := func(_dollar_dollar *pb.Data) *pb.CSVData { - var _t1613 *pb.CSVData + _t1622 := func(_dollar_dollar *pb.Data) *pb.CSVData { + var _t1623 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1613 = _dollar_dollar.GetCsvData() + _t1623 = _dollar_dollar.GetCsvData() } - return _t1613 + return _t1623 } - _t1614 := _t1612(msg) - deconstruct_result1122 := _t1614 - if deconstruct_result1122 != nil { - unwrapped1123 := deconstruct_result1122 - p.pretty_csv_data(unwrapped1123) + _t1624 := _t1622(msg) + deconstruct_result1127 := _t1624 + if deconstruct_result1127 != nil { + unwrapped1128 := deconstruct_result1127 + p.pretty_csv_data(unwrapped1128) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3550,29 +3550,29 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1134 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1134 != nil { - p.write(*flat1134) + flat1139 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1139 != nil { + p.write(*flat1139) return nil } else { - _t1615 := func(_dollar_dollar *pb.EDB) []interface{} { + _t1625 := func(_dollar_dollar *pb.EDB) []interface{} { return []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} } - _t1616 := _t1615(msg) - fields1129 := _t1616 - unwrapped_fields1130 := fields1129 + _t1626 := _t1625(msg) + fields1134 := _t1626 + unwrapped_fields1135 := fields1134 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1131 := unwrapped_fields1130[0].(*pb.RelationId) - p.pretty_relation_id(field1131) + field1136 := unwrapped_fields1135[0].(*pb.RelationId) + p.pretty_relation_id(field1136) p.newline() - field1132 := unwrapped_fields1130[1].([]string) - p.pretty_edb_path(field1132) + field1137 := unwrapped_fields1135[1].([]string) + p.pretty_edb_path(field1137) p.newline() - field1133 := unwrapped_fields1130[2].([]*pb.Type) - p.pretty_edb_types(field1133) + field1138 := unwrapped_fields1135[2].([]*pb.Type) + p.pretty_edb_types(field1138) p.dedent() p.write(")") } @@ -3580,19 +3580,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1138 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1138 != nil { - p.write(*flat1138) + flat1143 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1143 != nil { + p.write(*flat1143) return nil } else { - fields1135 := msg + fields1140 := msg p.write("[") p.indent() - for i1137, elem1136 := range fields1135 { - if (i1137 > 0) { + for i1142, elem1141 := range fields1140 { + if (i1142 > 0) { p.newline() } - p.write(p.formatStringValue(elem1136)) + p.write(p.formatStringValue(elem1141)) } p.dedent() p.write("]") @@ -3601,19 +3601,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1142 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1142 != nil { - p.write(*flat1142) + flat1147 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1147 != nil { + p.write(*flat1147) return nil } else { - fields1139 := msg + fields1144 := msg p.write("[") p.indent() - for i1141, elem1140 := range fields1139 { - if (i1141 > 0) { + for i1146, elem1145 := range fields1144 { + if (i1146 > 0) { p.newline() } - p.pretty_type(elem1140) + p.pretty_type(elem1145) } p.dedent() p.write("]") @@ -3622,26 +3622,26 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1147 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1147 != nil { - p.write(*flat1147) + flat1152 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1152 != nil { + p.write(*flat1152) return nil } else { - _t1617 := func(_dollar_dollar *pb.BeTreeRelation) []interface{} { + _t1627 := func(_dollar_dollar *pb.BeTreeRelation) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} } - _t1618 := _t1617(msg) - fields1143 := _t1618 - unwrapped_fields1144 := fields1143 + _t1628 := _t1627(msg) + fields1148 := _t1628 + unwrapped_fields1149 := fields1148 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1145 := unwrapped_fields1144[0].(*pb.RelationId) - p.pretty_relation_id(field1145) + field1150 := unwrapped_fields1149[0].(*pb.RelationId) + p.pretty_relation_id(field1150) p.newline() - field1146 := unwrapped_fields1144[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1146) + field1151 := unwrapped_fields1149[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1151) p.dedent() p.write(")") } @@ -3649,30 +3649,30 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1153 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1153 != nil { - p.write(*flat1153) + flat1158 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1158 != nil { + p.write(*flat1158) return nil } else { - _t1619 := func(_dollar_dollar *pb.BeTreeInfo) []interface{} { - _t1620 := p.deconstruct_betree_info_config(_dollar_dollar) - return []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1620} + _t1629 := func(_dollar_dollar *pb.BeTreeInfo) []interface{} { + _t1630 := p.deconstruct_betree_info_config(_dollar_dollar) + return []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1630} } - _t1621 := _t1619(msg) - fields1148 := _t1621 - unwrapped_fields1149 := fields1148 + _t1631 := _t1629(msg) + fields1153 := _t1631 + unwrapped_fields1154 := fields1153 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1150 := unwrapped_fields1149[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1150) + field1155 := unwrapped_fields1154[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1155) p.newline() - field1151 := unwrapped_fields1149[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1151) + field1156 := unwrapped_fields1154[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1156) p.newline() - field1152 := unwrapped_fields1149[2].([][]interface{}) - p.pretty_config_dict(field1152) + field1157 := unwrapped_fields1154[2].([][]interface{}) + p.pretty_config_dict(field1157) p.dedent() p.write(")") } @@ -3680,22 +3680,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1157 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1157 != nil { - p.write(*flat1157) + flat1162 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1162 != nil { + p.write(*flat1162) return nil } else { - fields1154 := msg + fields1159 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1154) == 0) { + if !(len(fields1159) == 0) { p.newline() - for i1156, elem1155 := range fields1154 { - if (i1156 > 0) { + for i1161, elem1160 := range fields1159 { + if (i1161 > 0) { p.newline() } - p.pretty_type(elem1155) + p.pretty_type(elem1160) } } p.dedent() @@ -3705,22 +3705,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{} { - flat1161 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1161 != nil { - p.write(*flat1161) + flat1166 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1166 != nil { + p.write(*flat1166) return nil } else { - fields1158 := msg + fields1163 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1158) == 0) { + if !(len(fields1163) == 0) { p.newline() - for i1160, elem1159 := range fields1158 { - if (i1160 > 0) { + for i1165, elem1164 := range fields1163 { + if (i1165 > 0) { p.newline() } - p.pretty_type(elem1159) + p.pretty_type(elem1164) } } p.dedent() @@ -3730,32 +3730,32 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1168 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1168 != nil { - p.write(*flat1168) + flat1173 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1173 != nil { + p.write(*flat1173) return nil } else { - _t1622 := func(_dollar_dollar *pb.CSVData) []interface{} { + _t1632 := func(_dollar_dollar *pb.CSVData) []interface{} { return []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} } - _t1623 := _t1622(msg) - fields1162 := _t1623 - unwrapped_fields1163 := fields1162 + _t1633 := _t1632(msg) + fields1167 := _t1633 + unwrapped_fields1168 := fields1167 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1164 := unwrapped_fields1163[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1164) + field1169 := unwrapped_fields1168[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1169) p.newline() - field1165 := unwrapped_fields1163[1].(*pb.CSVConfig) - p.pretty_csv_config(field1165) + field1170 := unwrapped_fields1168[1].(*pb.CSVConfig) + p.pretty_csv_config(field1170) p.newline() - field1166 := unwrapped_fields1163[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1166) + field1171 := unwrapped_fields1168[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1171) p.newline() - field1167 := unwrapped_fields1163[3].(string) - p.pretty_csv_asof(field1167) + field1172 := unwrapped_fields1168[3].(string) + p.pretty_csv_asof(field1172) p.dedent() p.write(")") } @@ -3763,39 +3763,39 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1175 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1175 != nil { - p.write(*flat1175) + flat1180 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1180 != nil { + p.write(*flat1180) return nil } else { - _t1624 := func(_dollar_dollar *pb.CSVLocator) []interface{} { - var _t1625 []string + _t1634 := func(_dollar_dollar *pb.CSVLocator) []interface{} { + var _t1635 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1625 = _dollar_dollar.GetPaths() + _t1635 = _dollar_dollar.GetPaths() } - var _t1626 *string + var _t1636 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1626 = ptr(string(_dollar_dollar.GetInlineData())) + _t1636 = ptr(string(_dollar_dollar.GetInlineData())) } - return []interface{}{_t1625, _t1626} + return []interface{}{_t1635, _t1636} } - _t1627 := _t1624(msg) - fields1169 := _t1627 - unwrapped_fields1170 := fields1169 + _t1637 := _t1634(msg) + fields1174 := _t1637 + unwrapped_fields1175 := fields1174 p.write("(") p.write("csv_locator") p.indentSexp() - field1171 := unwrapped_fields1170[0].([]string) - if field1171 != nil { + field1176 := unwrapped_fields1175[0].([]string) + if field1176 != nil { p.newline() - opt_val1172 := field1171 - p.pretty_csv_locator_paths(opt_val1172) + opt_val1177 := field1176 + p.pretty_csv_locator_paths(opt_val1177) } - field1173 := unwrapped_fields1170[1].(*string) - if field1173 != nil { + field1178 := unwrapped_fields1175[1].(*string) + if field1178 != nil { p.newline() - opt_val1174 := *field1173 - p.pretty_csv_locator_inline_data(opt_val1174) + opt_val1179 := *field1178 + p.pretty_csv_locator_inline_data(opt_val1179) } p.dedent() p.write(")") @@ -3804,22 +3804,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1179 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1179 != nil { - p.write(*flat1179) + flat1184 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1184 != nil { + p.write(*flat1184) return nil } else { - fields1176 := msg + fields1181 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1176) == 0) { + if !(len(fields1181) == 0) { p.newline() - for i1178, elem1177 := range fields1176 { - if (i1178 > 0) { + for i1183, elem1182 := range fields1181 { + if (i1183 > 0) { p.newline() } - p.write(p.formatStringValue(elem1177)) + p.write(p.formatStringValue(elem1182)) } } p.dedent() @@ -3829,17 +3829,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1181 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1181 != nil { - p.write(*flat1181) + flat1186 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1186 != nil { + p.write(*flat1186) return nil } else { - fields1180 := msg + fields1185 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1180)) + p.write(p.formatStringValue(fields1185)) p.dedent() p.write(")") } @@ -3847,23 +3847,23 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1184 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1184 != nil { - p.write(*flat1184) + flat1189 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1189 != nil { + p.write(*flat1189) return nil } else { - _t1628 := func(_dollar_dollar *pb.CSVConfig) [][]interface{} { - _t1629 := p.deconstruct_csv_config(_dollar_dollar) - return _t1629 + _t1638 := func(_dollar_dollar *pb.CSVConfig) [][]interface{} { + _t1639 := p.deconstruct_csv_config(_dollar_dollar) + return _t1639 } - _t1630 := _t1628(msg) - fields1182 := _t1630 - unwrapped_fields1183 := fields1182 + _t1640 := _t1638(msg) + fields1187 := _t1640 + unwrapped_fields1188 := fields1187 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields1183) + p.pretty_config_dict(unwrapped_fields1188) p.dedent() p.write(")") } @@ -3871,22 +3871,22 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1188 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1188 != nil { - p.write(*flat1188) + flat1193 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1193 != nil { + p.write(*flat1193) return nil } else { - fields1185 := msg + fields1190 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1185) == 0) { + if !(len(fields1190) == 0) { p.newline() - for i1187, elem1186 := range fields1185 { - if (i1187 > 0) { + for i1192, elem1191 := range fields1190 { + if (i1192 > 0) { p.newline() } - p.pretty_gnf_column(elem1186) + p.pretty_gnf_column(elem1191) } } p.dedent() @@ -3896,41 +3896,41 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1197 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1197 != nil { - p.write(*flat1197) + flat1202 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1202 != nil { + p.write(*flat1202) return nil } else { - _t1631 := func(_dollar_dollar *pb.GNFColumn) []interface{} { - var _t1632 *pb.RelationId + _t1641 := func(_dollar_dollar *pb.GNFColumn) []interface{} { + var _t1642 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1632 = _dollar_dollar.GetTargetId() + _t1642 = _dollar_dollar.GetTargetId() } - return []interface{}{_dollar_dollar.GetColumnPath(), _t1632, _dollar_dollar.GetTypes()} + return []interface{}{_dollar_dollar.GetColumnPath(), _t1642, _dollar_dollar.GetTypes()} } - _t1633 := _t1631(msg) - fields1189 := _t1633 - unwrapped_fields1190 := fields1189 + _t1643 := _t1641(msg) + fields1194 := _t1643 + unwrapped_fields1195 := fields1194 p.write("(") p.write("column") p.indentSexp() p.newline() - field1191 := unwrapped_fields1190[0].([]string) - p.pretty_gnf_column_path(field1191) - field1192 := unwrapped_fields1190[1].(*pb.RelationId) - if field1192 != nil { + field1196 := unwrapped_fields1195[0].([]string) + p.pretty_gnf_column_path(field1196) + field1197 := unwrapped_fields1195[1].(*pb.RelationId) + if field1197 != nil { p.newline() - opt_val1193 := field1192 - p.pretty_relation_id(opt_val1193) + opt_val1198 := field1197 + p.pretty_relation_id(opt_val1198) } p.newline() p.write("[") - field1194 := unwrapped_fields1190[2].([]*pb.Type) - for i1196, elem1195 := range field1194 { - if (i1196 > 0) { + field1199 := unwrapped_fields1195[2].([]*pb.Type) + for i1201, elem1200 := range field1199 { + if (i1201 > 0) { p.newline() } - p.pretty_type(elem1195) + p.pretty_type(elem1200) } p.write("]") p.dedent() @@ -3940,42 +3940,42 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1204 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1204 != nil { - p.write(*flat1204) + flat1209 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1209 != nil { + p.write(*flat1209) return nil } else { - _t1634 := func(_dollar_dollar []string) *string { - var _t1635 *string + _t1644 := func(_dollar_dollar []string) *string { + var _t1645 *string if int64(len(_dollar_dollar)) == 1 { - _t1635 = ptr(_dollar_dollar[0]) + _t1645 = ptr(_dollar_dollar[0]) } - return _t1635 + return _t1645 } - _t1636 := _t1634(msg) - deconstruct_result1202 := _t1636 - if deconstruct_result1202 != nil { - unwrapped1203 := *deconstruct_result1202 - p.write(p.formatStringValue(unwrapped1203)) + _t1646 := _t1644(msg) + deconstruct_result1207 := _t1646 + if deconstruct_result1207 != nil { + unwrapped1208 := *deconstruct_result1207 + p.write(p.formatStringValue(unwrapped1208)) } else { - _t1637 := func(_dollar_dollar []string) []string { - var _t1638 []string + _t1647 := func(_dollar_dollar []string) []string { + var _t1648 []string if int64(len(_dollar_dollar)) != 1 { - _t1638 = _dollar_dollar + _t1648 = _dollar_dollar } - return _t1638 + return _t1648 } - _t1639 := _t1637(msg) - deconstruct_result1198 := _t1639 - if deconstruct_result1198 != nil { - unwrapped1199 := deconstruct_result1198 + _t1649 := _t1647(msg) + deconstruct_result1203 := _t1649 + if deconstruct_result1203 != nil { + unwrapped1204 := deconstruct_result1203 p.write("[") p.indent() - for i1201, elem1200 := range unwrapped1199 { - if (i1201 > 0) { + for i1206, elem1205 := range unwrapped1204 { + if (i1206 > 0) { p.newline() } - p.write(p.formatStringValue(elem1200)) + p.write(p.formatStringValue(elem1205)) } p.dedent() p.write("]") @@ -3988,17 +3988,17 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1206 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1206 != nil { - p.write(*flat1206) + flat1211 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1211 != nil { + p.write(*flat1211) return nil } else { - fields1205 := msg + fields1210 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1205)) + p.write(p.formatStringValue(fields1210)) p.dedent() p.write(")") } @@ -4006,22 +4006,22 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1209 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1209 != nil { - p.write(*flat1209) + flat1214 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1214 != nil { + p.write(*flat1214) return nil } else { - _t1640 := func(_dollar_dollar *pb.Undefine) *pb.FragmentId { + _t1650 := func(_dollar_dollar *pb.Undefine) *pb.FragmentId { return _dollar_dollar.GetFragmentId() } - _t1641 := _t1640(msg) - fields1207 := _t1641 - unwrapped_fields1208 := fields1207 + _t1651 := _t1650(msg) + fields1212 := _t1651 + unwrapped_fields1213 := fields1212 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1208) + p.pretty_fragment_id(unwrapped_fields1213) p.dedent() p.write(")") } @@ -4029,27 +4029,27 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1214 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1214 != nil { - p.write(*flat1214) + flat1219 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1219 != nil { + p.write(*flat1219) return nil } else { - _t1642 := func(_dollar_dollar *pb.Context) []*pb.RelationId { + _t1652 := func(_dollar_dollar *pb.Context) []*pb.RelationId { return _dollar_dollar.GetRelations() } - _t1643 := _t1642(msg) - fields1210 := _t1643 - unwrapped_fields1211 := fields1210 + _t1653 := _t1652(msg) + fields1215 := _t1653 + unwrapped_fields1216 := fields1215 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1211) == 0) { + if !(len(unwrapped_fields1216) == 0) { p.newline() - for i1213, elem1212 := range unwrapped_fields1211 { - if (i1213 > 0) { + for i1218, elem1217 := range unwrapped_fields1216 { + if (i1218 > 0) { p.newline() } - p.pretty_relation_id(elem1212) + p.pretty_relation_id(elem1217) } } p.dedent() @@ -4059,49 +4059,73 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1219 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1219 != nil { - p.write(*flat1219) + flat1224 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1224 != nil { + p.write(*flat1224) return nil } else { - _t1644 := func(_dollar_dollar *pb.Snapshot) []interface{} { - return []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + _t1654 := func(_dollar_dollar *pb.Snapshot) []*pb.SnapshotMapping { + return _dollar_dollar.GetMappings() } - _t1645 := _t1644(msg) - fields1215 := _t1645 - unwrapped_fields1216 := fields1215 + _t1655 := _t1654(msg) + fields1220 := _t1655 + unwrapped_fields1221 := fields1220 p.write("(") p.write("snapshot") p.indentSexp() - p.newline() - field1217 := unwrapped_fields1216[0].([]string) - p.pretty_edb_path(field1217) - p.newline() - field1218 := unwrapped_fields1216[1].(*pb.RelationId) - p.pretty_relation_id(field1218) + if !(len(unwrapped_fields1221) == 0) { + p.newline() + for i1223, elem1222 := range unwrapped_fields1221 { + if (i1223 > 0) { + p.newline() + } + p.pretty_snapshot_mapping(elem1222) + } + } p.dedent() p.write(")") } return nil } +func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { + flat1229 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1229 != nil { + p.write(*flat1229) + return nil + } else { + _t1656 := func(_dollar_dollar *pb.SnapshotMapping) []interface{} { + return []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + } + _t1657 := _t1656(msg) + fields1225 := _t1657 + unwrapped_fields1226 := fields1225 + field1227 := unwrapped_fields1226[0].([]string) + p.pretty_edb_path(field1227) + p.write(" ") + field1228 := unwrapped_fields1226[1].(*pb.RelationId) + p.pretty_relation_id(field1228) + } + return nil +} + func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1223 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1223 != nil { - p.write(*flat1223) + flat1233 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1233 != nil { + p.write(*flat1233) return nil } else { - fields1220 := msg + fields1230 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1220) == 0) { + if !(len(fields1230) == 0) { p.newline() - for i1222, elem1221 := range fields1220 { - if (i1222 > 0) { + for i1232, elem1231 := range fields1230 { + if (i1232 > 0) { p.newline() } - p.pretty_read(elem1221) + p.pretty_read(elem1231) } } p.dedent() @@ -4111,75 +4135,75 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1234 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1234 != nil { - p.write(*flat1234) + flat1244 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1244 != nil { + p.write(*flat1244) return nil } else { - _t1646 := func(_dollar_dollar *pb.Read) *pb.Demand { - var _t1647 *pb.Demand + _t1658 := func(_dollar_dollar *pb.Read) *pb.Demand { + var _t1659 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1647 = _dollar_dollar.GetDemand() + _t1659 = _dollar_dollar.GetDemand() } - return _t1647 + return _t1659 } - _t1648 := _t1646(msg) - deconstruct_result1232 := _t1648 - if deconstruct_result1232 != nil { - unwrapped1233 := deconstruct_result1232 - p.pretty_demand(unwrapped1233) + _t1660 := _t1658(msg) + deconstruct_result1242 := _t1660 + if deconstruct_result1242 != nil { + unwrapped1243 := deconstruct_result1242 + p.pretty_demand(unwrapped1243) } else { - _t1649 := func(_dollar_dollar *pb.Read) *pb.Output { - var _t1650 *pb.Output + _t1661 := func(_dollar_dollar *pb.Read) *pb.Output { + var _t1662 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1650 = _dollar_dollar.GetOutput() + _t1662 = _dollar_dollar.GetOutput() } - return _t1650 + return _t1662 } - _t1651 := _t1649(msg) - deconstruct_result1230 := _t1651 - if deconstruct_result1230 != nil { - unwrapped1231 := deconstruct_result1230 - p.pretty_output(unwrapped1231) + _t1663 := _t1661(msg) + deconstruct_result1240 := _t1663 + if deconstruct_result1240 != nil { + unwrapped1241 := deconstruct_result1240 + p.pretty_output(unwrapped1241) } else { - _t1652 := func(_dollar_dollar *pb.Read) *pb.WhatIf { - var _t1653 *pb.WhatIf + _t1664 := func(_dollar_dollar *pb.Read) *pb.WhatIf { + var _t1665 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1653 = _dollar_dollar.GetWhatIf() + _t1665 = _dollar_dollar.GetWhatIf() } - return _t1653 + return _t1665 } - _t1654 := _t1652(msg) - deconstruct_result1228 := _t1654 - if deconstruct_result1228 != nil { - unwrapped1229 := deconstruct_result1228 - p.pretty_what_if(unwrapped1229) + _t1666 := _t1664(msg) + deconstruct_result1238 := _t1666 + if deconstruct_result1238 != nil { + unwrapped1239 := deconstruct_result1238 + p.pretty_what_if(unwrapped1239) } else { - _t1655 := func(_dollar_dollar *pb.Read) *pb.Abort { - var _t1656 *pb.Abort + _t1667 := func(_dollar_dollar *pb.Read) *pb.Abort { + var _t1668 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1656 = _dollar_dollar.GetAbort() + _t1668 = _dollar_dollar.GetAbort() } - return _t1656 + return _t1668 } - _t1657 := _t1655(msg) - deconstruct_result1226 := _t1657 - if deconstruct_result1226 != nil { - unwrapped1227 := deconstruct_result1226 - p.pretty_abort(unwrapped1227) + _t1669 := _t1667(msg) + deconstruct_result1236 := _t1669 + if deconstruct_result1236 != nil { + unwrapped1237 := deconstruct_result1236 + p.pretty_abort(unwrapped1237) } else { - _t1658 := func(_dollar_dollar *pb.Read) *pb.Export { - var _t1659 *pb.Export + _t1670 := func(_dollar_dollar *pb.Read) *pb.Export { + var _t1671 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1659 = _dollar_dollar.GetExport() + _t1671 = _dollar_dollar.GetExport() } - return _t1659 + return _t1671 } - _t1660 := _t1658(msg) - deconstruct_result1224 := _t1660 - if deconstruct_result1224 != nil { - unwrapped1225 := deconstruct_result1224 - p.pretty_export(unwrapped1225) + _t1672 := _t1670(msg) + deconstruct_result1234 := _t1672 + if deconstruct_result1234 != nil { + unwrapped1235 := deconstruct_result1234 + p.pretty_export(unwrapped1235) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4192,22 +4216,22 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1237 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1237 != nil { - p.write(*flat1237) + flat1247 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1247 != nil { + p.write(*flat1247) return nil } else { - _t1661 := func(_dollar_dollar *pb.Demand) *pb.RelationId { + _t1673 := func(_dollar_dollar *pb.Demand) *pb.RelationId { return _dollar_dollar.GetRelationId() } - _t1662 := _t1661(msg) - fields1235 := _t1662 - unwrapped_fields1236 := fields1235 + _t1674 := _t1673(msg) + fields1245 := _t1674 + unwrapped_fields1246 := fields1245 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1236) + p.pretty_relation_id(unwrapped_fields1246) p.dedent() p.write(")") } @@ -4215,26 +4239,26 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1242 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1242 != nil { - p.write(*flat1242) + flat1252 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1252 != nil { + p.write(*flat1252) return nil } else { - _t1663 := func(_dollar_dollar *pb.Output) []interface{} { + _t1675 := func(_dollar_dollar *pb.Output) []interface{} { return []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} } - _t1664 := _t1663(msg) - fields1238 := _t1664 - unwrapped_fields1239 := fields1238 + _t1676 := _t1675(msg) + fields1248 := _t1676 + unwrapped_fields1249 := fields1248 p.write("(") p.write("output") p.indentSexp() p.newline() - field1240 := unwrapped_fields1239[0].(string) - p.pretty_name(field1240) + field1250 := unwrapped_fields1249[0].(string) + p.pretty_name(field1250) p.newline() - field1241 := unwrapped_fields1239[1].(*pb.RelationId) - p.pretty_relation_id(field1241) + field1251 := unwrapped_fields1249[1].(*pb.RelationId) + p.pretty_relation_id(field1251) p.dedent() p.write(")") } @@ -4242,26 +4266,26 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1247 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1247 != nil { - p.write(*flat1247) + flat1257 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1257 != nil { + p.write(*flat1257) return nil } else { - _t1665 := func(_dollar_dollar *pb.WhatIf) []interface{} { + _t1677 := func(_dollar_dollar *pb.WhatIf) []interface{} { return []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} } - _t1666 := _t1665(msg) - fields1243 := _t1666 - unwrapped_fields1244 := fields1243 + _t1678 := _t1677(msg) + fields1253 := _t1678 + unwrapped_fields1254 := fields1253 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1245 := unwrapped_fields1244[0].(string) - p.pretty_name(field1245) + field1255 := unwrapped_fields1254[0].(string) + p.pretty_name(field1255) p.newline() - field1246 := unwrapped_fields1244[1].(*pb.Epoch) - p.pretty_epoch(field1246) + field1256 := unwrapped_fields1254[1].(*pb.Epoch) + p.pretty_epoch(field1256) p.dedent() p.write(")") } @@ -4269,33 +4293,33 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1253 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1253 != nil { - p.write(*flat1253) + flat1263 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1263 != nil { + p.write(*flat1263) return nil } else { - _t1667 := func(_dollar_dollar *pb.Abort) []interface{} { - var _t1668 *string + _t1679 := func(_dollar_dollar *pb.Abort) []interface{} { + var _t1680 *string if _dollar_dollar.GetName() != "abort" { - _t1668 = ptr(_dollar_dollar.GetName()) + _t1680 = ptr(_dollar_dollar.GetName()) } - return []interface{}{_t1668, _dollar_dollar.GetRelationId()} + return []interface{}{_t1680, _dollar_dollar.GetRelationId()} } - _t1669 := _t1667(msg) - fields1248 := _t1669 - unwrapped_fields1249 := fields1248 + _t1681 := _t1679(msg) + fields1258 := _t1681 + unwrapped_fields1259 := fields1258 p.write("(") p.write("abort") p.indentSexp() - field1250 := unwrapped_fields1249[0].(*string) - if field1250 != nil { + field1260 := unwrapped_fields1259[0].(*string) + if field1260 != nil { p.newline() - opt_val1251 := *field1250 - p.pretty_name(opt_val1251) + opt_val1261 := *field1260 + p.pretty_name(opt_val1261) } p.newline() - field1252 := unwrapped_fields1249[1].(*pb.RelationId) - p.pretty_relation_id(field1252) + field1262 := unwrapped_fields1259[1].(*pb.RelationId) + p.pretty_relation_id(field1262) p.dedent() p.write(")") } @@ -4303,22 +4327,22 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1256 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1256 != nil { - p.write(*flat1256) + flat1266 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1266 != nil { + p.write(*flat1266) return nil } else { - _t1670 := func(_dollar_dollar *pb.Export) *pb.ExportCSVConfig { + _t1682 := func(_dollar_dollar *pb.Export) *pb.ExportCSVConfig { return _dollar_dollar.GetCsvConfig() } - _t1671 := _t1670(msg) - fields1254 := _t1671 - unwrapped_fields1255 := fields1254 + _t1683 := _t1682(msg) + fields1264 := _t1683 + unwrapped_fields1265 := fields1264 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped_fields1255) + p.pretty_export_csv_config(unwrapped_fields1265) p.dedent() p.write(")") } @@ -4326,30 +4350,30 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1262 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1262 != nil { - p.write(*flat1262) + flat1272 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1272 != nil { + p.write(*flat1272) return nil } else { - _t1672 := func(_dollar_dollar *pb.ExportCSVConfig) []interface{} { - _t1673 := p.deconstruct_export_csv_config(_dollar_dollar) - return []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1673} + _t1684 := func(_dollar_dollar *pb.ExportCSVConfig) []interface{} { + _t1685 := p.deconstruct_export_csv_config(_dollar_dollar) + return []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1685} } - _t1674 := _t1672(msg) - fields1257 := _t1674 - unwrapped_fields1258 := fields1257 + _t1686 := _t1684(msg) + fields1267 := _t1686 + unwrapped_fields1268 := fields1267 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1259 := unwrapped_fields1258[0].(string) - p.pretty_export_csv_path(field1259) + field1269 := unwrapped_fields1268[0].(string) + p.pretty_export_csv_path(field1269) p.newline() - field1260 := unwrapped_fields1258[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns(field1260) + field1270 := unwrapped_fields1268[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns(field1270) p.newline() - field1261 := unwrapped_fields1258[2].([][]interface{}) - p.pretty_config_dict(field1261) + field1271 := unwrapped_fields1268[2].([][]interface{}) + p.pretty_config_dict(field1271) p.dedent() p.write(")") } @@ -4357,17 +4381,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1264 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1264 != nil { - p.write(*flat1264) + flat1274 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1274 != nil { + p.write(*flat1274) return nil } else { - fields1263 := msg + fields1273 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1263)) + p.write(p.formatStringValue(fields1273)) p.dedent() p.write(")") } @@ -4375,22 +4399,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) interface{} { - flat1268 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) }) - if flat1268 != nil { - p.write(*flat1268) + flat1278 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) }) + if flat1278 != nil { + p.write(*flat1278) return nil } else { - fields1265 := msg + fields1275 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1265) == 0) { + if !(len(fields1275) == 0) { p.newline() - for i1267, elem1266 := range fields1265 { - if (i1267 > 0) { + for i1277, elem1276 := range fields1275 { + if (i1277 > 0) { p.newline() } - p.pretty_export_csv_column(elem1266) + p.pretty_export_csv_column(elem1276) } } p.dedent() @@ -4400,26 +4424,26 @@ func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) int } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1273 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1273 != nil { - p.write(*flat1273) + flat1283 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1283 != nil { + p.write(*flat1283) return nil } else { - _t1675 := func(_dollar_dollar *pb.ExportCSVColumn) []interface{} { + _t1687 := func(_dollar_dollar *pb.ExportCSVColumn) []interface{} { return []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} } - _t1676 := _t1675(msg) - fields1269 := _t1676 - unwrapped_fields1270 := fields1269 + _t1688 := _t1687(msg) + fields1279 := _t1688 + unwrapped_fields1280 := fields1279 p.write("(") p.write("column") p.indentSexp() p.newline() - field1271 := unwrapped_fields1270[0].(string) - p.write(p.formatStringValue(field1271)) + field1281 := unwrapped_fields1280[0].(string) + p.write(p.formatStringValue(field1281)) p.newline() - field1272 := unwrapped_fields1270[1].(*pb.RelationId) - p.pretty_relation_id(field1272) + field1282 := unwrapped_fields1280[1].(*pb.RelationId) + p.pretty_relation_id(field1282) p.dedent() p.write(")") } @@ -4435,8 +4459,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1714 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1714) + _t1726 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1726) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") @@ -4749,6 +4773,8 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) { p.pretty_context(m) case *pb.Snapshot: p.pretty_snapshot(m) + case *pb.SnapshotMapping: + p.pretty_snapshot_mapping(m) case []*pb.Read: p.pretty_epoch_reads(m) case *pb.Read: diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl index 7fc8c0ae..7218a1cb 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl @@ -22,7 +22,7 @@ const LQPSyntax = Union{ RelAtom,Abstraction,Algorithm,Assign,Break,Conjunction,Def,Disjunction, Exists,FFI,MonoidDef,MonusDef,Not,Reduce,Script,Upsert,Construct,Declaration, Loop,Formula,Instruction,FragmentId,DebugInfo,Fragment,ExportCSVColumn, - ExportCSVConfig,Demand,Undefine,Configure,Snapshot,Define,Context,Sync,Abort,Output,Write, + ExportCSVConfig,Demand,Undefine,Configure,SnapshotMapping,Snapshot,Define,Context,Sync,Abort,Output,Write, Export,Epoch,Read,Transaction,WhatIf,Constraint,FunctionalDependency, DateTimeValue,DateValue,DecimalValue, BeTreeInfo,BeTreeRelation, diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 8a6b7e44..6c189a30 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -362,10 +362,15 @@ Base.:(==)(a::Define, b::Define) = a.fragment == b.fragment Base.hash(a::Define, h::UInt) = hash(a.fragment, h) Base.isequal(a::Define, b::Define) = isequal(a.fragment, b.fragment) +# SnapshotMapping +Base.:(==)(a::SnapshotMapping, b::SnapshotMapping) = a.destination_path == b.destination_path && a.source_relation == b.source_relation +Base.hash(a::SnapshotMapping, h::UInt) = hash(a.source_relation, hash(a.destination_path, h)) +Base.isequal(a::SnapshotMapping, b::SnapshotMapping) = isequal(a.destination_path, b.destination_path) && isequal(a.source_relation, b.source_relation) + # Snapshot -Base.:(==)(a::Snapshot, b::Snapshot) = a.destination_path == b.destination_path && a.source_relation == b.source_relation -Base.hash(a::Snapshot, h::UInt) = hash(a.source_relation, hash(a.destination_path, h)) -Base.isequal(a::Snapshot, b::Snapshot) = isequal(a.destination_path, b.destination_path) && isequal(a.source_relation, b.source_relation) +Base.:(==)(a::Snapshot, b::Snapshot) = a.mappings == b.mappings +Base.hash(a::Snapshot, h::UInt) = hash(a.mappings, h) +Base.isequal(a::Snapshot, b::Snapshot) = isequal(a.mappings, b.mappings) # Context Base.:(==)(a::Context, b::Context) = a.relations == b.relations diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl index 5b79c7b8..ae3e4a62 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl @@ -5,9 +5,9 @@ import ProtoBuf as PB using ProtoBuf: OneOf using ProtoBuf.EnumX: @enumx -export ExportCSVColumn, Demand, Undefine, MaintenanceLevel, Snapshot, Define, Context, Sync -export Abort, Output, ExportCSVConfig, IVMConfig, Write, Export, Configure, Epoch, Read -export Transaction, WhatIf +export ExportCSVColumn, Demand, Undefine, MaintenanceLevel, Define, Context, Sync +export SnapshotMapping, Abort, Output, ExportCSVConfig, IVMConfig, Snapshot, Export +export Configure, Write, Epoch, Read, Transaction, WhatIf abstract type var"##Abstract#Transaction" end abstract type var"##Abstract#Epoch" end abstract type var"##Abstract#Read" end @@ -115,43 +115,6 @@ end @enumx MaintenanceLevel MAINTENANCE_LEVEL_UNSPECIFIED=0 MAINTENANCE_LEVEL_OFF=1 MAINTENANCE_LEVEL_AUTO=2 MAINTENANCE_LEVEL_ALL=3 -struct Snapshot - destination_path::Vector{String} - source_relation::Union{Nothing,RelationId} -end -Snapshot(;destination_path = Vector{String}(), source_relation = nothing) = Snapshot(destination_path, source_relation) -PB.default_values(::Type{Snapshot}) = (;destination_path = Vector{String}(), source_relation = nothing) -PB.field_numbers(::Type{Snapshot}) = (;destination_path = 1, source_relation = 2) - -function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Snapshot}) - destination_path = PB.BufferedVector{String}() - source_relation = Ref{Union{Nothing,RelationId}}(nothing) - while !PB.message_done(d) - field_number, wire_type = PB.decode_tag(d) - if field_number == 1 - PB.decode!(d, destination_path) - elseif field_number == 2 - PB.decode!(d, source_relation) - else - Base.skip(d, wire_type) - end - end - return Snapshot(destination_path[], source_relation[]) -end - -function PB.encode(e::PB.AbstractProtoEncoder, x::Snapshot) - initpos = position(e.io) - !isempty(x.destination_path) && PB.encode(e, 1, x.destination_path) - !isnothing(x.source_relation) && PB.encode(e, 2, x.source_relation) - return position(e.io) - initpos -end -function PB._encoded_size(x::Snapshot) - encoded_size = 0 - !isempty(x.destination_path) && (encoded_size += PB._encoded_size(x.destination_path, 1)) - !isnothing(x.source_relation) && (encoded_size += PB._encoded_size(x.source_relation, 2)) - return encoded_size -end - struct Define fragment::Union{Nothing,Fragment} end @@ -245,6 +208,43 @@ function PB._encoded_size(x::Sync) return encoded_size end +struct SnapshotMapping + destination_path::Vector{String} + source_relation::Union{Nothing,RelationId} +end +SnapshotMapping(;destination_path = Vector{String}(), source_relation = nothing) = SnapshotMapping(destination_path, source_relation) +PB.default_values(::Type{SnapshotMapping}) = (;destination_path = Vector{String}(), source_relation = nothing) +PB.field_numbers(::Type{SnapshotMapping}) = (;destination_path = 1, source_relation = 2) + +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:SnapshotMapping}) + destination_path = PB.BufferedVector{String}() + source_relation = Ref{Union{Nothing,RelationId}}(nothing) + while !PB.message_done(d) + field_number, wire_type = PB.decode_tag(d) + if field_number == 1 + PB.decode!(d, destination_path) + elseif field_number == 2 + PB.decode!(d, source_relation) + else + Base.skip(d, wire_type) + end + end + return SnapshotMapping(destination_path[], source_relation[]) +end + +function PB.encode(e::PB.AbstractProtoEncoder, x::SnapshotMapping) + initpos = position(e.io) + !isempty(x.destination_path) && PB.encode(e, 1, x.destination_path) + !isnothing(x.source_relation) && PB.encode(e, 2, x.source_relation) + return position(e.io) - initpos +end +function PB._encoded_size(x::SnapshotMapping) + encoded_size = 0 + !isempty(x.destination_path) && (encoded_size += PB._encoded_size(x.destination_path, 1)) + !isnothing(x.source_relation) && (encoded_size += PB._encoded_size(x.source_relation, 2)) + return encoded_size +end + struct Abort name::String relation_id::Union{Nothing,RelationId} @@ -429,62 +429,34 @@ function PB._encoded_size(x::IVMConfig) return encoded_size end -struct Write - write_type::Union{Nothing,OneOf{<:Union{Define,Undefine,Context,Snapshot}}} +struct Snapshot + mappings::Vector{SnapshotMapping} end -Write(;write_type = nothing) = Write(write_type) -PB.reserved_fields(::Type{Write}) = (names = String[], numbers = Union{Int,UnitRange{Int}}[4]) -PB.oneof_field_types(::Type{Write}) = (; - write_type = (;define=Define, undefine=Undefine, context=Context, snapshot=Snapshot), -) -PB.default_values(::Type{Write}) = (;define = nothing, undefine = nothing, context = nothing, snapshot = nothing) -PB.field_numbers(::Type{Write}) = (;define = 1, undefine = 2, context = 3, snapshot = 5) +Snapshot(;mappings = Vector{SnapshotMapping}()) = Snapshot(mappings) +PB.default_values(::Type{Snapshot}) = (;mappings = Vector{SnapshotMapping}()) +PB.field_numbers(::Type{Snapshot}) = (;mappings = 1) -function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Write}) - write_type = nothing +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Snapshot}) + mappings = PB.BufferedVector{SnapshotMapping}() while !PB.message_done(d) field_number, wire_type = PB.decode_tag(d) if field_number == 1 - write_type = OneOf(:define, PB.decode(d, Ref{Define})) - elseif field_number == 2 - write_type = OneOf(:undefine, PB.decode(d, Ref{Undefine})) - elseif field_number == 3 - write_type = OneOf(:context, PB.decode(d, Ref{Context})) - elseif field_number == 5 - write_type = OneOf(:snapshot, PB.decode(d, Ref{Snapshot})) + PB.decode!(d, mappings) else Base.skip(d, wire_type) end end - return Write(write_type) + return Snapshot(mappings[]) end -function PB.encode(e::PB.AbstractProtoEncoder, x::Write) +function PB.encode(e::PB.AbstractProtoEncoder, x::Snapshot) initpos = position(e.io) - if isnothing(x.write_type); - elseif x.write_type.name === :define - PB.encode(e, 1, x.write_type[]::Define) - elseif x.write_type.name === :undefine - PB.encode(e, 2, x.write_type[]::Undefine) - elseif x.write_type.name === :context - PB.encode(e, 3, x.write_type[]::Context) - elseif x.write_type.name === :snapshot - PB.encode(e, 5, x.write_type[]::Snapshot) - end + !isempty(x.mappings) && PB.encode(e, 1, x.mappings) return position(e.io) - initpos end -function PB._encoded_size(x::Write) +function PB._encoded_size(x::Snapshot) encoded_size = 0 - if isnothing(x.write_type); - elseif x.write_type.name === :define - encoded_size += PB._encoded_size(x.write_type[]::Define, 1) - elseif x.write_type.name === :undefine - encoded_size += PB._encoded_size(x.write_type[]::Undefine, 2) - elseif x.write_type.name === :context - encoded_size += PB._encoded_size(x.write_type[]::Context, 3) - elseif x.write_type.name === :snapshot - encoded_size += PB._encoded_size(x.write_type[]::Snapshot, 5) - end + !isempty(x.mappings) && (encoded_size += PB._encoded_size(x.mappings, 1)) return encoded_size end @@ -565,6 +537,65 @@ function PB._encoded_size(x::Configure) return encoded_size end +struct Write + write_type::Union{Nothing,OneOf{<:Union{Define,Undefine,Context,Snapshot}}} +end +Write(;write_type = nothing) = Write(write_type) +PB.reserved_fields(::Type{Write}) = (names = String[], numbers = Union{Int,UnitRange{Int}}[4]) +PB.oneof_field_types(::Type{Write}) = (; + write_type = (;define=Define, undefine=Undefine, context=Context, snapshot=Snapshot), +) +PB.default_values(::Type{Write}) = (;define = nothing, undefine = nothing, context = nothing, snapshot = nothing) +PB.field_numbers(::Type{Write}) = (;define = 1, undefine = 2, context = 3, snapshot = 5) + +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Write}) + write_type = nothing + while !PB.message_done(d) + field_number, wire_type = PB.decode_tag(d) + if field_number == 1 + write_type = OneOf(:define, PB.decode(d, Ref{Define})) + elseif field_number == 2 + write_type = OneOf(:undefine, PB.decode(d, Ref{Undefine})) + elseif field_number == 3 + write_type = OneOf(:context, PB.decode(d, Ref{Context})) + elseif field_number == 5 + write_type = OneOf(:snapshot, PB.decode(d, Ref{Snapshot})) + else + Base.skip(d, wire_type) + end + end + return Write(write_type) +end + +function PB.encode(e::PB.AbstractProtoEncoder, x::Write) + initpos = position(e.io) + if isnothing(x.write_type); + elseif x.write_type.name === :define + PB.encode(e, 1, x.write_type[]::Define) + elseif x.write_type.name === :undefine + PB.encode(e, 2, x.write_type[]::Undefine) + elseif x.write_type.name === :context + PB.encode(e, 3, x.write_type[]::Context) + elseif x.write_type.name === :snapshot + PB.encode(e, 5, x.write_type[]::Snapshot) + end + return position(e.io) - initpos +end +function PB._encoded_size(x::Write) + encoded_size = 0 + if isnothing(x.write_type); + elseif x.write_type.name === :define + encoded_size += PB._encoded_size(x.write_type[]::Define, 1) + elseif x.write_type.name === :undefine + encoded_size += PB._encoded_size(x.write_type[]::Undefine, 2) + elseif x.write_type.name === :context + encoded_size += PB._encoded_size(x.write_type[]::Context, 3) + elseif x.write_type.name === :snapshot + encoded_size += PB._encoded_size(x.write_type[]::Snapshot, 5) + end + return encoded_size +end + # Stub definitions for cyclic types struct var"##Stub#Epoch"{T1<:var"##Abstract#Read"} <: var"##Abstract#Epoch" writes::Vector{Write} diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 22ee7471..40b58a46 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -305,7 +305,7 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return Int32(_get_oneof_field(value, :int_value)) else - _t1329 = nothing + _t1339 = nothing end return Int32(default) end @@ -314,7 +314,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 - _t1330 = nothing + _t1340 = nothing end return default end @@ -323,7 +323,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 - _t1331 = nothing + _t1341 = nothing end return default end @@ -332,7 +332,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 - _t1332 = nothing + _t1342 = nothing end return default end @@ -341,7 +341,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 - _t1333 = nothing + _t1343 = nothing end return default end @@ -350,7 +350,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 - _t1334 = nothing + _t1344 = nothing end return nothing end @@ -359,7 +359,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 - _t1335 = nothing + _t1345 = nothing end return nothing end @@ -368,7 +368,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 - _t1336 = nothing + _t1346 = nothing end return nothing end @@ -377,70 +377,70 @@ 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 - _t1337 = nothing + _t1347 = nothing end return nothing end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.CSVConfig config = Dict(config_dict) - _t1338 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t1338 - _t1339 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t1339 - _t1340 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t1340 - _t1341 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t1341 - _t1342 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t1342 - _t1343 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t1343 - _t1344 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t1344 - _t1345 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t1345 - _t1346 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t1346 - _t1347 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t1347 - _t1348 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") - compression = _t1348 - _t1349 = 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) - return _t1349 + _t1348 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t1348 + _t1349 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t1349 + _t1350 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t1350 + _t1351 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t1351 + _t1352 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t1352 + _t1353 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t1353 + _t1354 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t1354 + _t1355 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t1355 + _t1356 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t1356 + _t1357 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t1357 + _t1358 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") + compression = _t1358 + _t1359 = 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) + return _t1359 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) - _t1350 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t1350 - _t1351 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t1351 - _t1352 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t1352 - _t1353 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t1353 - _t1354 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t1354 - _t1355 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t1355 - _t1356 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t1356 - _t1357 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t1357 - _t1358 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t1358 - _t1359 = 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 = _t1359 - _t1360 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t1360 + _t1360 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t1360 + _t1361 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t1361 + _t1362 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t1362 + _t1363 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t1363 + _t1364 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t1364 + _t1365 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t1365 + _t1366 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t1366 + _t1367 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t1367 + _t1368 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t1368 + _t1369 = 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 = _t1369 + _t1370 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t1370 end function default_configure(parser::ParserState)::Proto.Configure - _t1361 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t1361 - _t1362 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t1362 + _t1371 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t1371 + _t1372 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t1372 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -462,32 +462,32 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t1363 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t1363 - _t1364 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t1364 - _t1365 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t1365 + _t1373 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t1373 + _t1374 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t1374 + _t1375 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t1375 end function export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t1366 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t1366 - _t1367 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t1367 - _t1368 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t1368 - _t1369 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t1369 - _t1370 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t1370 - _t1371 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t1371 - _t1372 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t1372 - _t1373 = 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 _t1373 + _t1376 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t1376 + _t1377 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t1377 + _t1378 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t1378 + _t1379 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t1379 + _t1380 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t1380 + _t1381 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t1381 + _t1382 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t1382 + _t1383 = 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 _t1383 end # --- Parse functions --- @@ -496,2186 +496,2170 @@ function parse_transaction(parser::ParserState)::Proto.Transaction consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t725 = parse_configure(parser) - _t724 = _t725 + _t733 = parse_configure(parser) + _t732 = _t733 else - _t724 = nothing + _t732 = nothing end - configure362 = _t724 + configure366 = _t732 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t727 = parse_sync(parser) - _t726 = _t727 + _t735 = parse_sync(parser) + _t734 = _t735 else - _t726 = nothing + _t734 = nothing end - sync363 = _t726 - xs364 = Proto.Epoch[] - cond365 = match_lookahead_literal(parser, "(", 0) - while cond365 - _t728 = parse_epoch(parser) - item366 = _t728 - push!(xs364, item366) - cond365 = match_lookahead_literal(parser, "(", 0) + sync367 = _t734 + xs368 = Proto.Epoch[] + cond369 = match_lookahead_literal(parser, "(", 0) + while cond369 + _t736 = parse_epoch(parser) + item370 = _t736 + push!(xs368, item370) + cond369 = match_lookahead_literal(parser, "(", 0) end - epochs367 = xs364 + epochs371 = xs368 consume_literal!(parser, ")") - _t729 = default_configure(parser) - _t730 = Proto.Transaction(epochs=epochs367, configure=(!isnothing(configure362) ? configure362 : _t729), sync=sync363) - return _t730 + _t737 = default_configure(parser) + _t738 = Proto.Transaction(epochs=epochs371, configure=(!isnothing(configure366) ? configure366 : _t737), sync=sync367) + return _t738 end function parse_configure(parser::ParserState)::Proto.Configure consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t731 = parse_config_dict(parser) - config_dict368 = _t731 + _t739 = parse_config_dict(parser) + config_dict372 = _t739 consume_literal!(parser, ")") - _t732 = construct_configure(parser, config_dict368) - return _t732 + _t740 = construct_configure(parser, config_dict372) + return _t740 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs369 = Tuple{String, Proto.Value}[] - cond370 = match_lookahead_literal(parser, ":", 0) - while cond370 - _t733 = parse_config_key_value(parser) - item371 = _t733 - push!(xs369, item371) - cond370 = match_lookahead_literal(parser, ":", 0) - end - config_key_values372 = xs369 + xs373 = Tuple{String, Proto.Value}[] + cond374 = match_lookahead_literal(parser, ":", 0) + while cond374 + _t741 = parse_config_key_value(parser) + item375 = _t741 + push!(xs373, item375) + cond374 = match_lookahead_literal(parser, ":", 0) + end + config_key_values376 = xs373 consume_literal!(parser, "}") - return config_key_values372 + return config_key_values376 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol373 = consume_terminal!(parser, "SYMBOL") - _t734 = parse_value(parser) - value374 = _t734 - return (symbol373, value374,) + symbol377 = consume_terminal!(parser, "SYMBOL") + _t742 = parse_value(parser) + value378 = _t742 + return (symbol377, value378,) end function parse_value(parser::ParserState)::Proto.Value if match_lookahead_literal(parser, "true", 0) - _t735 = 9 + _t743 = 9 else if match_lookahead_literal(parser, "missing", 0) - _t736 = 8 + _t744 = 8 else if match_lookahead_literal(parser, "false", 0) - _t737 = 9 + _t745 = 9 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t739 = 1 + _t747 = 1 else if match_lookahead_literal(parser, "date", 1) - _t740 = 0 + _t748 = 0 else - _t740 = -1 + _t748 = -1 end - _t739 = _t740 + _t747 = _t748 end - _t738 = _t739 + _t746 = _t747 else if match_lookahead_terminal(parser, "UINT128", 0) - _t741 = 5 + _t749 = 5 else if match_lookahead_terminal(parser, "STRING", 0) - _t742 = 2 + _t750 = 2 else if match_lookahead_terminal(parser, "INT128", 0) - _t743 = 6 + _t751 = 6 else if match_lookahead_terminal(parser, "INT", 0) - _t744 = 3 + _t752 = 3 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t745 = 4 + _t753 = 4 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t746 = 7 + _t754 = 7 else - _t746 = -1 + _t754 = -1 end - _t745 = _t746 + _t753 = _t754 end - _t744 = _t745 + _t752 = _t753 end - _t743 = _t744 + _t751 = _t752 end - _t742 = _t743 + _t750 = _t751 end - _t741 = _t742 + _t749 = _t750 end - _t738 = _t741 + _t746 = _t749 end - _t737 = _t738 + _t745 = _t746 end - _t736 = _t737 + _t744 = _t745 end - _t735 = _t736 - end - prediction375 = _t735 - if prediction375 == 9 - _t748 = parse_boolean_value(parser) - boolean_value384 = _t748 - _t749 = Proto.Value(value=OneOf(:boolean_value, boolean_value384)) - _t747 = _t749 + _t743 = _t744 + end + prediction379 = _t743 + if prediction379 == 9 + _t756 = parse_boolean_value(parser) + boolean_value388 = _t756 + _t757 = Proto.Value(value=OneOf(:boolean_value, boolean_value388)) + _t755 = _t757 else - if prediction375 == 8 + if prediction379 == 8 consume_literal!(parser, "missing") - _t751 = Proto.MissingValue() - _t752 = Proto.Value(value=OneOf(:missing_value, _t751)) - _t750 = _t752 + _t759 = Proto.MissingValue() + _t760 = Proto.Value(value=OneOf(:missing_value, _t759)) + _t758 = _t760 else - if prediction375 == 7 - decimal383 = consume_terminal!(parser, "DECIMAL") - _t754 = Proto.Value(value=OneOf(:decimal_value, decimal383)) - _t753 = _t754 + if prediction379 == 7 + decimal387 = consume_terminal!(parser, "DECIMAL") + _t762 = Proto.Value(value=OneOf(:decimal_value, decimal387)) + _t761 = _t762 else - if prediction375 == 6 - int128382 = consume_terminal!(parser, "INT128") - _t756 = Proto.Value(value=OneOf(:int128_value, int128382)) - _t755 = _t756 + if prediction379 == 6 + int128386 = consume_terminal!(parser, "INT128") + _t764 = Proto.Value(value=OneOf(:int128_value, int128386)) + _t763 = _t764 else - if prediction375 == 5 - uint128381 = consume_terminal!(parser, "UINT128") - _t758 = Proto.Value(value=OneOf(:uint128_value, uint128381)) - _t757 = _t758 + if prediction379 == 5 + uint128385 = consume_terminal!(parser, "UINT128") + _t766 = Proto.Value(value=OneOf(:uint128_value, uint128385)) + _t765 = _t766 else - if prediction375 == 4 - float380 = consume_terminal!(parser, "FLOAT") - _t760 = Proto.Value(value=OneOf(:float_value, float380)) - _t759 = _t760 + if prediction379 == 4 + float384 = consume_terminal!(parser, "FLOAT") + _t768 = Proto.Value(value=OneOf(:float_value, float384)) + _t767 = _t768 else - if prediction375 == 3 - int379 = consume_terminal!(parser, "INT") - _t762 = Proto.Value(value=OneOf(:int_value, int379)) - _t761 = _t762 + if prediction379 == 3 + int383 = consume_terminal!(parser, "INT") + _t770 = Proto.Value(value=OneOf(:int_value, int383)) + _t769 = _t770 else - if prediction375 == 2 - string378 = consume_terminal!(parser, "STRING") - _t764 = Proto.Value(value=OneOf(:string_value, string378)) - _t763 = _t764 + if prediction379 == 2 + string382 = consume_terminal!(parser, "STRING") + _t772 = Proto.Value(value=OneOf(:string_value, string382)) + _t771 = _t772 else - if prediction375 == 1 - _t766 = parse_datetime(parser) - datetime377 = _t766 - _t767 = Proto.Value(value=OneOf(:datetime_value, datetime377)) - _t765 = _t767 + if prediction379 == 1 + _t774 = parse_datetime(parser) + datetime381 = _t774 + _t775 = Proto.Value(value=OneOf(:datetime_value, datetime381)) + _t773 = _t775 else - if prediction375 == 0 - _t769 = parse_date(parser) - date376 = _t769 - _t770 = Proto.Value(value=OneOf(:date_value, date376)) - _t768 = _t770 + if prediction379 == 0 + _t777 = parse_date(parser) + date380 = _t777 + _t778 = Proto.Value(value=OneOf(:date_value, date380)) + _t776 = _t778 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t765 = _t768 + _t773 = _t776 end - _t763 = _t765 + _t771 = _t773 end - _t761 = _t763 + _t769 = _t771 end - _t759 = _t761 + _t767 = _t769 end - _t757 = _t759 + _t765 = _t767 end - _t755 = _t757 + _t763 = _t765 end - _t753 = _t755 + _t761 = _t763 end - _t750 = _t753 + _t758 = _t761 end - _t747 = _t750 + _t755 = _t758 end - return _t747 + return _t755 end function parse_date(parser::ParserState)::Proto.DateValue consume_literal!(parser, "(") consume_literal!(parser, "date") - int385 = consume_terminal!(parser, "INT") - int_3386 = consume_terminal!(parser, "INT") - int_4387 = consume_terminal!(parser, "INT") + int389 = consume_terminal!(parser, "INT") + int_3390 = consume_terminal!(parser, "INT") + int_4391 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t771 = Proto.DateValue(year=Int32(int385), month=Int32(int_3386), day=Int32(int_4387)) - return _t771 + _t779 = Proto.DateValue(year=Int32(int389), month=Int32(int_3390), day=Int32(int_4391)) + return _t779 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int388 = consume_terminal!(parser, "INT") - int_3389 = consume_terminal!(parser, "INT") - int_4390 = consume_terminal!(parser, "INT") - int_5391 = consume_terminal!(parser, "INT") - int_6392 = consume_terminal!(parser, "INT") - int_7393 = consume_terminal!(parser, "INT") + int392 = consume_terminal!(parser, "INT") + int_3393 = consume_terminal!(parser, "INT") + int_4394 = consume_terminal!(parser, "INT") + int_5395 = consume_terminal!(parser, "INT") + int_6396 = consume_terminal!(parser, "INT") + int_7397 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t772 = consume_terminal!(parser, "INT") + _t780 = consume_terminal!(parser, "INT") else - _t772 = nothing + _t780 = nothing end - int_8394 = _t772 + int_8398 = _t780 consume_literal!(parser, ")") - _t773 = Proto.DateTimeValue(year=Int32(int388), month=Int32(int_3389), day=Int32(int_4390), hour=Int32(int_5391), minute=Int32(int_6392), second=Int32(int_7393), microsecond=Int32((!isnothing(int_8394) ? int_8394 : 0))) - return _t773 + _t781 = Proto.DateTimeValue(year=Int32(int392), month=Int32(int_3393), day=Int32(int_4394), hour=Int32(int_5395), minute=Int32(int_6396), second=Int32(int_7397), microsecond=Int32((!isnothing(int_8398) ? int_8398 : 0))) + return _t781 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t774 = 0 + _t782 = 0 else if match_lookahead_literal(parser, "false", 0) - _t775 = 1 + _t783 = 1 else - _t775 = -1 + _t783 = -1 end - _t774 = _t775 + _t782 = _t783 end - prediction395 = _t774 - if prediction395 == 1 + prediction399 = _t782 + if prediction399 == 1 consume_literal!(parser, "false") - _t776 = false + _t784 = false else - if prediction395 == 0 + if prediction399 == 0 consume_literal!(parser, "true") - _t777 = true + _t785 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t776 = _t777 + _t784 = _t785 end - return _t776 + return _t784 end function parse_sync(parser::ParserState)::Proto.Sync consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs396 = Proto.FragmentId[] - cond397 = match_lookahead_literal(parser, ":", 0) - while cond397 - _t778 = parse_fragment_id(parser) - item398 = _t778 - push!(xs396, item398) - cond397 = match_lookahead_literal(parser, ":", 0) + xs400 = Proto.FragmentId[] + cond401 = match_lookahead_literal(parser, ":", 0) + while cond401 + _t786 = parse_fragment_id(parser) + item402 = _t786 + push!(xs400, item402) + cond401 = match_lookahead_literal(parser, ":", 0) end - fragment_ids399 = xs396 + fragment_ids403 = xs400 consume_literal!(parser, ")") - _t779 = Proto.Sync(fragments=fragment_ids399) - return _t779 + _t787 = Proto.Sync(fragments=fragment_ids403) + return _t787 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId consume_literal!(parser, ":") - symbol400 = consume_terminal!(parser, "SYMBOL") - return Proto.FragmentId(Vector{UInt8}(symbol400)) + symbol404 = consume_terminal!(parser, "SYMBOL") + return Proto.FragmentId(Vector{UInt8}(symbol404)) end function parse_epoch(parser::ParserState)::Proto.Epoch consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t781 = parse_epoch_writes(parser) - _t780 = _t781 + _t789 = parse_epoch_writes(parser) + _t788 = _t789 else - _t780 = nothing + _t788 = nothing end - epoch_writes401 = _t780 + epoch_writes405 = _t788 if match_lookahead_literal(parser, "(", 0) - _t783 = parse_epoch_reads(parser) - _t782 = _t783 + _t791 = parse_epoch_reads(parser) + _t790 = _t791 else - _t782 = nothing + _t790 = nothing end - epoch_reads402 = _t782 + epoch_reads406 = _t790 consume_literal!(parser, ")") - _t784 = Proto.Epoch(writes=(!isnothing(epoch_writes401) ? epoch_writes401 : Proto.Write[]), reads=(!isnothing(epoch_reads402) ? epoch_reads402 : Proto.Read[])) - return _t784 + _t792 = Proto.Epoch(writes=(!isnothing(epoch_writes405) ? epoch_writes405 : Proto.Write[]), reads=(!isnothing(epoch_reads406) ? epoch_reads406 : Proto.Read[])) + return _t792 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs403 = Proto.Write[] - cond404 = match_lookahead_literal(parser, "(", 0) - while cond404 - _t785 = parse_write(parser) - item405 = _t785 - push!(xs403, item405) - cond404 = match_lookahead_literal(parser, "(", 0) + xs407 = Proto.Write[] + cond408 = match_lookahead_literal(parser, "(", 0) + while cond408 + _t793 = parse_write(parser) + item409 = _t793 + push!(xs407, item409) + cond408 = match_lookahead_literal(parser, "(", 0) end - writes406 = xs403 + writes410 = xs407 consume_literal!(parser, ")") - return writes406 + return writes410 end function parse_write(parser::ParserState)::Proto.Write if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t787 = 1 + _t795 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t788 = 3 + _t796 = 3 else if match_lookahead_literal(parser, "define", 1) - _t789 = 0 + _t797 = 0 else if match_lookahead_literal(parser, "context", 1) - _t790 = 2 + _t798 = 2 else - _t790 = -1 + _t798 = -1 end - _t789 = _t790 + _t797 = _t798 end - _t788 = _t789 + _t796 = _t797 end - _t787 = _t788 + _t795 = _t796 end - _t786 = _t787 + _t794 = _t795 else - _t786 = -1 - end - prediction407 = _t786 - if prediction407 == 3 - _t792 = parse_snapshot(parser) - snapshot411 = _t792 - _t793 = Proto.Write(write_type=OneOf(:snapshot, snapshot411)) - _t791 = _t793 + _t794 = -1 + end + prediction411 = _t794 + if prediction411 == 3 + _t800 = parse_snapshot(parser) + snapshot415 = _t800 + _t801 = Proto.Write(write_type=OneOf(:snapshot, snapshot415)) + _t799 = _t801 else - if prediction407 == 2 - _t795 = parse_context(parser) - context410 = _t795 - _t796 = Proto.Write(write_type=OneOf(:context, context410)) - _t794 = _t796 + if prediction411 == 2 + _t803 = parse_context(parser) + context414 = _t803 + _t804 = Proto.Write(write_type=OneOf(:context, context414)) + _t802 = _t804 else - if prediction407 == 1 - _t798 = parse_undefine(parser) - undefine409 = _t798 - _t799 = Proto.Write(write_type=OneOf(:undefine, undefine409)) - _t797 = _t799 + if prediction411 == 1 + _t806 = parse_undefine(parser) + undefine413 = _t806 + _t807 = Proto.Write(write_type=OneOf(:undefine, undefine413)) + _t805 = _t807 else - if prediction407 == 0 - _t801 = parse_define(parser) - define408 = _t801 - _t802 = Proto.Write(write_type=OneOf(:define, define408)) - _t800 = _t802 + if prediction411 == 0 + _t809 = parse_define(parser) + define412 = _t809 + _t810 = Proto.Write(write_type=OneOf(:define, define412)) + _t808 = _t810 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t797 = _t800 + _t805 = _t808 end - _t794 = _t797 + _t802 = _t805 end - _t791 = _t794 + _t799 = _t802 end - return _t791 + return _t799 end function parse_define(parser::ParserState)::Proto.Define consume_literal!(parser, "(") consume_literal!(parser, "define") - _t803 = parse_fragment(parser) - fragment412 = _t803 + _t811 = parse_fragment(parser) + fragment416 = _t811 consume_literal!(parser, ")") - _t804 = Proto.Define(fragment=fragment412) - return _t804 + _t812 = Proto.Define(fragment=fragment416) + return _t812 end function parse_fragment(parser::ParserState)::Proto.Fragment consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t805 = parse_new_fragment_id(parser) - new_fragment_id413 = _t805 - xs414 = Proto.Declaration[] - cond415 = match_lookahead_literal(parser, "(", 0) - while cond415 - _t806 = parse_declaration(parser) - item416 = _t806 - push!(xs414, item416) - cond415 = match_lookahead_literal(parser, "(", 0) + _t813 = parse_new_fragment_id(parser) + new_fragment_id417 = _t813 + xs418 = Proto.Declaration[] + cond419 = match_lookahead_literal(parser, "(", 0) + while cond419 + _t814 = parse_declaration(parser) + item420 = _t814 + push!(xs418, item420) + cond419 = match_lookahead_literal(parser, "(", 0) end - declarations417 = xs414 + declarations421 = xs418 consume_literal!(parser, ")") - return construct_fragment(parser, new_fragment_id413, declarations417) + return construct_fragment(parser, new_fragment_id417, declarations421) end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - _t807 = parse_fragment_id(parser) - fragment_id418 = _t807 - start_fragment!(parser, fragment_id418) - return fragment_id418 + _t815 = parse_fragment_id(parser) + fragment_id422 = _t815 + start_fragment!(parser, fragment_id422) + return fragment_id422 end function parse_declaration(parser::ParserState)::Proto.Declaration if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "functional_dependency", 1) - _t809 = 2 + _t817 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t810 = 3 + _t818 = 3 else if match_lookahead_literal(parser, "def", 1) - _t811 = 0 + _t819 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t812 = 3 + _t820 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t813 = 3 + _t821 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t814 = 1 + _t822 = 1 else - _t814 = -1 + _t822 = -1 end - _t813 = _t814 + _t821 = _t822 end - _t812 = _t813 + _t820 = _t821 end - _t811 = _t812 + _t819 = _t820 end - _t810 = _t811 + _t818 = _t819 end - _t809 = _t810 + _t817 = _t818 end - _t808 = _t809 + _t816 = _t817 else - _t808 = -1 - end - prediction419 = _t808 - if prediction419 == 3 - _t816 = parse_data(parser) - data423 = _t816 - _t817 = Proto.Declaration(declaration_type=OneOf(:data, data423)) - _t815 = _t817 + _t816 = -1 + end + prediction423 = _t816 + if prediction423 == 3 + _t824 = parse_data(parser) + data427 = _t824 + _t825 = Proto.Declaration(declaration_type=OneOf(:data, data427)) + _t823 = _t825 else - if prediction419 == 2 - _t819 = parse_constraint(parser) - constraint422 = _t819 - _t820 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint422)) - _t818 = _t820 + if prediction423 == 2 + _t827 = parse_constraint(parser) + constraint426 = _t827 + _t828 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint426)) + _t826 = _t828 else - if prediction419 == 1 - _t822 = parse_algorithm(parser) - algorithm421 = _t822 - _t823 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm421)) - _t821 = _t823 + if prediction423 == 1 + _t830 = parse_algorithm(parser) + algorithm425 = _t830 + _t831 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm425)) + _t829 = _t831 else - if prediction419 == 0 - _t825 = parse_def(parser) - def420 = _t825 - _t826 = Proto.Declaration(declaration_type=OneOf(:def, def420)) - _t824 = _t826 + if prediction423 == 0 + _t833 = parse_def(parser) + def424 = _t833 + _t834 = Proto.Declaration(declaration_type=OneOf(:def, def424)) + _t832 = _t834 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t821 = _t824 + _t829 = _t832 end - _t818 = _t821 + _t826 = _t829 end - _t815 = _t818 + _t823 = _t826 end - return _t815 + return _t823 end function parse_def(parser::ParserState)::Proto.Def consume_literal!(parser, "(") consume_literal!(parser, "def") - _t827 = parse_relation_id(parser) - relation_id424 = _t827 - _t828 = parse_abstraction(parser) - abstraction425 = _t828 + _t835 = parse_relation_id(parser) + relation_id428 = _t835 + _t836 = parse_abstraction(parser) + abstraction429 = _t836 if match_lookahead_literal(parser, "(", 0) - _t830 = parse_attrs(parser) - _t829 = _t830 + _t838 = parse_attrs(parser) + _t837 = _t838 else - _t829 = nothing + _t837 = nothing end - attrs426 = _t829 + attrs430 = _t837 consume_literal!(parser, ")") - _t831 = Proto.Def(name=relation_id424, body=abstraction425, attrs=(!isnothing(attrs426) ? attrs426 : Proto.Attribute[])) - return _t831 + _t839 = Proto.Def(name=relation_id428, body=abstraction429, attrs=(!isnothing(attrs430) ? attrs430 : Proto.Attribute[])) + return _t839 end function parse_relation_id(parser::ParserState)::Proto.RelationId if match_lookahead_literal(parser, ":", 0) - _t832 = 0 + _t840 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t833 = 1 + _t841 = 1 else - _t833 = -1 + _t841 = -1 end - _t832 = _t833 + _t840 = _t841 end - prediction427 = _t832 - if prediction427 == 1 - uint128429 = consume_terminal!(parser, "UINT128") - _t834 = Proto.RelationId(uint128429.low, uint128429.high) + prediction431 = _t840 + if prediction431 == 1 + uint128433 = consume_terminal!(parser, "UINT128") + _t842 = Proto.RelationId(uint128433.low, uint128433.high) else - if prediction427 == 0 + if prediction431 == 0 consume_literal!(parser, ":") - symbol428 = consume_terminal!(parser, "SYMBOL") - _t835 = relation_id_from_string(parser, symbol428) + symbol432 = consume_terminal!(parser, "SYMBOL") + _t843 = relation_id_from_string(parser, symbol432) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t834 = _t835 + _t842 = _t843 end - return _t834 + return _t842 end function parse_abstraction(parser::ParserState)::Proto.Abstraction consume_literal!(parser, "(") - _t836 = parse_bindings(parser) - bindings430 = _t836 - _t837 = parse_formula(parser) - formula431 = _t837 + _t844 = parse_bindings(parser) + bindings434 = _t844 + _t845 = parse_formula(parser) + formula435 = _t845 consume_literal!(parser, ")") - _t838 = Proto.Abstraction(vars=vcat(bindings430[1], !isnothing(bindings430[2]) ? bindings430[2] : []), value=formula431) - return _t838 + _t846 = Proto.Abstraction(vars=vcat(bindings434[1], !isnothing(bindings434[2]) ? bindings434[2] : []), value=formula435) + return _t846 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs432 = Proto.Binding[] - cond433 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond433 - _t839 = parse_binding(parser) - item434 = _t839 - push!(xs432, item434) - cond433 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings435 = xs432 + xs436 = Proto.Binding[] + cond437 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond437 + _t847 = parse_binding(parser) + item438 = _t847 + push!(xs436, item438) + cond437 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings439 = xs436 if match_lookahead_literal(parser, "|", 0) - _t841 = parse_value_bindings(parser) - _t840 = _t841 + _t849 = parse_value_bindings(parser) + _t848 = _t849 else - _t840 = nothing + _t848 = nothing end - value_bindings436 = _t840 + value_bindings440 = _t848 consume_literal!(parser, "]") - return (bindings435, (!isnothing(value_bindings436) ? value_bindings436 : Proto.Binding[]),) + return (bindings439, (!isnothing(value_bindings440) ? value_bindings440 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - symbol437 = consume_terminal!(parser, "SYMBOL") + symbol441 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t842 = parse_type(parser) - type438 = _t842 - _t843 = Proto.Var(name=symbol437) - _t844 = Proto.Binding(var=_t843, var"#type"=type438) - return _t844 + _t850 = parse_type(parser) + type442 = _t850 + _t851 = Proto.Var(name=symbol441) + _t852 = Proto.Binding(var=_t851, var"#type"=type442) + return _t852 end function parse_type(parser::ParserState)::Proto.var"#Type" if match_lookahead_literal(parser, "UNKNOWN", 0) - _t845 = 0 + _t853 = 0 else if match_lookahead_literal(parser, "UINT128", 0) - _t846 = 4 + _t854 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t847 = 1 + _t855 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t848 = 8 + _t856 = 8 else if match_lookahead_literal(parser, "INT128", 0) - _t849 = 5 + _t857 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t850 = 2 + _t858 = 2 else if match_lookahead_literal(parser, "FLOAT", 0) - _t851 = 3 + _t859 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t852 = 7 + _t860 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t853 = 6 + _t861 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t854 = 10 + _t862 = 10 else if match_lookahead_literal(parser, "(", 0) - _t855 = 9 + _t863 = 9 else - _t855 = -1 + _t863 = -1 end - _t854 = _t855 + _t862 = _t863 end - _t853 = _t854 + _t861 = _t862 end - _t852 = _t853 + _t860 = _t861 end - _t851 = _t852 + _t859 = _t860 end - _t850 = _t851 + _t858 = _t859 end - _t849 = _t850 + _t857 = _t858 end - _t848 = _t849 + _t856 = _t857 end - _t847 = _t848 + _t855 = _t856 end - _t846 = _t847 + _t854 = _t855 end - _t845 = _t846 - end - prediction439 = _t845 - if prediction439 == 10 - _t857 = parse_boolean_type(parser) - boolean_type450 = _t857 - _t858 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type450)) - _t856 = _t858 + _t853 = _t854 + end + prediction443 = _t853 + if prediction443 == 10 + _t865 = parse_boolean_type(parser) + boolean_type454 = _t865 + _t866 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type454)) + _t864 = _t866 else - if prediction439 == 9 - _t860 = parse_decimal_type(parser) - decimal_type449 = _t860 - _t861 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type449)) - _t859 = _t861 + if prediction443 == 9 + _t868 = parse_decimal_type(parser) + decimal_type453 = _t868 + _t869 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type453)) + _t867 = _t869 else - if prediction439 == 8 - _t863 = parse_missing_type(parser) - missing_type448 = _t863 - _t864 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type448)) - _t862 = _t864 + if prediction443 == 8 + _t871 = parse_missing_type(parser) + missing_type452 = _t871 + _t872 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type452)) + _t870 = _t872 else - if prediction439 == 7 - _t866 = parse_datetime_type(parser) - datetime_type447 = _t866 - _t867 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type447)) - _t865 = _t867 + if prediction443 == 7 + _t874 = parse_datetime_type(parser) + datetime_type451 = _t874 + _t875 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type451)) + _t873 = _t875 else - if prediction439 == 6 - _t869 = parse_date_type(parser) - date_type446 = _t869 - _t870 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type446)) - _t868 = _t870 + if prediction443 == 6 + _t877 = parse_date_type(parser) + date_type450 = _t877 + _t878 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type450)) + _t876 = _t878 else - if prediction439 == 5 - _t872 = parse_int128_type(parser) - int128_type445 = _t872 - _t873 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type445)) - _t871 = _t873 + if prediction443 == 5 + _t880 = parse_int128_type(parser) + int128_type449 = _t880 + _t881 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type449)) + _t879 = _t881 else - if prediction439 == 4 - _t875 = parse_uint128_type(parser) - uint128_type444 = _t875 - _t876 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type444)) - _t874 = _t876 + if prediction443 == 4 + _t883 = parse_uint128_type(parser) + uint128_type448 = _t883 + _t884 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type448)) + _t882 = _t884 else - if prediction439 == 3 - _t878 = parse_float_type(parser) - float_type443 = _t878 - _t879 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type443)) - _t877 = _t879 + if prediction443 == 3 + _t886 = parse_float_type(parser) + float_type447 = _t886 + _t887 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type447)) + _t885 = _t887 else - if prediction439 == 2 - _t881 = parse_int_type(parser) - int_type442 = _t881 - _t882 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type442)) - _t880 = _t882 + if prediction443 == 2 + _t889 = parse_int_type(parser) + int_type446 = _t889 + _t890 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type446)) + _t888 = _t890 else - if prediction439 == 1 - _t884 = parse_string_type(parser) - string_type441 = _t884 - _t885 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type441)) - _t883 = _t885 + if prediction443 == 1 + _t892 = parse_string_type(parser) + string_type445 = _t892 + _t893 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type445)) + _t891 = _t893 else - if prediction439 == 0 - _t887 = parse_unspecified_type(parser) - unspecified_type440 = _t887 - _t888 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type440)) - _t886 = _t888 + if prediction443 == 0 + _t895 = parse_unspecified_type(parser) + unspecified_type444 = _t895 + _t896 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type444)) + _t894 = _t896 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t883 = _t886 + _t891 = _t894 end - _t880 = _t883 + _t888 = _t891 end - _t877 = _t880 + _t885 = _t888 end - _t874 = _t877 + _t882 = _t885 end - _t871 = _t874 + _t879 = _t882 end - _t868 = _t871 + _t876 = _t879 end - _t865 = _t868 + _t873 = _t876 end - _t862 = _t865 + _t870 = _t873 end - _t859 = _t862 + _t867 = _t870 end - _t856 = _t859 + _t864 = _t867 end - return _t856 + return _t864 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType consume_literal!(parser, "UNKNOWN") - _t889 = Proto.UnspecifiedType() - return _t889 + _t897 = Proto.UnspecifiedType() + return _t897 end function parse_string_type(parser::ParserState)::Proto.StringType consume_literal!(parser, "STRING") - _t890 = Proto.StringType() - return _t890 + _t898 = Proto.StringType() + return _t898 end function parse_int_type(parser::ParserState)::Proto.IntType consume_literal!(parser, "INT") - _t891 = Proto.IntType() - return _t891 + _t899 = Proto.IntType() + return _t899 end function parse_float_type(parser::ParserState)::Proto.FloatType consume_literal!(parser, "FLOAT") - _t892 = Proto.FloatType() - return _t892 + _t900 = Proto.FloatType() + return _t900 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type consume_literal!(parser, "UINT128") - _t893 = Proto.UInt128Type() - return _t893 + _t901 = Proto.UInt128Type() + return _t901 end function parse_int128_type(parser::ParserState)::Proto.Int128Type consume_literal!(parser, "INT128") - _t894 = Proto.Int128Type() - return _t894 + _t902 = Proto.Int128Type() + return _t902 end function parse_date_type(parser::ParserState)::Proto.DateType consume_literal!(parser, "DATE") - _t895 = Proto.DateType() - return _t895 + _t903 = Proto.DateType() + return _t903 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType consume_literal!(parser, "DATETIME") - _t896 = Proto.DateTimeType() - return _t896 + _t904 = Proto.DateTimeType() + return _t904 end function parse_missing_type(parser::ParserState)::Proto.MissingType consume_literal!(parser, "MISSING") - _t897 = Proto.MissingType() - return _t897 + _t905 = Proto.MissingType() + return _t905 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int451 = consume_terminal!(parser, "INT") - int_3452 = consume_terminal!(parser, "INT") + int455 = consume_terminal!(parser, "INT") + int_3456 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t898 = Proto.DecimalType(precision=Int32(int451), scale=Int32(int_3452)) - return _t898 + _t906 = Proto.DecimalType(precision=Int32(int455), scale=Int32(int_3456)) + return _t906 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType consume_literal!(parser, "BOOLEAN") - _t899 = Proto.BooleanType() - return _t899 + _t907 = Proto.BooleanType() + return _t907 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs453 = Proto.Binding[] - cond454 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond454 - _t900 = parse_binding(parser) - item455 = _t900 - push!(xs453, item455) - cond454 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs457 = Proto.Binding[] + cond458 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond458 + _t908 = parse_binding(parser) + item459 = _t908 + push!(xs457, item459) + cond458 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings456 = xs453 - return bindings456 + bindings460 = xs457 + return bindings460 end function parse_formula(parser::ParserState)::Proto.Formula if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t902 = 0 + _t910 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t903 = 11 + _t911 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t904 = 3 + _t912 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t905 = 10 + _t913 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t906 = 9 + _t914 = 9 else if match_lookahead_literal(parser, "or", 1) - _t907 = 5 + _t915 = 5 else if match_lookahead_literal(parser, "not", 1) - _t908 = 6 + _t916 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t909 = 7 + _t917 = 7 else if match_lookahead_literal(parser, "false", 1) - _t910 = 1 + _t918 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t911 = 2 + _t919 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t912 = 12 + _t920 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t913 = 8 + _t921 = 8 else if match_lookahead_literal(parser, "and", 1) - _t914 = 4 + _t922 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t915 = 10 + _t923 = 10 else if match_lookahead_literal(parser, ">", 1) - _t916 = 10 + _t924 = 10 else if match_lookahead_literal(parser, "=", 1) - _t917 = 10 + _t925 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t918 = 10 + _t926 = 10 else if match_lookahead_literal(parser, "<", 1) - _t919 = 10 + _t927 = 10 else if match_lookahead_literal(parser, "/", 1) - _t920 = 10 + _t928 = 10 else if match_lookahead_literal(parser, "-", 1) - _t921 = 10 + _t929 = 10 else if match_lookahead_literal(parser, "+", 1) - _t922 = 10 + _t930 = 10 else if match_lookahead_literal(parser, "*", 1) - _t923 = 10 + _t931 = 10 else - _t923 = -1 + _t931 = -1 end - _t922 = _t923 + _t930 = _t931 end - _t921 = _t922 + _t929 = _t930 end - _t920 = _t921 + _t928 = _t929 end - _t919 = _t920 + _t927 = _t928 end - _t918 = _t919 + _t926 = _t927 end - _t917 = _t918 + _t925 = _t926 end - _t916 = _t917 + _t924 = _t925 end - _t915 = _t916 + _t923 = _t924 end - _t914 = _t915 + _t922 = _t923 end - _t913 = _t914 + _t921 = _t922 end - _t912 = _t913 + _t920 = _t921 end - _t911 = _t912 + _t919 = _t920 end - _t910 = _t911 + _t918 = _t919 end - _t909 = _t910 + _t917 = _t918 end - _t908 = _t909 + _t916 = _t917 end - _t907 = _t908 + _t915 = _t916 end - _t906 = _t907 + _t914 = _t915 end - _t905 = _t906 + _t913 = _t914 end - _t904 = _t905 + _t912 = _t913 end - _t903 = _t904 + _t911 = _t912 end - _t902 = _t903 + _t910 = _t911 end - _t901 = _t902 + _t909 = _t910 else - _t901 = -1 - end - prediction457 = _t901 - if prediction457 == 12 - _t925 = parse_cast(parser) - cast470 = _t925 - _t926 = Proto.Formula(formula_type=OneOf(:cast, cast470)) - _t924 = _t926 + _t909 = -1 + end + prediction461 = _t909 + if prediction461 == 12 + _t933 = parse_cast(parser) + cast474 = _t933 + _t934 = Proto.Formula(formula_type=OneOf(:cast, cast474)) + _t932 = _t934 else - if prediction457 == 11 - _t928 = parse_rel_atom(parser) - rel_atom469 = _t928 - _t929 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom469)) - _t927 = _t929 + if prediction461 == 11 + _t936 = parse_rel_atom(parser) + rel_atom473 = _t936 + _t937 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom473)) + _t935 = _t937 else - if prediction457 == 10 - _t931 = parse_primitive(parser) - primitive468 = _t931 - _t932 = Proto.Formula(formula_type=OneOf(:primitive, primitive468)) - _t930 = _t932 + if prediction461 == 10 + _t939 = parse_primitive(parser) + primitive472 = _t939 + _t940 = Proto.Formula(formula_type=OneOf(:primitive, primitive472)) + _t938 = _t940 else - if prediction457 == 9 - _t934 = parse_pragma(parser) - pragma467 = _t934 - _t935 = Proto.Formula(formula_type=OneOf(:pragma, pragma467)) - _t933 = _t935 + if prediction461 == 9 + _t942 = parse_pragma(parser) + pragma471 = _t942 + _t943 = Proto.Formula(formula_type=OneOf(:pragma, pragma471)) + _t941 = _t943 else - if prediction457 == 8 - _t937 = parse_atom(parser) - atom466 = _t937 - _t938 = Proto.Formula(formula_type=OneOf(:atom, atom466)) - _t936 = _t938 + if prediction461 == 8 + _t945 = parse_atom(parser) + atom470 = _t945 + _t946 = Proto.Formula(formula_type=OneOf(:atom, atom470)) + _t944 = _t946 else - if prediction457 == 7 - _t940 = parse_ffi(parser) - ffi465 = _t940 - _t941 = Proto.Formula(formula_type=OneOf(:ffi, ffi465)) - _t939 = _t941 + if prediction461 == 7 + _t948 = parse_ffi(parser) + ffi469 = _t948 + _t949 = Proto.Formula(formula_type=OneOf(:ffi, ffi469)) + _t947 = _t949 else - if prediction457 == 6 - _t943 = parse_not(parser) - not464 = _t943 - _t944 = Proto.Formula(formula_type=OneOf(:not, not464)) - _t942 = _t944 + if prediction461 == 6 + _t951 = parse_not(parser) + not468 = _t951 + _t952 = Proto.Formula(formula_type=OneOf(:not, not468)) + _t950 = _t952 else - if prediction457 == 5 - _t946 = parse_disjunction(parser) - disjunction463 = _t946 - _t947 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction463)) - _t945 = _t947 + if prediction461 == 5 + _t954 = parse_disjunction(parser) + disjunction467 = _t954 + _t955 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction467)) + _t953 = _t955 else - if prediction457 == 4 - _t949 = parse_conjunction(parser) - conjunction462 = _t949 - _t950 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction462)) - _t948 = _t950 + if prediction461 == 4 + _t957 = parse_conjunction(parser) + conjunction466 = _t957 + _t958 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction466)) + _t956 = _t958 else - if prediction457 == 3 - _t952 = parse_reduce(parser) - reduce461 = _t952 - _t953 = Proto.Formula(formula_type=OneOf(:reduce, reduce461)) - _t951 = _t953 + if prediction461 == 3 + _t960 = parse_reduce(parser) + reduce465 = _t960 + _t961 = Proto.Formula(formula_type=OneOf(:reduce, reduce465)) + _t959 = _t961 else - if prediction457 == 2 - _t955 = parse_exists(parser) - exists460 = _t955 - _t956 = Proto.Formula(formula_type=OneOf(:exists, exists460)) - _t954 = _t956 + if prediction461 == 2 + _t963 = parse_exists(parser) + exists464 = _t963 + _t964 = Proto.Formula(formula_type=OneOf(:exists, exists464)) + _t962 = _t964 else - if prediction457 == 1 - _t958 = parse_false(parser) - false459 = _t958 - _t959 = Proto.Formula(formula_type=OneOf(:disjunction, false459)) - _t957 = _t959 + if prediction461 == 1 + _t966 = parse_false(parser) + false463 = _t966 + _t967 = Proto.Formula(formula_type=OneOf(:disjunction, false463)) + _t965 = _t967 else - if prediction457 == 0 - _t961 = parse_true(parser) - true458 = _t961 - _t962 = Proto.Formula(formula_type=OneOf(:conjunction, true458)) - _t960 = _t962 + if prediction461 == 0 + _t969 = parse_true(parser) + true462 = _t969 + _t970 = Proto.Formula(formula_type=OneOf(:conjunction, true462)) + _t968 = _t970 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t957 = _t960 + _t965 = _t968 end - _t954 = _t957 + _t962 = _t965 end - _t951 = _t954 + _t959 = _t962 end - _t948 = _t951 + _t956 = _t959 end - _t945 = _t948 + _t953 = _t956 end - _t942 = _t945 + _t950 = _t953 end - _t939 = _t942 + _t947 = _t950 end - _t936 = _t939 + _t944 = _t947 end - _t933 = _t936 + _t941 = _t944 end - _t930 = _t933 + _t938 = _t941 end - _t927 = _t930 + _t935 = _t938 end - _t924 = _t927 + _t932 = _t935 end - return _t924 + return _t932 end function parse_true(parser::ParserState)::Proto.Conjunction consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t963 = Proto.Conjunction(args=Proto.Formula[]) - return _t963 + _t971 = Proto.Conjunction(args=Proto.Formula[]) + return _t971 end function parse_false(parser::ParserState)::Proto.Disjunction consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t964 = Proto.Disjunction(args=Proto.Formula[]) - return _t964 + _t972 = Proto.Disjunction(args=Proto.Formula[]) + return _t972 end function parse_exists(parser::ParserState)::Proto.Exists consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t965 = parse_bindings(parser) - bindings471 = _t965 - _t966 = parse_formula(parser) - formula472 = _t966 + _t973 = parse_bindings(parser) + bindings475 = _t973 + _t974 = parse_formula(parser) + formula476 = _t974 consume_literal!(parser, ")") - _t967 = Proto.Abstraction(vars=vcat(bindings471[1], !isnothing(bindings471[2]) ? bindings471[2] : []), value=formula472) - _t968 = Proto.Exists(body=_t967) - return _t968 + _t975 = Proto.Abstraction(vars=vcat(bindings475[1], !isnothing(bindings475[2]) ? bindings475[2] : []), value=formula476) + _t976 = Proto.Exists(body=_t975) + return _t976 end function parse_reduce(parser::ParserState)::Proto.Reduce consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t969 = parse_abstraction(parser) - abstraction473 = _t969 - _t970 = parse_abstraction(parser) - abstraction_3474 = _t970 - _t971 = parse_terms(parser) - terms475 = _t971 - consume_literal!(parser, ")") - _t972 = Proto.Reduce(op=abstraction473, body=abstraction_3474, terms=terms475) - return _t972 + _t977 = parse_abstraction(parser) + abstraction477 = _t977 + _t978 = parse_abstraction(parser) + abstraction_3478 = _t978 + _t979 = parse_terms(parser) + terms479 = _t979 + consume_literal!(parser, ")") + _t980 = Proto.Reduce(op=abstraction477, body=abstraction_3478, terms=terms479) + return _t980 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs476 = Proto.Term[] - cond477 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond477 - _t973 = parse_term(parser) - item478 = _t973 - push!(xs476, item478) - cond477 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + xs480 = Proto.Term[] + cond481 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond481 + _t981 = parse_term(parser) + item482 = _t981 + push!(xs480, item482) + cond481 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - terms479 = xs476 + terms483 = xs480 consume_literal!(parser, ")") - return terms479 + return terms483 end function parse_term(parser::ParserState)::Proto.Term if match_lookahead_literal(parser, "true", 0) - _t974 = 1 + _t982 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t975 = 1 + _t983 = 1 else if match_lookahead_literal(parser, "false", 0) - _t976 = 1 + _t984 = 1 else if match_lookahead_literal(parser, "(", 0) - _t977 = 1 + _t985 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t978 = 1 + _t986 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t979 = 0 + _t987 = 0 else if match_lookahead_terminal(parser, "STRING", 0) - _t980 = 1 + _t988 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t981 = 1 + _t989 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t982 = 1 + _t990 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t983 = 1 + _t991 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t984 = 1 + _t992 = 1 else - _t984 = -1 + _t992 = -1 end - _t983 = _t984 + _t991 = _t992 end - _t982 = _t983 + _t990 = _t991 end - _t981 = _t982 + _t989 = _t990 end - _t980 = _t981 + _t988 = _t989 end - _t979 = _t980 + _t987 = _t988 end - _t978 = _t979 + _t986 = _t987 end - _t977 = _t978 + _t985 = _t986 end - _t976 = _t977 + _t984 = _t985 end - _t975 = _t976 + _t983 = _t984 end - _t974 = _t975 - end - prediction480 = _t974 - if prediction480 == 1 - _t986 = parse_constant(parser) - constant482 = _t986 - _t987 = Proto.Term(term_type=OneOf(:constant, constant482)) - _t985 = _t987 + _t982 = _t983 + end + prediction484 = _t982 + if prediction484 == 1 + _t994 = parse_constant(parser) + constant486 = _t994 + _t995 = Proto.Term(term_type=OneOf(:constant, constant486)) + _t993 = _t995 else - if prediction480 == 0 - _t989 = parse_var(parser) - var481 = _t989 - _t990 = Proto.Term(term_type=OneOf(:var, var481)) - _t988 = _t990 + if prediction484 == 0 + _t997 = parse_var(parser) + var485 = _t997 + _t998 = Proto.Term(term_type=OneOf(:var, var485)) + _t996 = _t998 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t985 = _t988 + _t993 = _t996 end - return _t985 + return _t993 end function parse_var(parser::ParserState)::Proto.Var - symbol483 = consume_terminal!(parser, "SYMBOL") - _t991 = Proto.Var(name=symbol483) - return _t991 + symbol487 = consume_terminal!(parser, "SYMBOL") + _t999 = Proto.Var(name=symbol487) + return _t999 end function parse_constant(parser::ParserState)::Proto.Value - _t992 = parse_value(parser) - value484 = _t992 - return value484 + _t1000 = parse_value(parser) + value488 = _t1000 + return value488 end function parse_conjunction(parser::ParserState)::Proto.Conjunction consume_literal!(parser, "(") consume_literal!(parser, "and") - xs485 = Proto.Formula[] - cond486 = match_lookahead_literal(parser, "(", 0) - while cond486 - _t993 = parse_formula(parser) - item487 = _t993 - push!(xs485, item487) - cond486 = match_lookahead_literal(parser, "(", 0) + xs489 = Proto.Formula[] + cond490 = match_lookahead_literal(parser, "(", 0) + while cond490 + _t1001 = parse_formula(parser) + item491 = _t1001 + push!(xs489, item491) + cond490 = match_lookahead_literal(parser, "(", 0) end - formulas488 = xs485 + formulas492 = xs489 consume_literal!(parser, ")") - _t994 = Proto.Conjunction(args=formulas488) - return _t994 + _t1002 = Proto.Conjunction(args=formulas492) + return _t1002 end function parse_disjunction(parser::ParserState)::Proto.Disjunction consume_literal!(parser, "(") consume_literal!(parser, "or") - xs489 = Proto.Formula[] - cond490 = match_lookahead_literal(parser, "(", 0) - while cond490 - _t995 = parse_formula(parser) - item491 = _t995 - push!(xs489, item491) - cond490 = match_lookahead_literal(parser, "(", 0) + xs493 = Proto.Formula[] + cond494 = match_lookahead_literal(parser, "(", 0) + while cond494 + _t1003 = parse_formula(parser) + item495 = _t1003 + push!(xs493, item495) + cond494 = match_lookahead_literal(parser, "(", 0) end - formulas492 = xs489 + formulas496 = xs493 consume_literal!(parser, ")") - _t996 = Proto.Disjunction(args=formulas492) - return _t996 + _t1004 = Proto.Disjunction(args=formulas496) + return _t1004 end function parse_not(parser::ParserState)::Proto.Not consume_literal!(parser, "(") consume_literal!(parser, "not") - _t997 = parse_formula(parser) - formula493 = _t997 + _t1005 = parse_formula(parser) + formula497 = _t1005 consume_literal!(parser, ")") - _t998 = Proto.Not(arg=formula493) - return _t998 + _t1006 = Proto.Not(arg=formula497) + return _t1006 end function parse_ffi(parser::ParserState)::Proto.FFI consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t999 = parse_name(parser) - name494 = _t999 - _t1000 = parse_ffi_args(parser) - ffi_args495 = _t1000 - _t1001 = parse_terms(parser) - terms496 = _t1001 - consume_literal!(parser, ")") - _t1002 = Proto.FFI(name=name494, args=ffi_args495, terms=terms496) - return _t1002 + _t1007 = parse_name(parser) + name498 = _t1007 + _t1008 = parse_ffi_args(parser) + ffi_args499 = _t1008 + _t1009 = parse_terms(parser) + terms500 = _t1009 + consume_literal!(parser, ")") + _t1010 = Proto.FFI(name=name498, args=ffi_args499, terms=terms500) + return _t1010 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol497 = consume_terminal!(parser, "SYMBOL") - return symbol497 + symbol501 = consume_terminal!(parser, "SYMBOL") + return symbol501 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs498 = Proto.Abstraction[] - cond499 = match_lookahead_literal(parser, "(", 0) - while cond499 - _t1003 = parse_abstraction(parser) - item500 = _t1003 - push!(xs498, item500) - cond499 = match_lookahead_literal(parser, "(", 0) + xs502 = Proto.Abstraction[] + cond503 = match_lookahead_literal(parser, "(", 0) + while cond503 + _t1011 = parse_abstraction(parser) + item504 = _t1011 + push!(xs502, item504) + cond503 = match_lookahead_literal(parser, "(", 0) end - abstractions501 = xs498 + abstractions505 = xs502 consume_literal!(parser, ")") - return abstractions501 + return abstractions505 end function parse_atom(parser::ParserState)::Proto.Atom consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1004 = parse_relation_id(parser) - relation_id502 = _t1004 - xs503 = Proto.Term[] - cond504 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond504 - _t1005 = parse_term(parser) - item505 = _t1005 - push!(xs503, item505) - cond504 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - end - terms506 = xs503 - consume_literal!(parser, ")") - _t1006 = Proto.Atom(name=relation_id502, terms=terms506) - return _t1006 + _t1012 = parse_relation_id(parser) + relation_id506 = _t1012 + xs507 = Proto.Term[] + cond508 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond508 + _t1013 = parse_term(parser) + item509 = _t1013 + push!(xs507, item509) + cond508 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + end + terms510 = xs507 + consume_literal!(parser, ")") + _t1014 = Proto.Atom(name=relation_id506, terms=terms510) + return _t1014 end function parse_pragma(parser::ParserState)::Proto.Pragma consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1007 = parse_name(parser) - name507 = _t1007 - xs508 = Proto.Term[] - cond509 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond509 - _t1008 = parse_term(parser) - item510 = _t1008 - push!(xs508, item510) - cond509 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1015 = parse_name(parser) + name511 = _t1015 + xs512 = Proto.Term[] + cond513 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond513 + _t1016 = parse_term(parser) + item514 = _t1016 + push!(xs512, item514) + cond513 = ((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - terms511 = xs508 + terms515 = xs512 consume_literal!(parser, ")") - _t1009 = Proto.Pragma(name=name507, terms=terms511) - return _t1009 + _t1017 = Proto.Pragma(name=name511, terms=terms515) + return _t1017 end function parse_primitive(parser::ParserState)::Proto.Primitive if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1011 = 9 + _t1019 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1012 = 4 + _t1020 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1013 = 3 + _t1021 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1014 = 0 + _t1022 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1015 = 2 + _t1023 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1016 = 1 + _t1024 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1017 = 8 + _t1025 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1018 = 6 + _t1026 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1019 = 5 + _t1027 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1020 = 7 + _t1028 = 7 else - _t1020 = -1 + _t1028 = -1 end - _t1019 = _t1020 + _t1027 = _t1028 end - _t1018 = _t1019 + _t1026 = _t1027 end - _t1017 = _t1018 + _t1025 = _t1026 end - _t1016 = _t1017 + _t1024 = _t1025 end - _t1015 = _t1016 + _t1023 = _t1024 end - _t1014 = _t1015 + _t1022 = _t1023 end - _t1013 = _t1014 + _t1021 = _t1022 end - _t1012 = _t1013 + _t1020 = _t1021 end - _t1011 = _t1012 + _t1019 = _t1020 end - _t1010 = _t1011 + _t1018 = _t1019 else - _t1010 = -1 + _t1018 = -1 end - prediction512 = _t1010 - if prediction512 == 9 + prediction516 = _t1018 + if prediction516 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1022 = parse_name(parser) - name522 = _t1022 - xs523 = Proto.RelTerm[] - cond524 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond524 - _t1023 = parse_rel_term(parser) - item525 = _t1023 - push!(xs523, item525) - cond524 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1030 = parse_name(parser) + name526 = _t1030 + xs527 = Proto.RelTerm[] + cond528 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond528 + _t1031 = parse_rel_term(parser) + item529 = _t1031 + push!(xs527, item529) + cond528 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - rel_terms526 = xs523 + rel_terms530 = xs527 consume_literal!(parser, ")") - _t1024 = Proto.Primitive(name=name522, terms=rel_terms526) - _t1021 = _t1024 + _t1032 = Proto.Primitive(name=name526, terms=rel_terms530) + _t1029 = _t1032 else - if prediction512 == 8 - _t1026 = parse_divide(parser) - divide521 = _t1026 - _t1025 = divide521 + if prediction516 == 8 + _t1034 = parse_divide(parser) + divide525 = _t1034 + _t1033 = divide525 else - if prediction512 == 7 - _t1028 = parse_multiply(parser) - multiply520 = _t1028 - _t1027 = multiply520 + if prediction516 == 7 + _t1036 = parse_multiply(parser) + multiply524 = _t1036 + _t1035 = multiply524 else - if prediction512 == 6 - _t1030 = parse_minus(parser) - minus519 = _t1030 - _t1029 = minus519 + if prediction516 == 6 + _t1038 = parse_minus(parser) + minus523 = _t1038 + _t1037 = minus523 else - if prediction512 == 5 - _t1032 = parse_add(parser) - add518 = _t1032 - _t1031 = add518 + if prediction516 == 5 + _t1040 = parse_add(parser) + add522 = _t1040 + _t1039 = add522 else - if prediction512 == 4 - _t1034 = parse_gt_eq(parser) - gt_eq517 = _t1034 - _t1033 = gt_eq517 + if prediction516 == 4 + _t1042 = parse_gt_eq(parser) + gt_eq521 = _t1042 + _t1041 = gt_eq521 else - if prediction512 == 3 - _t1036 = parse_gt(parser) - gt516 = _t1036 - _t1035 = gt516 + if prediction516 == 3 + _t1044 = parse_gt(parser) + gt520 = _t1044 + _t1043 = gt520 else - if prediction512 == 2 - _t1038 = parse_lt_eq(parser) - lt_eq515 = _t1038 - _t1037 = lt_eq515 + if prediction516 == 2 + _t1046 = parse_lt_eq(parser) + lt_eq519 = _t1046 + _t1045 = lt_eq519 else - if prediction512 == 1 - _t1040 = parse_lt(parser) - lt514 = _t1040 - _t1039 = lt514 + if prediction516 == 1 + _t1048 = parse_lt(parser) + lt518 = _t1048 + _t1047 = lt518 else - if prediction512 == 0 - _t1042 = parse_eq(parser) - eq513 = _t1042 - _t1041 = eq513 + if prediction516 == 0 + _t1050 = parse_eq(parser) + eq517 = _t1050 + _t1049 = eq517 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1039 = _t1041 + _t1047 = _t1049 end - _t1037 = _t1039 + _t1045 = _t1047 end - _t1035 = _t1037 + _t1043 = _t1045 end - _t1033 = _t1035 + _t1041 = _t1043 end - _t1031 = _t1033 + _t1039 = _t1041 end - _t1029 = _t1031 + _t1037 = _t1039 end - _t1027 = _t1029 + _t1035 = _t1037 end - _t1025 = _t1027 + _t1033 = _t1035 end - _t1021 = _t1025 + _t1029 = _t1033 end - return _t1021 + return _t1029 end function parse_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1043 = parse_term(parser) - term527 = _t1043 - _t1044 = parse_term(parser) - term_3528 = _t1044 + _t1051 = parse_term(parser) + term531 = _t1051 + _t1052 = parse_term(parser) + term_3532 = _t1052 consume_literal!(parser, ")") - _t1045 = Proto.RelTerm(rel_term_type=OneOf(:term, term527)) - _t1046 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3528)) - _t1047 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1045, _t1046]) - return _t1047 + _t1053 = Proto.RelTerm(rel_term_type=OneOf(:term, term531)) + _t1054 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3532)) + _t1055 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1053, _t1054]) + return _t1055 end function parse_lt(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1048 = parse_term(parser) - term529 = _t1048 - _t1049 = parse_term(parser) - term_3530 = _t1049 + _t1056 = parse_term(parser) + term533 = _t1056 + _t1057 = parse_term(parser) + term_3534 = _t1057 consume_literal!(parser, ")") - _t1050 = Proto.RelTerm(rel_term_type=OneOf(:term, term529)) - _t1051 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3530)) - _t1052 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1050, _t1051]) - return _t1052 + _t1058 = Proto.RelTerm(rel_term_type=OneOf(:term, term533)) + _t1059 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3534)) + _t1060 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1058, _t1059]) + return _t1060 end function parse_lt_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1053 = parse_term(parser) - term531 = _t1053 - _t1054 = parse_term(parser) - term_3532 = _t1054 + _t1061 = parse_term(parser) + term535 = _t1061 + _t1062 = parse_term(parser) + term_3536 = _t1062 consume_literal!(parser, ")") - _t1055 = Proto.RelTerm(rel_term_type=OneOf(:term, term531)) - _t1056 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3532)) - _t1057 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1055, _t1056]) - return _t1057 + _t1063 = Proto.RelTerm(rel_term_type=OneOf(:term, term535)) + _t1064 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3536)) + _t1065 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1063, _t1064]) + return _t1065 end function parse_gt(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1058 = parse_term(parser) - term533 = _t1058 - _t1059 = parse_term(parser) - term_3534 = _t1059 + _t1066 = parse_term(parser) + term537 = _t1066 + _t1067 = parse_term(parser) + term_3538 = _t1067 consume_literal!(parser, ")") - _t1060 = Proto.RelTerm(rel_term_type=OneOf(:term, term533)) - _t1061 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3534)) - _t1062 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1060, _t1061]) - return _t1062 + _t1068 = Proto.RelTerm(rel_term_type=OneOf(:term, term537)) + _t1069 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538)) + _t1070 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1068, _t1069]) + return _t1070 end function parse_gt_eq(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1063 = parse_term(parser) - term535 = _t1063 - _t1064 = parse_term(parser) - term_3536 = _t1064 + _t1071 = parse_term(parser) + term539 = _t1071 + _t1072 = parse_term(parser) + term_3540 = _t1072 consume_literal!(parser, ")") - _t1065 = Proto.RelTerm(rel_term_type=OneOf(:term, term535)) - _t1066 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3536)) - _t1067 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1065, _t1066]) - return _t1067 + _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term539)) + _t1074 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3540)) + _t1075 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1073, _t1074]) + return _t1075 end function parse_add(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1068 = parse_term(parser) - term537 = _t1068 - _t1069 = parse_term(parser) - term_3538 = _t1069 - _t1070 = parse_term(parser) - term_4539 = _t1070 + _t1076 = parse_term(parser) + term541 = _t1076 + _t1077 = parse_term(parser) + term_3542 = _t1077 + _t1078 = parse_term(parser) + term_4543 = _t1078 consume_literal!(parser, ")") - _t1071 = Proto.RelTerm(rel_term_type=OneOf(:term, term537)) - _t1072 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538)) - _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4539)) - _t1074 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1071, _t1072, _t1073]) - return _t1074 + _t1079 = Proto.RelTerm(rel_term_type=OneOf(:term, term541)) + _t1080 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3542)) + _t1081 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4543)) + _t1082 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1079, _t1080, _t1081]) + return _t1082 end function parse_minus(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1075 = parse_term(parser) - term540 = _t1075 - _t1076 = parse_term(parser) - term_3541 = _t1076 - _t1077 = parse_term(parser) - term_4542 = _t1077 + _t1083 = parse_term(parser) + term544 = _t1083 + _t1084 = parse_term(parser) + term_3545 = _t1084 + _t1085 = parse_term(parser) + term_4546 = _t1085 consume_literal!(parser, ")") - _t1078 = Proto.RelTerm(rel_term_type=OneOf(:term, term540)) - _t1079 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3541)) - _t1080 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4542)) - _t1081 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1078, _t1079, _t1080]) - return _t1081 + _t1086 = Proto.RelTerm(rel_term_type=OneOf(:term, term544)) + _t1087 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3545)) + _t1088 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4546)) + _t1089 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1086, _t1087, _t1088]) + return _t1089 end function parse_multiply(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1082 = parse_term(parser) - term543 = _t1082 - _t1083 = parse_term(parser) - term_3544 = _t1083 - _t1084 = parse_term(parser) - term_4545 = _t1084 + _t1090 = parse_term(parser) + term547 = _t1090 + _t1091 = parse_term(parser) + term_3548 = _t1091 + _t1092 = parse_term(parser) + term_4549 = _t1092 consume_literal!(parser, ")") - _t1085 = Proto.RelTerm(rel_term_type=OneOf(:term, term543)) - _t1086 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3544)) - _t1087 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4545)) - _t1088 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1085, _t1086, _t1087]) - return _t1088 + _t1093 = Proto.RelTerm(rel_term_type=OneOf(:term, term547)) + _t1094 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3548)) + _t1095 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4549)) + _t1096 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1093, _t1094, _t1095]) + return _t1096 end function parse_divide(parser::ParserState)::Proto.Primitive consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1089 = parse_term(parser) - term546 = _t1089 - _t1090 = parse_term(parser) - term_3547 = _t1090 - _t1091 = parse_term(parser) - term_4548 = _t1091 + _t1097 = parse_term(parser) + term550 = _t1097 + _t1098 = parse_term(parser) + term_3551 = _t1098 + _t1099 = parse_term(parser) + term_4552 = _t1099 consume_literal!(parser, ")") - _t1092 = Proto.RelTerm(rel_term_type=OneOf(:term, term546)) - _t1093 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3547)) - _t1094 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4548)) - _t1095 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1092, _t1093, _t1094]) - return _t1095 + _t1100 = Proto.RelTerm(rel_term_type=OneOf(:term, term550)) + _t1101 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3551)) + _t1102 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4552)) + _t1103 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1100, _t1101, _t1102]) + return _t1103 end function parse_rel_term(parser::ParserState)::Proto.RelTerm if match_lookahead_literal(parser, "true", 0) - _t1096 = 1 + _t1104 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1097 = 1 + _t1105 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1098 = 1 + _t1106 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1099 = 1 + _t1107 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1100 = 0 + _t1108 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1101 = 1 + _t1109 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1102 = 1 + _t1110 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1103 = 1 + _t1111 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1104 = 1 + _t1112 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1105 = 1 + _t1113 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1106 = 1 + _t1114 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1107 = 1 + _t1115 = 1 else - _t1107 = -1 + _t1115 = -1 end - _t1106 = _t1107 + _t1114 = _t1115 end - _t1105 = _t1106 + _t1113 = _t1114 end - _t1104 = _t1105 + _t1112 = _t1113 end - _t1103 = _t1104 + _t1111 = _t1112 end - _t1102 = _t1103 + _t1110 = _t1111 end - _t1101 = _t1102 + _t1109 = _t1110 end - _t1100 = _t1101 + _t1108 = _t1109 end - _t1099 = _t1100 + _t1107 = _t1108 end - _t1098 = _t1099 + _t1106 = _t1107 end - _t1097 = _t1098 + _t1105 = _t1106 end - _t1096 = _t1097 - end - prediction549 = _t1096 - if prediction549 == 1 - _t1109 = parse_term(parser) - term551 = _t1109 - _t1110 = Proto.RelTerm(rel_term_type=OneOf(:term, term551)) - _t1108 = _t1110 + _t1104 = _t1105 + end + prediction553 = _t1104 + if prediction553 == 1 + _t1117 = parse_term(parser) + term555 = _t1117 + _t1118 = Proto.RelTerm(rel_term_type=OneOf(:term, term555)) + _t1116 = _t1118 else - if prediction549 == 0 - _t1112 = parse_specialized_value(parser) - specialized_value550 = _t1112 - _t1113 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value550)) - _t1111 = _t1113 + if prediction553 == 0 + _t1120 = parse_specialized_value(parser) + specialized_value554 = _t1120 + _t1121 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value554)) + _t1119 = _t1121 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1108 = _t1111 + _t1116 = _t1119 end - return _t1108 + return _t1116 end function parse_specialized_value(parser::ParserState)::Proto.Value consume_literal!(parser, "#") - _t1114 = parse_value(parser) - value552 = _t1114 - return value552 + _t1122 = parse_value(parser) + value556 = _t1122 + return value556 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1115 = parse_name(parser) - name553 = _t1115 - xs554 = Proto.RelTerm[] - cond555 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond555 - _t1116 = parse_rel_term(parser) - item556 = _t1116 - push!(xs554, item556) - cond555 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1123 = parse_name(parser) + name557 = _t1123 + xs558 = Proto.RelTerm[] + cond559 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond559 + _t1124 = parse_rel_term(parser) + item560 = _t1124 + push!(xs558, item560) + cond559 = (((((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - rel_terms557 = xs554 + rel_terms561 = xs558 consume_literal!(parser, ")") - _t1117 = Proto.RelAtom(name=name553, terms=rel_terms557) - return _t1117 + _t1125 = Proto.RelAtom(name=name557, terms=rel_terms561) + return _t1125 end function parse_cast(parser::ParserState)::Proto.Cast consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1118 = parse_term(parser) - term558 = _t1118 - _t1119 = parse_term(parser) - term_3559 = _t1119 + _t1126 = parse_term(parser) + term562 = _t1126 + _t1127 = parse_term(parser) + term_3563 = _t1127 consume_literal!(parser, ")") - _t1120 = Proto.Cast(input=term558, result=term_3559) - return _t1120 + _t1128 = Proto.Cast(input=term562, result=term_3563) + return _t1128 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs560 = Proto.Attribute[] - cond561 = match_lookahead_literal(parser, "(", 0) - while cond561 - _t1121 = parse_attribute(parser) - item562 = _t1121 - push!(xs560, item562) - cond561 = match_lookahead_literal(parser, "(", 0) + xs564 = Proto.Attribute[] + cond565 = match_lookahead_literal(parser, "(", 0) + while cond565 + _t1129 = parse_attribute(parser) + item566 = _t1129 + push!(xs564, item566) + cond565 = match_lookahead_literal(parser, "(", 0) end - attributes563 = xs560 + attributes567 = xs564 consume_literal!(parser, ")") - return attributes563 + return attributes567 end function parse_attribute(parser::ParserState)::Proto.Attribute consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1122 = parse_name(parser) - name564 = _t1122 - xs565 = Proto.Value[] - cond566 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond566 - _t1123 = parse_value(parser) - item567 = _t1123 - push!(xs565, item567) - cond566 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + _t1130 = parse_name(parser) + name568 = _t1130 + xs569 = Proto.Value[] + cond570 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond570 + _t1131 = parse_value(parser) + item571 = _t1131 + push!(xs569, item571) + cond570 = (((((((((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, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) end - values568 = xs565 + values572 = xs569 consume_literal!(parser, ")") - _t1124 = Proto.Attribute(name=name564, args=values568) - return _t1124 + _t1132 = Proto.Attribute(name=name568, args=values572) + return _t1132 end function parse_algorithm(parser::ParserState)::Proto.Algorithm consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs569 = Proto.RelationId[] - cond570 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond570 - _t1125 = parse_relation_id(parser) - item571 = _t1125 - push!(xs569, item571) - cond570 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs573 = Proto.RelationId[] + cond574 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond574 + _t1133 = parse_relation_id(parser) + item575 = _t1133 + push!(xs573, item575) + cond574 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids572 = xs569 - _t1126 = parse_script(parser) - script573 = _t1126 + relation_ids576 = xs573 + _t1134 = parse_script(parser) + script577 = _t1134 consume_literal!(parser, ")") - _t1127 = Proto.Algorithm(var"#global"=relation_ids572, body=script573) - return _t1127 + _t1135 = Proto.Algorithm(var"#global"=relation_ids576, body=script577) + return _t1135 end function parse_script(parser::ParserState)::Proto.Script consume_literal!(parser, "(") consume_literal!(parser, "script") - xs574 = Proto.Construct[] - cond575 = match_lookahead_literal(parser, "(", 0) - while cond575 - _t1128 = parse_construct(parser) - item576 = _t1128 - push!(xs574, item576) - cond575 = match_lookahead_literal(parser, "(", 0) + xs578 = Proto.Construct[] + cond579 = match_lookahead_literal(parser, "(", 0) + while cond579 + _t1136 = parse_construct(parser) + item580 = _t1136 + push!(xs578, item580) + cond579 = match_lookahead_literal(parser, "(", 0) end - constructs577 = xs574 + constructs581 = xs578 consume_literal!(parser, ")") - _t1129 = Proto.Script(constructs=constructs577) - return _t1129 + _t1137 = Proto.Script(constructs=constructs581) + return _t1137 end function parse_construct(parser::ParserState)::Proto.Construct if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1131 = 1 + _t1139 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1132 = 1 + _t1140 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1133 = 1 + _t1141 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1134 = 0 + _t1142 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1135 = 1 + _t1143 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1136 = 1 + _t1144 = 1 else - _t1136 = -1 + _t1144 = -1 end - _t1135 = _t1136 + _t1143 = _t1144 end - _t1134 = _t1135 + _t1142 = _t1143 end - _t1133 = _t1134 + _t1141 = _t1142 end - _t1132 = _t1133 + _t1140 = _t1141 end - _t1131 = _t1132 + _t1139 = _t1140 end - _t1130 = _t1131 + _t1138 = _t1139 else - _t1130 = -1 - end - prediction578 = _t1130 - if prediction578 == 1 - _t1138 = parse_instruction(parser) - instruction580 = _t1138 - _t1139 = Proto.Construct(construct_type=OneOf(:instruction, instruction580)) - _t1137 = _t1139 + _t1138 = -1 + end + prediction582 = _t1138 + if prediction582 == 1 + _t1146 = parse_instruction(parser) + instruction584 = _t1146 + _t1147 = Proto.Construct(construct_type=OneOf(:instruction, instruction584)) + _t1145 = _t1147 else - if prediction578 == 0 - _t1141 = parse_loop(parser) - loop579 = _t1141 - _t1142 = Proto.Construct(construct_type=OneOf(:loop, loop579)) - _t1140 = _t1142 + if prediction582 == 0 + _t1149 = parse_loop(parser) + loop583 = _t1149 + _t1150 = Proto.Construct(construct_type=OneOf(:loop, loop583)) + _t1148 = _t1150 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1137 = _t1140 + _t1145 = _t1148 end - return _t1137 + return _t1145 end function parse_loop(parser::ParserState)::Proto.Loop consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1143 = parse_init(parser) - init581 = _t1143 - _t1144 = parse_script(parser) - script582 = _t1144 + _t1151 = parse_init(parser) + init585 = _t1151 + _t1152 = parse_script(parser) + script586 = _t1152 consume_literal!(parser, ")") - _t1145 = Proto.Loop(init=init581, body=script582) - return _t1145 + _t1153 = Proto.Loop(init=init585, body=script586) + return _t1153 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs583 = Proto.Instruction[] - cond584 = match_lookahead_literal(parser, "(", 0) - while cond584 - _t1146 = parse_instruction(parser) - item585 = _t1146 - push!(xs583, item585) - cond584 = match_lookahead_literal(parser, "(", 0) + xs587 = Proto.Instruction[] + cond588 = match_lookahead_literal(parser, "(", 0) + while cond588 + _t1154 = parse_instruction(parser) + item589 = _t1154 + push!(xs587, item589) + cond588 = match_lookahead_literal(parser, "(", 0) end - instructions586 = xs583 + instructions590 = xs587 consume_literal!(parser, ")") - return instructions586 + return instructions590 end function parse_instruction(parser::ParserState)::Proto.Instruction if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1148 = 1 + _t1156 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1149 = 4 + _t1157 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1150 = 3 + _t1158 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1151 = 2 + _t1159 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1152 = 0 + _t1160 = 0 else - _t1152 = -1 + _t1160 = -1 end - _t1151 = _t1152 + _t1159 = _t1160 end - _t1150 = _t1151 + _t1158 = _t1159 end - _t1149 = _t1150 + _t1157 = _t1158 end - _t1148 = _t1149 + _t1156 = _t1157 end - _t1147 = _t1148 + _t1155 = _t1156 else - _t1147 = -1 - end - prediction587 = _t1147 - if prediction587 == 4 - _t1154 = parse_monus_def(parser) - monus_def592 = _t1154 - _t1155 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def592)) - _t1153 = _t1155 + _t1155 = -1 + end + prediction591 = _t1155 + if prediction591 == 4 + _t1162 = parse_monus_def(parser) + monus_def596 = _t1162 + _t1163 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def596)) + _t1161 = _t1163 else - if prediction587 == 3 - _t1157 = parse_monoid_def(parser) - monoid_def591 = _t1157 - _t1158 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def591)) - _t1156 = _t1158 + if prediction591 == 3 + _t1165 = parse_monoid_def(parser) + monoid_def595 = _t1165 + _t1166 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def595)) + _t1164 = _t1166 else - if prediction587 == 2 - _t1160 = parse_break(parser) - break590 = _t1160 - _t1161 = Proto.Instruction(instr_type=OneOf(:var"#break", break590)) - _t1159 = _t1161 + if prediction591 == 2 + _t1168 = parse_break(parser) + break594 = _t1168 + _t1169 = Proto.Instruction(instr_type=OneOf(:var"#break", break594)) + _t1167 = _t1169 else - if prediction587 == 1 - _t1163 = parse_upsert(parser) - upsert589 = _t1163 - _t1164 = Proto.Instruction(instr_type=OneOf(:upsert, upsert589)) - _t1162 = _t1164 + if prediction591 == 1 + _t1171 = parse_upsert(parser) + upsert593 = _t1171 + _t1172 = Proto.Instruction(instr_type=OneOf(:upsert, upsert593)) + _t1170 = _t1172 else - if prediction587 == 0 - _t1166 = parse_assign(parser) - assign588 = _t1166 - _t1167 = Proto.Instruction(instr_type=OneOf(:assign, assign588)) - _t1165 = _t1167 + if prediction591 == 0 + _t1174 = parse_assign(parser) + assign592 = _t1174 + _t1175 = Proto.Instruction(instr_type=OneOf(:assign, assign592)) + _t1173 = _t1175 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1162 = _t1165 + _t1170 = _t1173 end - _t1159 = _t1162 + _t1167 = _t1170 end - _t1156 = _t1159 + _t1164 = _t1167 end - _t1153 = _t1156 + _t1161 = _t1164 end - return _t1153 + return _t1161 end function parse_assign(parser::ParserState)::Proto.Assign consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1168 = parse_relation_id(parser) - relation_id593 = _t1168 - _t1169 = parse_abstraction(parser) - abstraction594 = _t1169 + _t1176 = parse_relation_id(parser) + relation_id597 = _t1176 + _t1177 = parse_abstraction(parser) + abstraction598 = _t1177 if match_lookahead_literal(parser, "(", 0) - _t1171 = parse_attrs(parser) - _t1170 = _t1171 + _t1179 = parse_attrs(parser) + _t1178 = _t1179 else - _t1170 = nothing + _t1178 = nothing end - attrs595 = _t1170 + attrs599 = _t1178 consume_literal!(parser, ")") - _t1172 = Proto.Assign(name=relation_id593, body=abstraction594, attrs=(!isnothing(attrs595) ? attrs595 : Proto.Attribute[])) - return _t1172 + _t1180 = Proto.Assign(name=relation_id597, body=abstraction598, attrs=(!isnothing(attrs599) ? attrs599 : Proto.Attribute[])) + return _t1180 end function parse_upsert(parser::ParserState)::Proto.Upsert consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1173 = parse_relation_id(parser) - relation_id596 = _t1173 - _t1174 = parse_abstraction_with_arity(parser) - abstraction_with_arity597 = _t1174 + _t1181 = parse_relation_id(parser) + relation_id600 = _t1181 + _t1182 = parse_abstraction_with_arity(parser) + abstraction_with_arity601 = _t1182 if match_lookahead_literal(parser, "(", 0) - _t1176 = parse_attrs(parser) - _t1175 = _t1176 + _t1184 = parse_attrs(parser) + _t1183 = _t1184 else - _t1175 = nothing + _t1183 = nothing end - attrs598 = _t1175 + attrs602 = _t1183 consume_literal!(parser, ")") - _t1177 = Proto.Upsert(name=relation_id596, body=abstraction_with_arity597[1], attrs=(!isnothing(attrs598) ? attrs598 : Proto.Attribute[]), value_arity=abstraction_with_arity597[2]) - return _t1177 + _t1185 = Proto.Upsert(name=relation_id600, body=abstraction_with_arity601[1], attrs=(!isnothing(attrs602) ? attrs602 : Proto.Attribute[]), value_arity=abstraction_with_arity601[2]) + return _t1185 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1178 = parse_bindings(parser) - bindings599 = _t1178 - _t1179 = parse_formula(parser) - formula600 = _t1179 + _t1186 = parse_bindings(parser) + bindings603 = _t1186 + _t1187 = parse_formula(parser) + formula604 = _t1187 consume_literal!(parser, ")") - _t1180 = Proto.Abstraction(vars=vcat(bindings599[1], !isnothing(bindings599[2]) ? bindings599[2] : []), value=formula600) - return (_t1180, length(bindings599[2]),) + _t1188 = Proto.Abstraction(vars=vcat(bindings603[1], !isnothing(bindings603[2]) ? bindings603[2] : []), value=formula604) + return (_t1188, length(bindings603[2]),) end function parse_break(parser::ParserState)::Proto.Break consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1181 = parse_relation_id(parser) - relation_id601 = _t1181 - _t1182 = parse_abstraction(parser) - abstraction602 = _t1182 + _t1189 = parse_relation_id(parser) + relation_id605 = _t1189 + _t1190 = parse_abstraction(parser) + abstraction606 = _t1190 if match_lookahead_literal(parser, "(", 0) - _t1184 = parse_attrs(parser) - _t1183 = _t1184 + _t1192 = parse_attrs(parser) + _t1191 = _t1192 else - _t1183 = nothing + _t1191 = nothing end - attrs603 = _t1183 + attrs607 = _t1191 consume_literal!(parser, ")") - _t1185 = Proto.Break(name=relation_id601, body=abstraction602, attrs=(!isnothing(attrs603) ? attrs603 : Proto.Attribute[])) - return _t1185 + _t1193 = Proto.Break(name=relation_id605, body=abstraction606, attrs=(!isnothing(attrs607) ? attrs607 : Proto.Attribute[])) + return _t1193 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1186 = parse_monoid(parser) - monoid604 = _t1186 - _t1187 = parse_relation_id(parser) - relation_id605 = _t1187 - _t1188 = parse_abstraction_with_arity(parser) - abstraction_with_arity606 = _t1188 + _t1194 = parse_monoid(parser) + monoid608 = _t1194 + _t1195 = parse_relation_id(parser) + relation_id609 = _t1195 + _t1196 = parse_abstraction_with_arity(parser) + abstraction_with_arity610 = _t1196 if match_lookahead_literal(parser, "(", 0) - _t1190 = parse_attrs(parser) - _t1189 = _t1190 + _t1198 = parse_attrs(parser) + _t1197 = _t1198 else - _t1189 = nothing + _t1197 = nothing end - attrs607 = _t1189 + attrs611 = _t1197 consume_literal!(parser, ")") - _t1191 = Proto.MonoidDef(monoid=monoid604, name=relation_id605, body=abstraction_with_arity606[1], attrs=(!isnothing(attrs607) ? attrs607 : Proto.Attribute[]), value_arity=abstraction_with_arity606[2]) - return _t1191 + _t1199 = Proto.MonoidDef(monoid=monoid608, name=relation_id609, body=abstraction_with_arity610[1], attrs=(!isnothing(attrs611) ? attrs611 : Proto.Attribute[]), value_arity=abstraction_with_arity610[2]) + return _t1199 end function parse_monoid(parser::ParserState)::Proto.Monoid if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1193 = 3 + _t1201 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1194 = 0 + _t1202 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1195 = 1 + _t1203 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1196 = 2 + _t1204 = 2 else - _t1196 = -1 + _t1204 = -1 end - _t1195 = _t1196 + _t1203 = _t1204 end - _t1194 = _t1195 + _t1202 = _t1203 end - _t1193 = _t1194 + _t1201 = _t1202 end - _t1192 = _t1193 + _t1200 = _t1201 else - _t1192 = -1 - end - prediction608 = _t1192 - if prediction608 == 3 - _t1198 = parse_sum_monoid(parser) - sum_monoid612 = _t1198 - _t1199 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid612)) - _t1197 = _t1199 + _t1200 = -1 + end + prediction612 = _t1200 + if prediction612 == 3 + _t1206 = parse_sum_monoid(parser) + sum_monoid616 = _t1206 + _t1207 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid616)) + _t1205 = _t1207 else - if prediction608 == 2 - _t1201 = parse_max_monoid(parser) - max_monoid611 = _t1201 - _t1202 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid611)) - _t1200 = _t1202 + if prediction612 == 2 + _t1209 = parse_max_monoid(parser) + max_monoid615 = _t1209 + _t1210 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid615)) + _t1208 = _t1210 else - if prediction608 == 1 - _t1204 = parse_min_monoid(parser) - min_monoid610 = _t1204 - _t1205 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid610)) - _t1203 = _t1205 + if prediction612 == 1 + _t1212 = parse_min_monoid(parser) + min_monoid614 = _t1212 + _t1213 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid614)) + _t1211 = _t1213 else - if prediction608 == 0 - _t1207 = parse_or_monoid(parser) - or_monoid609 = _t1207 - _t1208 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid609)) - _t1206 = _t1208 + if prediction612 == 0 + _t1215 = parse_or_monoid(parser) + or_monoid613 = _t1215 + _t1216 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid613)) + _t1214 = _t1216 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1203 = _t1206 + _t1211 = _t1214 end - _t1200 = _t1203 + _t1208 = _t1211 end - _t1197 = _t1200 + _t1205 = _t1208 end - return _t1197 + return _t1205 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1209 = Proto.OrMonoid() - return _t1209 + _t1217 = Proto.OrMonoid() + return _t1217 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1210 = parse_type(parser) - type613 = _t1210 + _t1218 = parse_type(parser) + type617 = _t1218 consume_literal!(parser, ")") - _t1211 = Proto.MinMonoid(var"#type"=type613) - return _t1211 + _t1219 = Proto.MinMonoid(var"#type"=type617) + return _t1219 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1212 = parse_type(parser) - type614 = _t1212 + _t1220 = parse_type(parser) + type618 = _t1220 consume_literal!(parser, ")") - _t1213 = Proto.MaxMonoid(var"#type"=type614) - return _t1213 + _t1221 = Proto.MaxMonoid(var"#type"=type618) + return _t1221 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1214 = parse_type(parser) - type615 = _t1214 + _t1222 = parse_type(parser) + type619 = _t1222 consume_literal!(parser, ")") - _t1215 = Proto.SumMonoid(var"#type"=type615) - return _t1215 + _t1223 = Proto.SumMonoid(var"#type"=type619) + return _t1223 end function parse_monus_def(parser::ParserState)::Proto.MonusDef consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1216 = parse_monoid(parser) - monoid616 = _t1216 - _t1217 = parse_relation_id(parser) - relation_id617 = _t1217 - _t1218 = parse_abstraction_with_arity(parser) - abstraction_with_arity618 = _t1218 + _t1224 = parse_monoid(parser) + monoid620 = _t1224 + _t1225 = parse_relation_id(parser) + relation_id621 = _t1225 + _t1226 = parse_abstraction_with_arity(parser) + abstraction_with_arity622 = _t1226 if match_lookahead_literal(parser, "(", 0) - _t1220 = parse_attrs(parser) - _t1219 = _t1220 + _t1228 = parse_attrs(parser) + _t1227 = _t1228 else - _t1219 = nothing + _t1227 = nothing end - attrs619 = _t1219 + attrs623 = _t1227 consume_literal!(parser, ")") - _t1221 = Proto.MonusDef(monoid=monoid616, name=relation_id617, body=abstraction_with_arity618[1], attrs=(!isnothing(attrs619) ? attrs619 : Proto.Attribute[]), value_arity=abstraction_with_arity618[2]) - return _t1221 + _t1229 = Proto.MonusDef(monoid=monoid620, name=relation_id621, body=abstraction_with_arity622[1], attrs=(!isnothing(attrs623) ? attrs623 : Proto.Attribute[]), value_arity=abstraction_with_arity622[2]) + return _t1229 end function parse_constraint(parser::ParserState)::Proto.Constraint consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1222 = parse_relation_id(parser) - relation_id620 = _t1222 - _t1223 = parse_abstraction(parser) - abstraction621 = _t1223 - _t1224 = parse_functional_dependency_keys(parser) - functional_dependency_keys622 = _t1224 - _t1225 = parse_functional_dependency_values(parser) - functional_dependency_values623 = _t1225 + _t1230 = parse_relation_id(parser) + relation_id624 = _t1230 + _t1231 = parse_abstraction(parser) + abstraction625 = _t1231 + _t1232 = parse_functional_dependency_keys(parser) + functional_dependency_keys626 = _t1232 + _t1233 = parse_functional_dependency_values(parser) + functional_dependency_values627 = _t1233 consume_literal!(parser, ")") - _t1226 = Proto.FunctionalDependency(guard=abstraction621, keys=functional_dependency_keys622, values=functional_dependency_values623) - _t1227 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1226), name=relation_id620) - return _t1227 + _t1234 = Proto.FunctionalDependency(guard=abstraction625, keys=functional_dependency_keys626, values=functional_dependency_values627) + _t1235 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1234), name=relation_id624) + return _t1235 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs624 = Proto.Var[] - cond625 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond625 - _t1228 = parse_var(parser) - item626 = _t1228 - push!(xs624, item626) - cond625 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars627 = xs624 - consume_literal!(parser, ")") - return vars627 -end - -function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} - consume_literal!(parser, "(") - consume_literal!(parser, "values") xs628 = Proto.Var[] cond629 = match_lookahead_terminal(parser, "SYMBOL", 0) while cond629 - _t1229 = parse_var(parser) - item630 = _t1229 + _t1236 = parse_var(parser) + item630 = _t1236 push!(xs628, item630) cond629 = match_lookahead_terminal(parser, "SYMBOL", 0) end @@ -2684,148 +2668,148 @@ function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.V return vars631 end +function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} + consume_literal!(parser, "(") + consume_literal!(parser, "values") + xs632 = Proto.Var[] + cond633 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond633 + _t1237 = parse_var(parser) + item634 = _t1237 + push!(xs632, item634) + cond633 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars635 = xs632 + consume_literal!(parser, ")") + return vars635 +end + function parse_data(parser::ParserState)::Proto.Data if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "edb", 1) - _t1231 = 0 + _t1239 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1232 = 2 + _t1240 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1233 = 1 + _t1241 = 1 else - _t1233 = -1 + _t1241 = -1 end - _t1232 = _t1233 + _t1240 = _t1241 end - _t1231 = _t1232 + _t1239 = _t1240 end - _t1230 = _t1231 + _t1238 = _t1239 else - _t1230 = -1 - end - prediction632 = _t1230 - if prediction632 == 2 - _t1235 = parse_csv_data(parser) - csv_data635 = _t1235 - _t1236 = Proto.Data(data_type=OneOf(:csv_data, csv_data635)) - _t1234 = _t1236 + _t1238 = -1 + end + prediction636 = _t1238 + if prediction636 == 2 + _t1243 = parse_csv_data(parser) + csv_data639 = _t1243 + _t1244 = Proto.Data(data_type=OneOf(:csv_data, csv_data639)) + _t1242 = _t1244 else - if prediction632 == 1 - _t1238 = parse_betree_relation(parser) - betree_relation634 = _t1238 - _t1239 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation634)) - _t1237 = _t1239 + if prediction636 == 1 + _t1246 = parse_betree_relation(parser) + betree_relation638 = _t1246 + _t1247 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation638)) + _t1245 = _t1247 else - if prediction632 == 0 - _t1241 = parse_edb(parser) - edb633 = _t1241 - _t1242 = Proto.Data(data_type=OneOf(:edb, edb633)) - _t1240 = _t1242 + if prediction636 == 0 + _t1249 = parse_edb(parser) + edb637 = _t1249 + _t1250 = Proto.Data(data_type=OneOf(:edb, edb637)) + _t1248 = _t1250 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1237 = _t1240 + _t1245 = _t1248 end - _t1234 = _t1237 + _t1242 = _t1245 end - return _t1234 + return _t1242 end function parse_edb(parser::ParserState)::Proto.EDB consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t1243 = parse_relation_id(parser) - relation_id636 = _t1243 - _t1244 = parse_edb_path(parser) - edb_path637 = _t1244 - _t1245 = parse_edb_types(parser) - edb_types638 = _t1245 - consume_literal!(parser, ")") - _t1246 = Proto.EDB(target_id=relation_id636, path=edb_path637, types=edb_types638) - return _t1246 + _t1251 = parse_relation_id(parser) + relation_id640 = _t1251 + _t1252 = parse_edb_path(parser) + edb_path641 = _t1252 + _t1253 = parse_edb_types(parser) + edb_types642 = _t1253 + consume_literal!(parser, ")") + _t1254 = Proto.EDB(target_id=relation_id640, path=edb_path641, types=edb_types642) + return _t1254 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs639 = String[] - cond640 = match_lookahead_terminal(parser, "STRING", 0) - while cond640 - item641 = consume_terminal!(parser, "STRING") - push!(xs639, item641) - cond640 = match_lookahead_terminal(parser, "STRING", 0) - end - strings642 = xs639 + xs643 = String[] + cond644 = match_lookahead_terminal(parser, "STRING", 0) + while cond644 + item645 = consume_terminal!(parser, "STRING") + push!(xs643, item645) + cond644 = match_lookahead_terminal(parser, "STRING", 0) + end + strings646 = xs643 consume_literal!(parser, "]") - return strings642 + return strings646 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs643 = Proto.var"#Type"[] - cond644 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond644 - _t1247 = parse_type(parser) - item645 = _t1247 - push!(xs643, item645) - cond644 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs647 = Proto.var"#Type"[] + cond648 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond648 + _t1255 = parse_type(parser) + item649 = _t1255 + push!(xs647, item649) + cond648 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types646 = xs643 + types650 = xs647 consume_literal!(parser, "]") - return types646 + return types650 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1248 = parse_relation_id(parser) - relation_id647 = _t1248 - _t1249 = parse_betree_info(parser) - betree_info648 = _t1249 + _t1256 = parse_relation_id(parser) + relation_id651 = _t1256 + _t1257 = parse_betree_info(parser) + betree_info652 = _t1257 consume_literal!(parser, ")") - _t1250 = Proto.BeTreeRelation(name=relation_id647, relation_info=betree_info648) - return _t1250 + _t1258 = Proto.BeTreeRelation(name=relation_id651, relation_info=betree_info652) + return _t1258 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1251 = parse_betree_info_key_types(parser) - betree_info_key_types649 = _t1251 - _t1252 = parse_betree_info_value_types(parser) - betree_info_value_types650 = _t1252 - _t1253 = parse_config_dict(parser) - config_dict651 = _t1253 - consume_literal!(parser, ")") - _t1254 = construct_betree_info(parser, betree_info_key_types649, betree_info_value_types650, config_dict651) - return _t1254 + _t1259 = parse_betree_info_key_types(parser) + betree_info_key_types653 = _t1259 + _t1260 = parse_betree_info_value_types(parser) + betree_info_value_types654 = _t1260 + _t1261 = parse_config_dict(parser) + config_dict655 = _t1261 + consume_literal!(parser, ")") + _t1262 = construct_betree_info(parser, betree_info_key_types653, betree_info_value_types654, config_dict655) + return _t1262 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs652 = Proto.var"#Type"[] - cond653 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond653 - _t1255 = parse_type(parser) - item654 = _t1255 - push!(xs652, item654) - cond653 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types655 = xs652 - consume_literal!(parser, ")") - return types655 -end - -function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} - consume_literal!(parser, "(") - consume_literal!(parser, "value_types") xs656 = Proto.var"#Type"[] cond657 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) while cond657 - _t1256 = parse_type(parser) - item658 = _t1256 + _t1263 = parse_type(parser) + item658 = _t1263 push!(xs656, item658) cond657 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end @@ -2834,403 +2818,433 @@ function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#T return types659 end +function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} + consume_literal!(parser, "(") + consume_literal!(parser, "value_types") + xs660 = Proto.var"#Type"[] + cond661 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond661 + _t1264 = parse_type(parser) + item662 = _t1264 + push!(xs660, item662) + cond661 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types663 = xs660 + consume_literal!(parser, ")") + return types663 +end + function parse_csv_data(parser::ParserState)::Proto.CSVData consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1257 = parse_csvlocator(parser) - csvlocator660 = _t1257 - _t1258 = parse_csv_config(parser) - csv_config661 = _t1258 - _t1259 = parse_gnf_columns(parser) - gnf_columns662 = _t1259 - _t1260 = parse_csv_asof(parser) - csv_asof663 = _t1260 + _t1265 = parse_csvlocator(parser) + csvlocator664 = _t1265 + _t1266 = parse_csv_config(parser) + csv_config665 = _t1266 + _t1267 = parse_gnf_columns(parser) + gnf_columns666 = _t1267 + _t1268 = parse_csv_asof(parser) + csv_asof667 = _t1268 consume_literal!(parser, ")") - _t1261 = Proto.CSVData(locator=csvlocator660, config=csv_config661, columns=gnf_columns662, asof=csv_asof663) - return _t1261 + _t1269 = Proto.CSVData(locator=csvlocator664, config=csv_config665, columns=gnf_columns666, asof=csv_asof667) + return _t1269 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1263 = parse_csv_locator_paths(parser) - _t1262 = _t1263 + _t1271 = parse_csv_locator_paths(parser) + _t1270 = _t1271 else - _t1262 = nothing + _t1270 = nothing end - csv_locator_paths664 = _t1262 + csv_locator_paths668 = _t1270 if match_lookahead_literal(parser, "(", 0) - _t1265 = parse_csv_locator_inline_data(parser) - _t1264 = _t1265 + _t1273 = parse_csv_locator_inline_data(parser) + _t1272 = _t1273 else - _t1264 = nothing + _t1272 = nothing end - csv_locator_inline_data665 = _t1264 + csv_locator_inline_data669 = _t1272 consume_literal!(parser, ")") - _t1266 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths664) ? csv_locator_paths664 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data665) ? csv_locator_inline_data665 : ""))) - return _t1266 + _t1274 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths668) ? csv_locator_paths668 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data669) ? csv_locator_inline_data669 : ""))) + return _t1274 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs666 = String[] - cond667 = match_lookahead_terminal(parser, "STRING", 0) - while cond667 - item668 = consume_terminal!(parser, "STRING") - push!(xs666, item668) - cond667 = match_lookahead_terminal(parser, "STRING", 0) + xs670 = String[] + cond671 = match_lookahead_terminal(parser, "STRING", 0) + while cond671 + item672 = consume_terminal!(parser, "STRING") + push!(xs670, item672) + cond671 = match_lookahead_terminal(parser, "STRING", 0) end - strings669 = xs666 + strings673 = xs670 consume_literal!(parser, ")") - return strings669 + return strings673 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - string670 = consume_terminal!(parser, "STRING") + string674 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string670 + return string674 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1267 = parse_config_dict(parser) - config_dict671 = _t1267 + _t1275 = parse_config_dict(parser) + config_dict675 = _t1275 consume_literal!(parser, ")") - _t1268 = construct_csv_config(parser, config_dict671) - return _t1268 + _t1276 = construct_csv_config(parser, config_dict675) + return _t1276 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs672 = Proto.GNFColumn[] - cond673 = match_lookahead_literal(parser, "(", 0) - while cond673 - _t1269 = parse_gnf_column(parser) - item674 = _t1269 - push!(xs672, item674) - cond673 = match_lookahead_literal(parser, "(", 0) + xs676 = Proto.GNFColumn[] + cond677 = match_lookahead_literal(parser, "(", 0) + while cond677 + _t1277 = parse_gnf_column(parser) + item678 = _t1277 + push!(xs676, item678) + cond677 = match_lookahead_literal(parser, "(", 0) end - gnf_columns675 = xs672 + gnf_columns679 = xs676 consume_literal!(parser, ")") - return gnf_columns675 + return gnf_columns679 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn consume_literal!(parser, "(") consume_literal!(parser, "column") - _t1270 = parse_gnf_column_path(parser) - gnf_column_path676 = _t1270 + _t1278 = parse_gnf_column_path(parser) + gnf_column_path680 = _t1278 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t1272 = parse_relation_id(parser) - _t1271 = _t1272 + _t1280 = parse_relation_id(parser) + _t1279 = _t1280 else - _t1271 = nothing + _t1279 = nothing end - relation_id677 = _t1271 + relation_id681 = _t1279 consume_literal!(parser, "[") - xs678 = Proto.var"#Type"[] - cond679 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond679 - _t1273 = parse_type(parser) - item680 = _t1273 - push!(xs678, item680) - cond679 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types681 = xs678 + xs682 = Proto.var"#Type"[] + cond683 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond683 + _t1281 = parse_type(parser) + item684 = _t1281 + push!(xs682, item684) + cond683 = ((((((((((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, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types685 = xs682 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t1274 = Proto.GNFColumn(column_path=gnf_column_path676, target_id=relation_id677, types=types681) - return _t1274 + _t1282 = Proto.GNFColumn(column_path=gnf_column_path680, target_id=relation_id681, types=types685) + return _t1282 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t1275 = 1 + _t1283 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1276 = 0 + _t1284 = 0 else - _t1276 = -1 + _t1284 = -1 end - _t1275 = _t1276 + _t1283 = _t1284 end - prediction682 = _t1275 - if prediction682 == 1 + prediction686 = _t1283 + if prediction686 == 1 consume_literal!(parser, "[") - xs684 = String[] - cond685 = match_lookahead_terminal(parser, "STRING", 0) - while cond685 - item686 = consume_terminal!(parser, "STRING") - push!(xs684, item686) - cond685 = match_lookahead_terminal(parser, "STRING", 0) + xs688 = String[] + cond689 = match_lookahead_terminal(parser, "STRING", 0) + while cond689 + item690 = consume_terminal!(parser, "STRING") + push!(xs688, item690) + cond689 = match_lookahead_terminal(parser, "STRING", 0) end - strings687 = xs684 + strings691 = xs688 consume_literal!(parser, "]") - _t1277 = strings687 + _t1285 = strings691 else - if prediction682 == 0 - string683 = consume_terminal!(parser, "STRING") - _t1278 = String[string683] + if prediction686 == 0 + string687 = consume_terminal!(parser, "STRING") + _t1286 = String[string687] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t1277 = _t1278 + _t1285 = _t1286 end - return _t1277 + return _t1285 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string688 = consume_terminal!(parser, "STRING") + string692 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string688 + return string692 end function parse_undefine(parser::ParserState)::Proto.Undefine consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t1279 = parse_fragment_id(parser) - fragment_id689 = _t1279 + _t1287 = parse_fragment_id(parser) + fragment_id693 = _t1287 consume_literal!(parser, ")") - _t1280 = Proto.Undefine(fragment_id=fragment_id689) - return _t1280 + _t1288 = Proto.Undefine(fragment_id=fragment_id693) + return _t1288 end function parse_context(parser::ParserState)::Proto.Context consume_literal!(parser, "(") consume_literal!(parser, "context") - xs690 = Proto.RelationId[] - cond691 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond691 - _t1281 = parse_relation_id(parser) - item692 = _t1281 - push!(xs690, item692) - cond691 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs694 = Proto.RelationId[] + cond695 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond695 + _t1289 = parse_relation_id(parser) + item696 = _t1289 + push!(xs694, item696) + cond695 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids693 = xs690 + relation_ids697 = xs694 consume_literal!(parser, ")") - _t1282 = Proto.Context(relations=relation_ids693) - return _t1282 + _t1290 = Proto.Context(relations=relation_ids697) + return _t1290 end function parse_snapshot(parser::ParserState)::Proto.Snapshot consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t1283 = parse_edb_path(parser) - edb_path694 = _t1283 - _t1284 = parse_relation_id(parser) - relation_id695 = _t1284 + xs698 = Proto.SnapshotMapping[] + cond699 = match_lookahead_literal(parser, "[", 0) + while cond699 + _t1291 = parse_snapshot_mapping(parser) + item700 = _t1291 + push!(xs698, item700) + cond699 = match_lookahead_literal(parser, "[", 0) + end + snapshot_mappings701 = xs698 consume_literal!(parser, ")") - _t1285 = Proto.Snapshot(destination_path=edb_path694, source_relation=relation_id695) - return _t1285 + _t1292 = Proto.Snapshot(mappings=snapshot_mappings701) + return _t1292 +end + +function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping + _t1293 = parse_edb_path(parser) + edb_path702 = _t1293 + _t1294 = parse_relation_id(parser) + relation_id703 = _t1294 + _t1295 = Proto.SnapshotMapping(destination_path=edb_path702, source_relation=relation_id703) + return _t1295 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs696 = Proto.Read[] - cond697 = match_lookahead_literal(parser, "(", 0) - while cond697 - _t1286 = parse_read(parser) - item698 = _t1286 - push!(xs696, item698) - cond697 = match_lookahead_literal(parser, "(", 0) + xs704 = Proto.Read[] + cond705 = match_lookahead_literal(parser, "(", 0) + while cond705 + _t1296 = parse_read(parser) + item706 = _t1296 + push!(xs704, item706) + cond705 = match_lookahead_literal(parser, "(", 0) end - reads699 = xs696 + reads707 = xs704 consume_literal!(parser, ")") - return reads699 + return reads707 end function parse_read(parser::ParserState)::Proto.Read if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t1288 = 2 + _t1298 = 2 else if match_lookahead_literal(parser, "output", 1) - _t1289 = 1 + _t1299 = 1 else if match_lookahead_literal(parser, "export", 1) - _t1290 = 4 + _t1300 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t1291 = 0 + _t1301 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t1292 = 3 + _t1302 = 3 else - _t1292 = -1 + _t1302 = -1 end - _t1291 = _t1292 + _t1301 = _t1302 end - _t1290 = _t1291 + _t1300 = _t1301 end - _t1289 = _t1290 + _t1299 = _t1300 end - _t1288 = _t1289 + _t1298 = _t1299 end - _t1287 = _t1288 + _t1297 = _t1298 else - _t1287 = -1 - end - prediction700 = _t1287 - if prediction700 == 4 - _t1294 = parse_export(parser) - export705 = _t1294 - _t1295 = Proto.Read(read_type=OneOf(:var"#export", export705)) - _t1293 = _t1295 + _t1297 = -1 + end + prediction708 = _t1297 + if prediction708 == 4 + _t1304 = parse_export(parser) + export713 = _t1304 + _t1305 = Proto.Read(read_type=OneOf(:var"#export", export713)) + _t1303 = _t1305 else - if prediction700 == 3 - _t1297 = parse_abort(parser) - abort704 = _t1297 - _t1298 = Proto.Read(read_type=OneOf(:abort, abort704)) - _t1296 = _t1298 + if prediction708 == 3 + _t1307 = parse_abort(parser) + abort712 = _t1307 + _t1308 = Proto.Read(read_type=OneOf(:abort, abort712)) + _t1306 = _t1308 else - if prediction700 == 2 - _t1300 = parse_what_if(parser) - what_if703 = _t1300 - _t1301 = Proto.Read(read_type=OneOf(:what_if, what_if703)) - _t1299 = _t1301 + if prediction708 == 2 + _t1310 = parse_what_if(parser) + what_if711 = _t1310 + _t1311 = Proto.Read(read_type=OneOf(:what_if, what_if711)) + _t1309 = _t1311 else - if prediction700 == 1 - _t1303 = parse_output(parser) - output702 = _t1303 - _t1304 = Proto.Read(read_type=OneOf(:output, output702)) - _t1302 = _t1304 + if prediction708 == 1 + _t1313 = parse_output(parser) + output710 = _t1313 + _t1314 = Proto.Read(read_type=OneOf(:output, output710)) + _t1312 = _t1314 else - if prediction700 == 0 - _t1306 = parse_demand(parser) - demand701 = _t1306 - _t1307 = Proto.Read(read_type=OneOf(:demand, demand701)) - _t1305 = _t1307 + if prediction708 == 0 + _t1316 = parse_demand(parser) + demand709 = _t1316 + _t1317 = Proto.Read(read_type=OneOf(:demand, demand709)) + _t1315 = _t1317 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t1302 = _t1305 + _t1312 = _t1315 end - _t1299 = _t1302 + _t1309 = _t1312 end - _t1296 = _t1299 + _t1306 = _t1309 end - _t1293 = _t1296 + _t1303 = _t1306 end - return _t1293 + return _t1303 end function parse_demand(parser::ParserState)::Proto.Demand consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t1308 = parse_relation_id(parser) - relation_id706 = _t1308 + _t1318 = parse_relation_id(parser) + relation_id714 = _t1318 consume_literal!(parser, ")") - _t1309 = Proto.Demand(relation_id=relation_id706) - return _t1309 + _t1319 = Proto.Demand(relation_id=relation_id714) + return _t1319 end function parse_output(parser::ParserState)::Proto.Output consume_literal!(parser, "(") consume_literal!(parser, "output") - _t1310 = parse_name(parser) - name707 = _t1310 - _t1311 = parse_relation_id(parser) - relation_id708 = _t1311 + _t1320 = parse_name(parser) + name715 = _t1320 + _t1321 = parse_relation_id(parser) + relation_id716 = _t1321 consume_literal!(parser, ")") - _t1312 = Proto.Output(name=name707, relation_id=relation_id708) - return _t1312 + _t1322 = Proto.Output(name=name715, relation_id=relation_id716) + return _t1322 end function parse_what_if(parser::ParserState)::Proto.WhatIf consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t1313 = parse_name(parser) - name709 = _t1313 - _t1314 = parse_epoch(parser) - epoch710 = _t1314 + _t1323 = parse_name(parser) + name717 = _t1323 + _t1324 = parse_epoch(parser) + epoch718 = _t1324 consume_literal!(parser, ")") - _t1315 = Proto.WhatIf(branch=name709, epoch=epoch710) - return _t1315 + _t1325 = Proto.WhatIf(branch=name717, epoch=epoch718) + return _t1325 end function parse_abort(parser::ParserState)::Proto.Abort consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t1317 = parse_name(parser) - _t1316 = _t1317 + _t1327 = parse_name(parser) + _t1326 = _t1327 else - _t1316 = nothing + _t1326 = nothing end - name711 = _t1316 - _t1318 = parse_relation_id(parser) - relation_id712 = _t1318 + name719 = _t1326 + _t1328 = parse_relation_id(parser) + relation_id720 = _t1328 consume_literal!(parser, ")") - _t1319 = Proto.Abort(name=(!isnothing(name711) ? name711 : "abort"), relation_id=relation_id712) - return _t1319 + _t1329 = Proto.Abort(name=(!isnothing(name719) ? name719 : "abort"), relation_id=relation_id720) + return _t1329 end function parse_export(parser::ParserState)::Proto.Export consume_literal!(parser, "(") consume_literal!(parser, "export") - _t1320 = parse_export_csv_config(parser) - export_csv_config713 = _t1320 + _t1330 = parse_export_csv_config(parser) + export_csv_config721 = _t1330 consume_literal!(parser, ")") - _t1321 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config713)) - return _t1321 + _t1331 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config721)) + return _t1331 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t1322 = parse_export_csv_path(parser) - export_csv_path714 = _t1322 - _t1323 = parse_export_csv_columns(parser) - export_csv_columns715 = _t1323 - _t1324 = parse_config_dict(parser) - config_dict716 = _t1324 - consume_literal!(parser, ")") - _t1325 = export_csv_config(parser, export_csv_path714, export_csv_columns715, config_dict716) - return _t1325 + _t1332 = parse_export_csv_path(parser) + export_csv_path722 = _t1332 + _t1333 = parse_export_csv_columns(parser) + export_csv_columns723 = _t1333 + _t1334 = parse_config_dict(parser) + config_dict724 = _t1334 + consume_literal!(parser, ")") + _t1335 = export_csv_config(parser, export_csv_path722, export_csv_columns723, config_dict724) + return _t1335 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string717 = consume_terminal!(parser, "STRING") + string725 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string717 + return string725 end function parse_export_csv_columns(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs718 = Proto.ExportCSVColumn[] - cond719 = match_lookahead_literal(parser, "(", 0) - while cond719 - _t1326 = parse_export_csv_column(parser) - item720 = _t1326 - push!(xs718, item720) - cond719 = match_lookahead_literal(parser, "(", 0) + xs726 = Proto.ExportCSVColumn[] + cond727 = match_lookahead_literal(parser, "(", 0) + while cond727 + _t1336 = parse_export_csv_column(parser) + item728 = _t1336 + push!(xs726, item728) + cond727 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns721 = xs718 + export_csv_columns729 = xs726 consume_literal!(parser, ")") - return export_csv_columns721 + return export_csv_columns729 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn consume_literal!(parser, "(") consume_literal!(parser, "column") - string722 = consume_terminal!(parser, "STRING") - _t1327 = parse_relation_id(parser) - relation_id723 = _t1327 + string730 = consume_terminal!(parser, "STRING") + _t1337 = parse_relation_id(parser) + relation_id731 = _t1337 consume_literal!(parser, ")") - _t1328 = Proto.ExportCSVColumn(column_name=string722, column_data=relation_id723) - return _t1328 + _t1338 = Proto.ExportCSVColumn(column_name=string730, column_data=relation_id731) + return _t1338 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 58c5ff65..82c3007c 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -338,147 +338,147 @@ end # --- Helper functions --- function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1710 = Proto.Value(value=OneOf(:int_value, Int64(v))) - return _t1710 + _t1723 = Proto.Value(value=OneOf(:int_value, Int64(v))) + return _t1723 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1711 = Proto.Value(value=OneOf(:int_value, v)) - return _t1711 + _t1724 = Proto.Value(value=OneOf(:int_value, v)) + return _t1724 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1712 = Proto.Value(value=OneOf(:float_value, v)) - return _t1712 + _t1725 = Proto.Value(value=OneOf(:float_value, v)) + return _t1725 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1713 = Proto.Value(value=OneOf(:string_value, v)) - return _t1713 + _t1726 = Proto.Value(value=OneOf(:string_value, v)) + return _t1726 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1714 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1714 + _t1727 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1727 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1715 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1715 + _t1728 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1728 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 - _t1716 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1716,)) + _t1729 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1729,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1717 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1717,)) + _t1730 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1730,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1718 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1718,)) + _t1731 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1731,)) end end end - _t1719 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1719,)) + _t1732 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1732,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1720 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1720,)) - _t1721 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1721,)) + _t1733 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1733,)) + _t1734 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1734,)) if msg.new_line != "" - _t1722 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1722,)) - end - _t1723 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1723,)) - _t1724 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1724,)) - _t1725 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1725,)) + _t1735 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1735,)) + end + _t1736 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1736,)) + _t1737 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1737,)) + _t1738 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1738,)) if msg.comment != "" - _t1726 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1726,)) + _t1739 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1739,)) end for missing_string in msg.missing_strings - _t1727 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1727,)) - end - _t1728 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1728,)) - _t1729 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1729,)) - _t1730 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1730,)) + _t1740 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1740,)) + end + _t1741 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1741,)) + _t1742 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1742,)) + _t1743 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1743,)) return sort(result) end function deconstruct_betree_info_config(pp::PrettyPrinter, msg::Proto.BeTreeInfo)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1731 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1731,)) - _t1732 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1732,)) - _t1733 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1733,)) - _t1734 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1734,)) + _t1744 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1744,)) + _t1745 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1745,)) + _t1746 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1746,)) + _t1747 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1747,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1735 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1735,)) + _t1748 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1748,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1736 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1736,)) + _t1749 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1749,)) end end - _t1737 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1737,)) - _t1738 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1738,)) + _t1750 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1750,)) + _t1751 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1751,)) 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) - _t1739 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1739,)) + _t1752 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1752,)) end if !isnothing(msg.compression) - _t1740 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1740,)) + _t1753 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1753,)) end if !isnothing(msg.syntax_header_row) - _t1741 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1741,)) + _t1754 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1754,)) end if !isnothing(msg.syntax_missing_string) - _t1742 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1742,)) + _t1755 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1755,)) end if !isnothing(msg.syntax_delim) - _t1743 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1743,)) + _t1756 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1756,)) end if !isnothing(msg.syntax_quotechar) - _t1744 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1744,)) + _t1757 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1757,)) end if !isnothing(msg.syntax_escapechar) - _t1745 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1745,)) + _t1758 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1758,)) end return sort(result) end @@ -493,7 +493,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1746 = nothing + _t1759 = nothing end return nothing end @@ -512,51 +512,51 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat646 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat646) - write(pp, flat646) + flat651 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat651) + write(pp, flat651) return nothing else - function _t1274(_dollar_dollar) + function _t1284(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1275 = _dollar_dollar.configure + _t1285 = _dollar_dollar.configure else - _t1275 = nothing + _t1285 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1276 = _dollar_dollar.sync + _t1286 = _dollar_dollar.sync else - _t1276 = nothing + _t1286 = nothing end - return (_t1275, _t1276, _dollar_dollar.epochs,) + return (_t1285, _t1286, _dollar_dollar.epochs,) end - _t1277 = _t1274(msg) - fields637 = _t1277 - unwrapped_fields638 = fields637 + _t1287 = _t1284(msg) + fields642 = _t1287 + unwrapped_fields643 = fields642 write(pp, "(") write(pp, "transaction") indent_sexp!(pp) - field639 = unwrapped_fields638[1] - if !isnothing(field639) + field644 = unwrapped_fields643[1] + if !isnothing(field644) newline(pp) - opt_val640 = field639 - pretty_configure(pp, opt_val640) + opt_val645 = field644 + pretty_configure(pp, opt_val645) end - field641 = unwrapped_fields638[2] - if !isnothing(field641) + field646 = unwrapped_fields643[2] + if !isnothing(field646) newline(pp) - opt_val642 = field641 - pretty_sync(pp, opt_val642) + opt_val647 = field646 + pretty_sync(pp, opt_val647) end - field643 = unwrapped_fields638[3] - if !isempty(field643) + field648 = unwrapped_fields643[3] + if !isempty(field648) newline(pp) - for (i1278, elem644) in enumerate(field643) - i645 = i1278 - 1 - if (i645 > 0) + for (i1288, elem649) in enumerate(field648) + i650 = i1288 - 1 + if (i650 > 0) newline(pp) end - pretty_epoch(pp, elem644) + pretty_epoch(pp, elem649) end end dedent!(pp) @@ -566,23 +566,23 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat649 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat649) - write(pp, flat649) + flat654 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat654) + write(pp, flat654) return nothing else - function _t1279(_dollar_dollar) - _t1280 = deconstruct_configure(pp, _dollar_dollar) - return _t1280 + function _t1289(_dollar_dollar) + _t1290 = deconstruct_configure(pp, _dollar_dollar) + return _t1290 end - _t1281 = _t1279(msg) - fields647 = _t1281 - unwrapped_fields648 = fields647 + _t1291 = _t1289(msg) + fields652 = _t1291 + unwrapped_fields653 = fields652 write(pp, "(") write(pp, "configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields648) + pretty_config_dict(pp, unwrapped_fields653) dedent!(pp) write(pp, ")") end @@ -590,22 +590,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat653 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat653) - write(pp, flat653) + flat658 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat658) + write(pp, flat658) return nothing else - fields650 = msg + fields655 = msg write(pp, "{") indent!(pp) - if !isempty(fields650) + if !isempty(fields655) newline(pp) - for (i1282, elem651) in enumerate(fields650) - i652 = i1282 - 1 - if (i652 > 0) + for (i1292, elem656) in enumerate(fields655) + i657 = i1292 - 1 + if (i657 > 0) newline(pp) end - pretty_config_key_value(pp, elem651) + pretty_config_key_value(pp, elem656) end end dedent!(pp) @@ -615,160 +615,160 @@ 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}) - flat658 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat658) - write(pp, flat658) + flat663 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat663) + write(pp, flat663) return nothing else - function _t1283(_dollar_dollar) + function _t1293(_dollar_dollar) return (_dollar_dollar[1], _dollar_dollar[2],) end - _t1284 = _t1283(msg) - fields654 = _t1284 - unwrapped_fields655 = fields654 + _t1294 = _t1293(msg) + fields659 = _t1294 + unwrapped_fields660 = fields659 write(pp, ":") - field656 = unwrapped_fields655[1] - write(pp, field656) + field661 = unwrapped_fields660[1] + write(pp, field661) write(pp, " ") - field657 = unwrapped_fields655[2] - pretty_value(pp, field657) + field662 = unwrapped_fields660[2] + pretty_value(pp, field662) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat678 = try_flat(pp, msg, pretty_value) - if !isnothing(flat678) - write(pp, flat678) + flat683 = try_flat(pp, msg, pretty_value) + if !isnothing(flat683) + write(pp, flat683) return nothing else - function _t1285(_dollar_dollar) + function _t1295(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1286 = _get_oneof_field(_dollar_dollar, :date_value) + _t1296 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1286 = nothing + _t1296 = nothing end - return _t1286 + return _t1296 end - _t1287 = _t1285(msg) - deconstruct_result676 = _t1287 - if !isnothing(deconstruct_result676) - unwrapped677 = deconstruct_result676 - pretty_date(pp, unwrapped677) + _t1297 = _t1295(msg) + deconstruct_result681 = _t1297 + if !isnothing(deconstruct_result681) + unwrapped682 = deconstruct_result681 + pretty_date(pp, unwrapped682) else - function _t1288(_dollar_dollar) + function _t1298(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1289 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1299 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1289 = nothing + _t1299 = nothing end - return _t1289 + return _t1299 end - _t1290 = _t1288(msg) - deconstruct_result674 = _t1290 - if !isnothing(deconstruct_result674) - unwrapped675 = deconstruct_result674 - pretty_datetime(pp, unwrapped675) + _t1300 = _t1298(msg) + deconstruct_result679 = _t1300 + if !isnothing(deconstruct_result679) + unwrapped680 = deconstruct_result679 + pretty_datetime(pp, unwrapped680) else - function _t1291(_dollar_dollar) + function _t1301(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1292 = _get_oneof_field(_dollar_dollar, :string_value) + _t1302 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1292 = nothing + _t1302 = nothing end - return _t1292 + return _t1302 end - _t1293 = _t1291(msg) - deconstruct_result672 = _t1293 - if !isnothing(deconstruct_result672) - unwrapped673 = deconstruct_result672 - write(pp, format_string(pp, unwrapped673)) + _t1303 = _t1301(msg) + deconstruct_result677 = _t1303 + if !isnothing(deconstruct_result677) + unwrapped678 = deconstruct_result677 + write(pp, format_string(pp, unwrapped678)) else - function _t1294(_dollar_dollar) + function _t1304(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1295 = _get_oneof_field(_dollar_dollar, :int_value) + _t1305 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1295 = nothing + _t1305 = nothing end - return _t1295 + return _t1305 end - _t1296 = _t1294(msg) - deconstruct_result670 = _t1296 - if !isnothing(deconstruct_result670) - unwrapped671 = deconstruct_result670 - write(pp, format_int(pp, unwrapped671)) + _t1306 = _t1304(msg) + deconstruct_result675 = _t1306 + if !isnothing(deconstruct_result675) + unwrapped676 = deconstruct_result675 + write(pp, format_int(pp, unwrapped676)) else - function _t1297(_dollar_dollar) + function _t1307(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1298 = _get_oneof_field(_dollar_dollar, :float_value) + _t1308 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1298 = nothing + _t1308 = nothing end - return _t1298 + return _t1308 end - _t1299 = _t1297(msg) - deconstruct_result668 = _t1299 - if !isnothing(deconstruct_result668) - unwrapped669 = deconstruct_result668 - write(pp, format_float(pp, unwrapped669)) + _t1309 = _t1307(msg) + deconstruct_result673 = _t1309 + if !isnothing(deconstruct_result673) + unwrapped674 = deconstruct_result673 + write(pp, format_float(pp, unwrapped674)) else - function _t1300(_dollar_dollar) + function _t1310(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1301 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1311 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1301 = nothing + _t1311 = nothing end - return _t1301 + return _t1311 end - _t1302 = _t1300(msg) - deconstruct_result666 = _t1302 - if !isnothing(deconstruct_result666) - unwrapped667 = deconstruct_result666 - write(pp, format_uint128(pp, unwrapped667)) + _t1312 = _t1310(msg) + deconstruct_result671 = _t1312 + if !isnothing(deconstruct_result671) + unwrapped672 = deconstruct_result671 + write(pp, format_uint128(pp, unwrapped672)) else - function _t1303(_dollar_dollar) + function _t1313(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1304 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1314 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1304 = nothing + _t1314 = nothing end - return _t1304 + return _t1314 end - _t1305 = _t1303(msg) - deconstruct_result664 = _t1305 - if !isnothing(deconstruct_result664) - unwrapped665 = deconstruct_result664 - write(pp, format_int128(pp, unwrapped665)) + _t1315 = _t1313(msg) + deconstruct_result669 = _t1315 + if !isnothing(deconstruct_result669) + unwrapped670 = deconstruct_result669 + write(pp, format_int128(pp, unwrapped670)) else - function _t1306(_dollar_dollar) + function _t1316(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1307 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1317 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1307 = nothing + _t1317 = nothing end - return _t1307 + return _t1317 end - _t1308 = _t1306(msg) - deconstruct_result662 = _t1308 - if !isnothing(deconstruct_result662) - unwrapped663 = deconstruct_result662 - write(pp, format_decimal(pp, unwrapped663)) + _t1318 = _t1316(msg) + deconstruct_result667 = _t1318 + if !isnothing(deconstruct_result667) + unwrapped668 = deconstruct_result667 + write(pp, format_decimal(pp, unwrapped668)) else - function _t1309(_dollar_dollar) + function _t1319(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1310 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1320 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1310 = nothing + _t1320 = nothing end - return _t1310 + return _t1320 end - _t1311 = _t1309(msg) - deconstruct_result660 = _t1311 - if !isnothing(deconstruct_result660) - unwrapped661 = deconstruct_result660 - pretty_boolean_value(pp, unwrapped661) + _t1321 = _t1319(msg) + deconstruct_result665 = _t1321 + if !isnothing(deconstruct_result665) + unwrapped666 = deconstruct_result665 + pretty_boolean_value(pp, unwrapped666) else - fields659 = msg + fields664 = msg write(pp, "missing") end end @@ -784,29 +784,29 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat684 = try_flat(pp, msg, pretty_date) - if !isnothing(flat684) - write(pp, flat684) + flat689 = try_flat(pp, msg, pretty_date) + if !isnothing(flat689) + write(pp, flat689) return nothing else - function _t1312(_dollar_dollar) + function _t1322(_dollar_dollar) return (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) end - _t1313 = _t1312(msg) - fields679 = _t1313 - unwrapped_fields680 = fields679 + _t1323 = _t1322(msg) + fields684 = _t1323 + unwrapped_fields685 = fields684 write(pp, "(") write(pp, "date") indent_sexp!(pp) newline(pp) - field681 = unwrapped_fields680[1] - write(pp, format_int(pp, field681)) + field686 = unwrapped_fields685[1] + write(pp, format_int(pp, field686)) newline(pp) - field682 = unwrapped_fields680[2] - write(pp, format_int(pp, field682)) + field687 = unwrapped_fields685[2] + write(pp, format_int(pp, field687)) newline(pp) - field683 = unwrapped_fields680[3] - write(pp, format_int(pp, field683)) + field688 = unwrapped_fields685[3] + write(pp, format_int(pp, field688)) dedent!(pp) write(pp, ")") end @@ -814,43 +814,43 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat695 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat695) - write(pp, flat695) + flat700 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat700) + write(pp, flat700) return nothing else - function _t1314(_dollar_dollar) + function _t1324(_dollar_dollar) return (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),) end - _t1315 = _t1314(msg) - fields685 = _t1315 - unwrapped_fields686 = fields685 + _t1325 = _t1324(msg) + fields690 = _t1325 + unwrapped_fields691 = fields690 write(pp, "(") write(pp, "datetime") indent_sexp!(pp) newline(pp) - field687 = unwrapped_fields686[1] - write(pp, format_int(pp, field687)) + field692 = unwrapped_fields691[1] + write(pp, format_int(pp, field692)) newline(pp) - field688 = unwrapped_fields686[2] - write(pp, format_int(pp, field688)) + field693 = unwrapped_fields691[2] + write(pp, format_int(pp, field693)) newline(pp) - field689 = unwrapped_fields686[3] - write(pp, format_int(pp, field689)) + field694 = unwrapped_fields691[3] + write(pp, format_int(pp, field694)) newline(pp) - field690 = unwrapped_fields686[4] - write(pp, format_int(pp, field690)) + field695 = unwrapped_fields691[4] + write(pp, format_int(pp, field695)) newline(pp) - field691 = unwrapped_fields686[5] - write(pp, format_int(pp, field691)) + field696 = unwrapped_fields691[5] + write(pp, format_int(pp, field696)) newline(pp) - field692 = unwrapped_fields686[6] - write(pp, format_int(pp, field692)) - field693 = unwrapped_fields686[7] - if !isnothing(field693) + field697 = unwrapped_fields691[6] + write(pp, format_int(pp, field697)) + field698 = unwrapped_fields691[7] + if !isnothing(field698) newline(pp) - opt_val694 = field693 - write(pp, format_int(pp, opt_val694)) + opt_val699 = field698 + write(pp, format_int(pp, opt_val699)) end dedent!(pp) write(pp, ")") @@ -859,32 +859,32 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) - function _t1316(_dollar_dollar) + function _t1326(_dollar_dollar) if _dollar_dollar - _t1317 = () + _t1327 = () else - _t1317 = nothing + _t1327 = nothing end - return _t1317 + return _t1327 end - _t1318 = _t1316(msg) - deconstruct_result698 = _t1318 - if !isnothing(deconstruct_result698) - unwrapped699 = deconstruct_result698 + _t1328 = _t1326(msg) + deconstruct_result703 = _t1328 + if !isnothing(deconstruct_result703) + unwrapped704 = deconstruct_result703 write(pp, "true") else - function _t1319(_dollar_dollar) + function _t1329(_dollar_dollar) if !_dollar_dollar - _t1320 = () + _t1330 = () else - _t1320 = nothing + _t1330 = nothing end - return _t1320 + return _t1330 end - _t1321 = _t1319(msg) - deconstruct_result696 = _t1321 - if !isnothing(deconstruct_result696) - unwrapped697 = deconstruct_result696 + _t1331 = _t1329(msg) + deconstruct_result701 = _t1331 + if !isnothing(deconstruct_result701) + unwrapped702 = deconstruct_result701 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -894,28 +894,28 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat704 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat704) - write(pp, flat704) + flat709 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat709) + write(pp, flat709) return nothing else - function _t1322(_dollar_dollar) + function _t1332(_dollar_dollar) return _dollar_dollar.fragments end - _t1323 = _t1322(msg) - fields700 = _t1323 - unwrapped_fields701 = fields700 + _t1333 = _t1332(msg) + fields705 = _t1333 + unwrapped_fields706 = fields705 write(pp, "(") write(pp, "sync") indent_sexp!(pp) - if !isempty(unwrapped_fields701) + if !isempty(unwrapped_fields706) newline(pp) - for (i1324, elem702) in enumerate(unwrapped_fields701) - i703 = i1324 - 1 - if (i703 > 0) + for (i1334, elem707) in enumerate(unwrapped_fields706) + i708 = i1334 - 1 + if (i708 > 0) newline(pp) end - pretty_fragment_id(pp, elem702) + pretty_fragment_id(pp, elem707) end end dedent!(pp) @@ -925,59 +925,59 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat707 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat707) - write(pp, flat707) + flat712 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat712) + write(pp, flat712) return nothing else - function _t1325(_dollar_dollar) + function _t1335(_dollar_dollar) return fragment_id_to_string(pp, _dollar_dollar) end - _t1326 = _t1325(msg) - fields705 = _t1326 - unwrapped_fields706 = fields705 + _t1336 = _t1335(msg) + fields710 = _t1336 + unwrapped_fields711 = fields710 write(pp, ":") - write(pp, unwrapped_fields706) + write(pp, unwrapped_fields711) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat714 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat714) - write(pp, flat714) + flat719 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat719) + write(pp, flat719) return nothing else - function _t1327(_dollar_dollar) + function _t1337(_dollar_dollar) if !isempty(_dollar_dollar.writes) - _t1328 = _dollar_dollar.writes + _t1338 = _dollar_dollar.writes else - _t1328 = nothing + _t1338 = nothing end if !isempty(_dollar_dollar.reads) - _t1329 = _dollar_dollar.reads + _t1339 = _dollar_dollar.reads else - _t1329 = nothing + _t1339 = nothing end - return (_t1328, _t1329,) + return (_t1338, _t1339,) end - _t1330 = _t1327(msg) - fields708 = _t1330 - unwrapped_fields709 = fields708 + _t1340 = _t1337(msg) + fields713 = _t1340 + unwrapped_fields714 = fields713 write(pp, "(") write(pp, "epoch") indent_sexp!(pp) - field710 = unwrapped_fields709[1] - if !isnothing(field710) + field715 = unwrapped_fields714[1] + if !isnothing(field715) newline(pp) - opt_val711 = field710 - pretty_epoch_writes(pp, opt_val711) + opt_val716 = field715 + pretty_epoch_writes(pp, opt_val716) end - field712 = unwrapped_fields709[2] - if !isnothing(field712) + field717 = unwrapped_fields714[2] + if !isnothing(field717) newline(pp) - opt_val713 = field712 - pretty_epoch_reads(pp, opt_val713) + opt_val718 = field717 + pretty_epoch_reads(pp, opt_val718) end dedent!(pp) write(pp, ")") @@ -986,23 +986,23 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat718 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat718) - write(pp, flat718) + flat723 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat723) + write(pp, flat723) return nothing else - fields715 = msg + fields720 = msg write(pp, "(") write(pp, "writes") indent_sexp!(pp) - if !isempty(fields715) + if !isempty(fields720) newline(pp) - for (i1331, elem716) in enumerate(fields715) - i717 = i1331 - 1 - if (i717 > 0) + for (i1341, elem721) in enumerate(fields720) + i722 = i1341 - 1 + if (i722 > 0) newline(pp) end - pretty_write(pp, elem716) + pretty_write(pp, elem721) end end dedent!(pp) @@ -1012,66 +1012,66 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat727 = try_flat(pp, msg, pretty_write) - if !isnothing(flat727) - write(pp, flat727) + flat732 = try_flat(pp, msg, pretty_write) + if !isnothing(flat732) + write(pp, flat732) return nothing else - function _t1332(_dollar_dollar) + function _t1342(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1333 = _get_oneof_field(_dollar_dollar, :define) + _t1343 = _get_oneof_field(_dollar_dollar, :define) else - _t1333 = nothing + _t1343 = nothing end - return _t1333 + return _t1343 end - _t1334 = _t1332(msg) - deconstruct_result725 = _t1334 - if !isnothing(deconstruct_result725) - unwrapped726 = deconstruct_result725 - pretty_define(pp, unwrapped726) + _t1344 = _t1342(msg) + deconstruct_result730 = _t1344 + if !isnothing(deconstruct_result730) + unwrapped731 = deconstruct_result730 + pretty_define(pp, unwrapped731) else - function _t1335(_dollar_dollar) + function _t1345(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1336 = _get_oneof_field(_dollar_dollar, :undefine) + _t1346 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1336 = nothing + _t1346 = nothing end - return _t1336 + return _t1346 end - _t1337 = _t1335(msg) - deconstruct_result723 = _t1337 - if !isnothing(deconstruct_result723) - unwrapped724 = deconstruct_result723 - pretty_undefine(pp, unwrapped724) + _t1347 = _t1345(msg) + deconstruct_result728 = _t1347 + if !isnothing(deconstruct_result728) + unwrapped729 = deconstruct_result728 + pretty_undefine(pp, unwrapped729) else - function _t1338(_dollar_dollar) + function _t1348(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1339 = _get_oneof_field(_dollar_dollar, :context) + _t1349 = _get_oneof_field(_dollar_dollar, :context) else - _t1339 = nothing + _t1349 = nothing end - return _t1339 + return _t1349 end - _t1340 = _t1338(msg) - deconstruct_result721 = _t1340 - if !isnothing(deconstruct_result721) - unwrapped722 = deconstruct_result721 - pretty_context(pp, unwrapped722) + _t1350 = _t1348(msg) + deconstruct_result726 = _t1350 + if !isnothing(deconstruct_result726) + unwrapped727 = deconstruct_result726 + pretty_context(pp, unwrapped727) else - function _t1341(_dollar_dollar) + function _t1351(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1342 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1352 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1342 = nothing + _t1352 = nothing end - return _t1342 + return _t1352 end - _t1343 = _t1341(msg) - deconstruct_result719 = _t1343 - if !isnothing(deconstruct_result719) - unwrapped720 = deconstruct_result719 - pretty_snapshot(pp, unwrapped720) + _t1353 = _t1351(msg) + deconstruct_result724 = _t1353 + if !isnothing(deconstruct_result724) + unwrapped725 = deconstruct_result724 + pretty_snapshot(pp, unwrapped725) else throw(ParseError("No matching rule for write")) end @@ -1083,22 +1083,22 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat730 = try_flat(pp, msg, pretty_define) - if !isnothing(flat730) - write(pp, flat730) + flat735 = try_flat(pp, msg, pretty_define) + if !isnothing(flat735) + write(pp, flat735) return nothing else - function _t1344(_dollar_dollar) + function _t1354(_dollar_dollar) return _dollar_dollar.fragment end - _t1345 = _t1344(msg) - fields728 = _t1345 - unwrapped_fields729 = fields728 + _t1355 = _t1354(msg) + fields733 = _t1355 + unwrapped_fields734 = fields733 write(pp, "(") write(pp, "define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields729) + pretty_fragment(pp, unwrapped_fields734) dedent!(pp) write(pp, ")") end @@ -1106,33 +1106,33 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat737 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat737) - write(pp, flat737) + flat742 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat742) + write(pp, flat742) return nothing else - function _t1346(_dollar_dollar) + function _t1356(_dollar_dollar) start_pretty_fragment(pp, _dollar_dollar) return (_dollar_dollar.id, _dollar_dollar.declarations,) end - _t1347 = _t1346(msg) - fields731 = _t1347 - unwrapped_fields732 = fields731 + _t1357 = _t1356(msg) + fields736 = _t1357 + unwrapped_fields737 = fields736 write(pp, "(") write(pp, "fragment") indent_sexp!(pp) newline(pp) - field733 = unwrapped_fields732[1] - pretty_new_fragment_id(pp, field733) - field734 = unwrapped_fields732[2] - if !isempty(field734) + field738 = unwrapped_fields737[1] + pretty_new_fragment_id(pp, field738) + field739 = unwrapped_fields737[2] + if !isempty(field739) newline(pp) - for (i1348, elem735) in enumerate(field734) - i736 = i1348 - 1 - if (i736 > 0) + for (i1358, elem740) in enumerate(field739) + i741 = i1358 - 1 + if (i741 > 0) newline(pp) end - pretty_declaration(pp, elem735) + pretty_declaration(pp, elem740) end end dedent!(pp) @@ -1142,78 +1142,78 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat739 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat739) - write(pp, flat739) + flat744 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat744) + write(pp, flat744) return nothing else - fields738 = msg - pretty_fragment_id(pp, fields738) + fields743 = msg + pretty_fragment_id(pp, fields743) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat748 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat748) - write(pp, flat748) + flat753 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat753) + write(pp, flat753) return nothing else - function _t1349(_dollar_dollar) + function _t1359(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1350 = _get_oneof_field(_dollar_dollar, :def) + _t1360 = _get_oneof_field(_dollar_dollar, :def) else - _t1350 = nothing + _t1360 = nothing end - return _t1350 + return _t1360 end - _t1351 = _t1349(msg) - deconstruct_result746 = _t1351 - if !isnothing(deconstruct_result746) - unwrapped747 = deconstruct_result746 - pretty_def(pp, unwrapped747) + _t1361 = _t1359(msg) + deconstruct_result751 = _t1361 + if !isnothing(deconstruct_result751) + unwrapped752 = deconstruct_result751 + pretty_def(pp, unwrapped752) else - function _t1352(_dollar_dollar) + function _t1362(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1353 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1363 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1353 = nothing + _t1363 = nothing end - return _t1353 + return _t1363 end - _t1354 = _t1352(msg) - deconstruct_result744 = _t1354 - if !isnothing(deconstruct_result744) - unwrapped745 = deconstruct_result744 - pretty_algorithm(pp, unwrapped745) + _t1364 = _t1362(msg) + deconstruct_result749 = _t1364 + if !isnothing(deconstruct_result749) + unwrapped750 = deconstruct_result749 + pretty_algorithm(pp, unwrapped750) else - function _t1355(_dollar_dollar) + function _t1365(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1356 = _get_oneof_field(_dollar_dollar, :constraint) + _t1366 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1356 = nothing + _t1366 = nothing end - return _t1356 + return _t1366 end - _t1357 = _t1355(msg) - deconstruct_result742 = _t1357 - if !isnothing(deconstruct_result742) - unwrapped743 = deconstruct_result742 - pretty_constraint(pp, unwrapped743) + _t1367 = _t1365(msg) + deconstruct_result747 = _t1367 + if !isnothing(deconstruct_result747) + unwrapped748 = deconstruct_result747 + pretty_constraint(pp, unwrapped748) else - function _t1358(_dollar_dollar) + function _t1368(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1359 = _get_oneof_field(_dollar_dollar, :data) + _t1369 = _get_oneof_field(_dollar_dollar, :data) else - _t1359 = nothing + _t1369 = nothing end - return _t1359 + return _t1369 end - _t1360 = _t1358(msg) - deconstruct_result740 = _t1360 - if !isnothing(deconstruct_result740) - unwrapped741 = deconstruct_result740 - pretty_data(pp, unwrapped741) + _t1370 = _t1368(msg) + deconstruct_result745 = _t1370 + if !isnothing(deconstruct_result745) + unwrapped746 = deconstruct_result745 + pretty_data(pp, unwrapped746) else throw(ParseError("No matching rule for declaration")) end @@ -1225,36 +1225,36 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat755 = try_flat(pp, msg, pretty_def) - if !isnothing(flat755) - write(pp, flat755) + flat760 = try_flat(pp, msg, pretty_def) + if !isnothing(flat760) + write(pp, flat760) return nothing else - function _t1361(_dollar_dollar) + function _t1371(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1362 = _dollar_dollar.attrs + _t1372 = _dollar_dollar.attrs else - _t1362 = nothing + _t1372 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1362,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1372,) end - _t1363 = _t1361(msg) - fields749 = _t1363 - unwrapped_fields750 = fields749 + _t1373 = _t1371(msg) + fields754 = _t1373 + unwrapped_fields755 = fields754 write(pp, "(") write(pp, "def") indent_sexp!(pp) newline(pp) - field751 = unwrapped_fields750[1] - pretty_relation_id(pp, field751) + field756 = unwrapped_fields755[1] + pretty_relation_id(pp, field756) newline(pp) - field752 = unwrapped_fields750[2] - pretty_abstraction(pp, field752) - field753 = unwrapped_fields750[3] - if !isnothing(field753) + field757 = unwrapped_fields755[2] + pretty_abstraction(pp, field757) + field758 = unwrapped_fields755[3] + if !isnothing(field758) newline(pp) - opt_val754 = field753 - pretty_attrs(pp, opt_val754) + opt_val759 = field758 + pretty_attrs(pp, opt_val759) end dedent!(pp) write(pp, ")") @@ -1263,36 +1263,36 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat760 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat760) - write(pp, flat760) + flat765 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat765) + write(pp, flat765) return nothing else - function _t1364(_dollar_dollar) + function _t1374(_dollar_dollar) if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1366 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1365 = _t1366 + _t1376 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1375 = _t1376 else - _t1365 = nothing + _t1375 = nothing end - return _t1365 + return _t1375 end - _t1367 = _t1364(msg) - deconstruct_result758 = _t1367 - if !isnothing(deconstruct_result758) - unwrapped759 = deconstruct_result758 + _t1377 = _t1374(msg) + deconstruct_result763 = _t1377 + if !isnothing(deconstruct_result763) + unwrapped764 = deconstruct_result763 write(pp, ":") - write(pp, unwrapped759) + write(pp, unwrapped764) else - function _t1368(_dollar_dollar) - _t1369 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - return _t1369 + function _t1378(_dollar_dollar) + _t1379 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + return _t1379 end - _t1370 = _t1368(msg) - deconstruct_result756 = _t1370 - if !isnothing(deconstruct_result756) - unwrapped757 = deconstruct_result756 - write(pp, format_uint128(pp, unwrapped757)) + _t1380 = _t1378(msg) + deconstruct_result761 = _t1380 + if !isnothing(deconstruct_result761) + unwrapped762 = deconstruct_result761 + write(pp, format_uint128(pp, unwrapped762)) else throw(ParseError("No matching rule for relation_id")) end @@ -1302,25 +1302,25 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat765 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat765) - write(pp, flat765) + flat770 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat770) + write(pp, flat770) return nothing else - function _t1371(_dollar_dollar) - _t1372 = deconstruct_bindings(pp, _dollar_dollar) - return (_t1372, _dollar_dollar.value,) + function _t1381(_dollar_dollar) + _t1382 = deconstruct_bindings(pp, _dollar_dollar) + return (_t1382, _dollar_dollar.value,) end - _t1373 = _t1371(msg) - fields761 = _t1373 - unwrapped_fields762 = fields761 + _t1383 = _t1381(msg) + fields766 = _t1383 + unwrapped_fields767 = fields766 write(pp, "(") indent!(pp) - field763 = unwrapped_fields762[1] - pretty_bindings(pp, field763) + field768 = unwrapped_fields767[1] + pretty_bindings(pp, field768) newline(pp) - field764 = unwrapped_fields762[2] - pretty_formula(pp, field764) + field769 = unwrapped_fields767[2] + pretty_formula(pp, field769) dedent!(pp) write(pp, ")") end @@ -1328,37 +1328,37 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat773 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat773) - write(pp, flat773) + flat778 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat778) + write(pp, flat778) return nothing else - function _t1374(_dollar_dollar) + function _t1384(_dollar_dollar) if !isempty(_dollar_dollar[2]) - _t1375 = _dollar_dollar[2] + _t1385 = _dollar_dollar[2] else - _t1375 = nothing + _t1385 = nothing end - return (_dollar_dollar[1], _t1375,) + return (_dollar_dollar[1], _t1385,) end - _t1376 = _t1374(msg) - fields766 = _t1376 - unwrapped_fields767 = fields766 + _t1386 = _t1384(msg) + fields771 = _t1386 + unwrapped_fields772 = fields771 write(pp, "[") indent!(pp) - field768 = unwrapped_fields767[1] - for (i1377, elem769) in enumerate(field768) - i770 = i1377 - 1 - if (i770 > 0) + field773 = unwrapped_fields772[1] + for (i1387, elem774) in enumerate(field773) + i775 = i1387 - 1 + if (i775 > 0) newline(pp) end - pretty_binding(pp, elem769) + pretty_binding(pp, elem774) end - field771 = unwrapped_fields767[2] - if !isnothing(field771) + field776 = unwrapped_fields772[2] + if !isnothing(field776) newline(pp) - opt_val772 = field771 - pretty_value_bindings(pp, opt_val772) + opt_val777 = field776 + pretty_value_bindings(pp, opt_val777) end dedent!(pp) write(pp, "]") @@ -1367,185 +1367,185 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat778 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat778) - write(pp, flat778) + flat783 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat783) + write(pp, flat783) return nothing else - function _t1378(_dollar_dollar) + function _t1388(_dollar_dollar) return (_dollar_dollar.var.name, _dollar_dollar.var"#type",) end - _t1379 = _t1378(msg) - fields774 = _t1379 - unwrapped_fields775 = fields774 - field776 = unwrapped_fields775[1] - write(pp, field776) + _t1389 = _t1388(msg) + fields779 = _t1389 + unwrapped_fields780 = fields779 + field781 = unwrapped_fields780[1] + write(pp, field781) write(pp, "::") - field777 = unwrapped_fields775[2] - pretty_type(pp, field777) + field782 = unwrapped_fields780[2] + pretty_type(pp, field782) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat801 = try_flat(pp, msg, pretty_type) - if !isnothing(flat801) - write(pp, flat801) + flat806 = try_flat(pp, msg, pretty_type) + if !isnothing(flat806) + write(pp, flat806) return nothing else - function _t1380(_dollar_dollar) + function _t1390(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1381 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1391 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1381 = nothing + _t1391 = nothing end - return _t1381 + return _t1391 end - _t1382 = _t1380(msg) - deconstruct_result799 = _t1382 - if !isnothing(deconstruct_result799) - unwrapped800 = deconstruct_result799 - pretty_unspecified_type(pp, unwrapped800) + _t1392 = _t1390(msg) + deconstruct_result804 = _t1392 + if !isnothing(deconstruct_result804) + unwrapped805 = deconstruct_result804 + pretty_unspecified_type(pp, unwrapped805) else - function _t1383(_dollar_dollar) + function _t1393(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1384 = _get_oneof_field(_dollar_dollar, :string_type) + _t1394 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1384 = nothing + _t1394 = nothing end - return _t1384 + return _t1394 end - _t1385 = _t1383(msg) - deconstruct_result797 = _t1385 - if !isnothing(deconstruct_result797) - unwrapped798 = deconstruct_result797 - pretty_string_type(pp, unwrapped798) + _t1395 = _t1393(msg) + deconstruct_result802 = _t1395 + if !isnothing(deconstruct_result802) + unwrapped803 = deconstruct_result802 + pretty_string_type(pp, unwrapped803) else - function _t1386(_dollar_dollar) + function _t1396(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1387 = _get_oneof_field(_dollar_dollar, :int_type) + _t1397 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1387 = nothing + _t1397 = nothing end - return _t1387 + return _t1397 end - _t1388 = _t1386(msg) - deconstruct_result795 = _t1388 - if !isnothing(deconstruct_result795) - unwrapped796 = deconstruct_result795 - pretty_int_type(pp, unwrapped796) + _t1398 = _t1396(msg) + deconstruct_result800 = _t1398 + if !isnothing(deconstruct_result800) + unwrapped801 = deconstruct_result800 + pretty_int_type(pp, unwrapped801) else - function _t1389(_dollar_dollar) + function _t1399(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1390 = _get_oneof_field(_dollar_dollar, :float_type) + _t1400 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1390 = nothing + _t1400 = nothing end - return _t1390 + return _t1400 end - _t1391 = _t1389(msg) - deconstruct_result793 = _t1391 - if !isnothing(deconstruct_result793) - unwrapped794 = deconstruct_result793 - pretty_float_type(pp, unwrapped794) + _t1401 = _t1399(msg) + deconstruct_result798 = _t1401 + if !isnothing(deconstruct_result798) + unwrapped799 = deconstruct_result798 + pretty_float_type(pp, unwrapped799) else - function _t1392(_dollar_dollar) + function _t1402(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1393 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1403 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1393 = nothing + _t1403 = nothing end - return _t1393 + return _t1403 end - _t1394 = _t1392(msg) - deconstruct_result791 = _t1394 - if !isnothing(deconstruct_result791) - unwrapped792 = deconstruct_result791 - pretty_uint128_type(pp, unwrapped792) + _t1404 = _t1402(msg) + deconstruct_result796 = _t1404 + if !isnothing(deconstruct_result796) + unwrapped797 = deconstruct_result796 + pretty_uint128_type(pp, unwrapped797) else - function _t1395(_dollar_dollar) + function _t1405(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1396 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1406 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1396 = nothing + _t1406 = nothing end - return _t1396 + return _t1406 end - _t1397 = _t1395(msg) - deconstruct_result789 = _t1397 - if !isnothing(deconstruct_result789) - unwrapped790 = deconstruct_result789 - pretty_int128_type(pp, unwrapped790) + _t1407 = _t1405(msg) + deconstruct_result794 = _t1407 + if !isnothing(deconstruct_result794) + unwrapped795 = deconstruct_result794 + pretty_int128_type(pp, unwrapped795) else - function _t1398(_dollar_dollar) + function _t1408(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1399 = _get_oneof_field(_dollar_dollar, :date_type) + _t1409 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1399 = nothing + _t1409 = nothing end - return _t1399 + return _t1409 end - _t1400 = _t1398(msg) - deconstruct_result787 = _t1400 - if !isnothing(deconstruct_result787) - unwrapped788 = deconstruct_result787 - pretty_date_type(pp, unwrapped788) + _t1410 = _t1408(msg) + deconstruct_result792 = _t1410 + if !isnothing(deconstruct_result792) + unwrapped793 = deconstruct_result792 + pretty_date_type(pp, unwrapped793) else - function _t1401(_dollar_dollar) + function _t1411(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1402 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1412 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1402 = nothing + _t1412 = nothing end - return _t1402 + return _t1412 end - _t1403 = _t1401(msg) - deconstruct_result785 = _t1403 - if !isnothing(deconstruct_result785) - unwrapped786 = deconstruct_result785 - pretty_datetime_type(pp, unwrapped786) + _t1413 = _t1411(msg) + deconstruct_result790 = _t1413 + if !isnothing(deconstruct_result790) + unwrapped791 = deconstruct_result790 + pretty_datetime_type(pp, unwrapped791) else - function _t1404(_dollar_dollar) + function _t1414(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1405 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1415 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1405 = nothing + _t1415 = nothing end - return _t1405 + return _t1415 end - _t1406 = _t1404(msg) - deconstruct_result783 = _t1406 - if !isnothing(deconstruct_result783) - unwrapped784 = deconstruct_result783 - pretty_missing_type(pp, unwrapped784) + _t1416 = _t1414(msg) + deconstruct_result788 = _t1416 + if !isnothing(deconstruct_result788) + unwrapped789 = deconstruct_result788 + pretty_missing_type(pp, unwrapped789) else - function _t1407(_dollar_dollar) + function _t1417(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1408 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1418 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1408 = nothing + _t1418 = nothing end - return _t1408 + return _t1418 end - _t1409 = _t1407(msg) - deconstruct_result781 = _t1409 - if !isnothing(deconstruct_result781) - unwrapped782 = deconstruct_result781 - pretty_decimal_type(pp, unwrapped782) + _t1419 = _t1417(msg) + deconstruct_result786 = _t1419 + if !isnothing(deconstruct_result786) + unwrapped787 = deconstruct_result786 + pretty_decimal_type(pp, unwrapped787) else - function _t1410(_dollar_dollar) + function _t1420(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1411 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1421 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1411 = nothing + _t1421 = nothing end - return _t1411 + return _t1421 end - _t1412 = _t1410(msg) - deconstruct_result779 = _t1412 - if !isnothing(deconstruct_result779) - unwrapped780 = deconstruct_result779 - pretty_boolean_type(pp, unwrapped780) + _t1422 = _t1420(msg) + deconstruct_result784 = _t1422 + if !isnothing(deconstruct_result784) + unwrapped785 = deconstruct_result784 + pretty_boolean_type(pp, unwrapped785) else throw(ParseError("No matching rule for type")) end @@ -1564,80 +1564,80 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields802 = msg + fields807 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields803 = msg + fields808 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields804 = msg + fields809 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields805 = msg + fields810 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields806 = msg + fields811 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields807 = msg + fields812 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields808 = msg + fields813 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields809 = msg + fields814 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields810 = msg + fields815 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat815 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat815) - write(pp, flat815) + flat820 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat820) + write(pp, flat820) return nothing else - function _t1413(_dollar_dollar) + function _t1423(_dollar_dollar) return (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) end - _t1414 = _t1413(msg) - fields811 = _t1414 - unwrapped_fields812 = fields811 + _t1424 = _t1423(msg) + fields816 = _t1424 + unwrapped_fields817 = fields816 write(pp, "(") write(pp, "DECIMAL") indent_sexp!(pp) newline(pp) - field813 = unwrapped_fields812[1] - write(pp, format_int(pp, field813)) + field818 = unwrapped_fields817[1] + write(pp, format_int(pp, field818)) newline(pp) - field814 = unwrapped_fields812[2] - write(pp, format_int(pp, field814)) + field819 = unwrapped_fields817[2] + write(pp, format_int(pp, field819)) dedent!(pp) write(pp, ")") end @@ -1645,27 +1645,27 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields816 = msg + fields821 = msg write(pp, "BOOLEAN") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat820 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat820) - write(pp, flat820) + flat825 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat825) + write(pp, flat825) return nothing else - fields817 = msg + fields822 = msg write(pp, "|") - if !isempty(fields817) + if !isempty(fields822) write(pp, " ") - for (i1415, elem818) in enumerate(fields817) - i819 = i1415 - 1 - if (i819 > 0) + for (i1425, elem823) in enumerate(fields822) + i824 = i1425 - 1 + if (i824 > 0) newline(pp) end - pretty_binding(pp, elem818) + pretty_binding(pp, elem823) end end end @@ -1673,192 +1673,192 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat847 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat847) - write(pp, flat847) + flat852 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat852) + write(pp, flat852) return nothing else - function _t1416(_dollar_dollar) + function _t1426(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1417 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1427 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1417 = nothing + _t1427 = nothing end - return _t1417 + return _t1427 end - _t1418 = _t1416(msg) - deconstruct_result845 = _t1418 - if !isnothing(deconstruct_result845) - unwrapped846 = deconstruct_result845 - pretty_true(pp, unwrapped846) + _t1428 = _t1426(msg) + deconstruct_result850 = _t1428 + if !isnothing(deconstruct_result850) + unwrapped851 = deconstruct_result850 + pretty_true(pp, unwrapped851) else - function _t1419(_dollar_dollar) + function _t1429(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1420 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1430 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1420 = nothing + _t1430 = nothing end - return _t1420 + return _t1430 end - _t1421 = _t1419(msg) - deconstruct_result843 = _t1421 - if !isnothing(deconstruct_result843) - unwrapped844 = deconstruct_result843 - pretty_false(pp, unwrapped844) + _t1431 = _t1429(msg) + deconstruct_result848 = _t1431 + if !isnothing(deconstruct_result848) + unwrapped849 = deconstruct_result848 + pretty_false(pp, unwrapped849) else - function _t1422(_dollar_dollar) + function _t1432(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1423 = _get_oneof_field(_dollar_dollar, :exists) + _t1433 = _get_oneof_field(_dollar_dollar, :exists) else - _t1423 = nothing + _t1433 = nothing end - return _t1423 + return _t1433 end - _t1424 = _t1422(msg) - deconstruct_result841 = _t1424 - if !isnothing(deconstruct_result841) - unwrapped842 = deconstruct_result841 - pretty_exists(pp, unwrapped842) + _t1434 = _t1432(msg) + deconstruct_result846 = _t1434 + if !isnothing(deconstruct_result846) + unwrapped847 = deconstruct_result846 + pretty_exists(pp, unwrapped847) else - function _t1425(_dollar_dollar) + function _t1435(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1426 = _get_oneof_field(_dollar_dollar, :reduce) + _t1436 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1426 = nothing + _t1436 = nothing end - return _t1426 + return _t1436 end - _t1427 = _t1425(msg) - deconstruct_result839 = _t1427 - if !isnothing(deconstruct_result839) - unwrapped840 = deconstruct_result839 - pretty_reduce(pp, unwrapped840) + _t1437 = _t1435(msg) + deconstruct_result844 = _t1437 + if !isnothing(deconstruct_result844) + unwrapped845 = deconstruct_result844 + pretty_reduce(pp, unwrapped845) else - function _t1428(_dollar_dollar) + function _t1438(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1429 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1439 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1429 = nothing + _t1439 = nothing end - return _t1429 + return _t1439 end - _t1430 = _t1428(msg) - deconstruct_result837 = _t1430 - if !isnothing(deconstruct_result837) - unwrapped838 = deconstruct_result837 - pretty_conjunction(pp, unwrapped838) + _t1440 = _t1438(msg) + deconstruct_result842 = _t1440 + if !isnothing(deconstruct_result842) + unwrapped843 = deconstruct_result842 + pretty_conjunction(pp, unwrapped843) else - function _t1431(_dollar_dollar) + function _t1441(_dollar_dollar) if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1432 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1442 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1432 = nothing + _t1442 = nothing end - return _t1432 + return _t1442 end - _t1433 = _t1431(msg) - deconstruct_result835 = _t1433 - if !isnothing(deconstruct_result835) - unwrapped836 = deconstruct_result835 - pretty_disjunction(pp, unwrapped836) + _t1443 = _t1441(msg) + deconstruct_result840 = _t1443 + if !isnothing(deconstruct_result840) + unwrapped841 = deconstruct_result840 + pretty_disjunction(pp, unwrapped841) else - function _t1434(_dollar_dollar) + function _t1444(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1435 = _get_oneof_field(_dollar_dollar, :not) + _t1445 = _get_oneof_field(_dollar_dollar, :not) else - _t1435 = nothing + _t1445 = nothing end - return _t1435 + return _t1445 end - _t1436 = _t1434(msg) - deconstruct_result833 = _t1436 - if !isnothing(deconstruct_result833) - unwrapped834 = deconstruct_result833 - pretty_not(pp, unwrapped834) + _t1446 = _t1444(msg) + deconstruct_result838 = _t1446 + if !isnothing(deconstruct_result838) + unwrapped839 = deconstruct_result838 + pretty_not(pp, unwrapped839) else - function _t1437(_dollar_dollar) + function _t1447(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1438 = _get_oneof_field(_dollar_dollar, :ffi) + _t1448 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1438 = nothing + _t1448 = nothing end - return _t1438 + return _t1448 end - _t1439 = _t1437(msg) - deconstruct_result831 = _t1439 - if !isnothing(deconstruct_result831) - unwrapped832 = deconstruct_result831 - pretty_ffi(pp, unwrapped832) + _t1449 = _t1447(msg) + deconstruct_result836 = _t1449 + if !isnothing(deconstruct_result836) + unwrapped837 = deconstruct_result836 + pretty_ffi(pp, unwrapped837) else - function _t1440(_dollar_dollar) + function _t1450(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1441 = _get_oneof_field(_dollar_dollar, :atom) + _t1451 = _get_oneof_field(_dollar_dollar, :atom) else - _t1441 = nothing + _t1451 = nothing end - return _t1441 + return _t1451 end - _t1442 = _t1440(msg) - deconstruct_result829 = _t1442 - if !isnothing(deconstruct_result829) - unwrapped830 = deconstruct_result829 - pretty_atom(pp, unwrapped830) + _t1452 = _t1450(msg) + deconstruct_result834 = _t1452 + if !isnothing(deconstruct_result834) + unwrapped835 = deconstruct_result834 + pretty_atom(pp, unwrapped835) else - function _t1443(_dollar_dollar) + function _t1453(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1444 = _get_oneof_field(_dollar_dollar, :pragma) + _t1454 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1444 = nothing + _t1454 = nothing end - return _t1444 + return _t1454 end - _t1445 = _t1443(msg) - deconstruct_result827 = _t1445 - if !isnothing(deconstruct_result827) - unwrapped828 = deconstruct_result827 - pretty_pragma(pp, unwrapped828) + _t1455 = _t1453(msg) + deconstruct_result832 = _t1455 + if !isnothing(deconstruct_result832) + unwrapped833 = deconstruct_result832 + pretty_pragma(pp, unwrapped833) else - function _t1446(_dollar_dollar) + function _t1456(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1447 = _get_oneof_field(_dollar_dollar, :primitive) + _t1457 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1447 = nothing + _t1457 = nothing end - return _t1447 + return _t1457 end - _t1448 = _t1446(msg) - deconstruct_result825 = _t1448 - if !isnothing(deconstruct_result825) - unwrapped826 = deconstruct_result825 - pretty_primitive(pp, unwrapped826) + _t1458 = _t1456(msg) + deconstruct_result830 = _t1458 + if !isnothing(deconstruct_result830) + unwrapped831 = deconstruct_result830 + pretty_primitive(pp, unwrapped831) else - function _t1449(_dollar_dollar) + function _t1459(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1450 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1460 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1450 = nothing + _t1460 = nothing end - return _t1450 + return _t1460 end - _t1451 = _t1449(msg) - deconstruct_result823 = _t1451 - if !isnothing(deconstruct_result823) - unwrapped824 = deconstruct_result823 - pretty_rel_atom(pp, unwrapped824) + _t1461 = _t1459(msg) + deconstruct_result828 = _t1461 + if !isnothing(deconstruct_result828) + unwrapped829 = deconstruct_result828 + pretty_rel_atom(pp, unwrapped829) else - function _t1452(_dollar_dollar) + function _t1462(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1453 = _get_oneof_field(_dollar_dollar, :cast) + _t1463 = _get_oneof_field(_dollar_dollar, :cast) else - _t1453 = nothing + _t1463 = nothing end - return _t1453 + return _t1463 end - _t1454 = _t1452(msg) - deconstruct_result821 = _t1454 - if !isnothing(deconstruct_result821) - unwrapped822 = deconstruct_result821 - pretty_cast(pp, unwrapped822) + _t1464 = _t1462(msg) + deconstruct_result826 = _t1464 + if !isnothing(deconstruct_result826) + unwrapped827 = deconstruct_result826 + pretty_cast(pp, unwrapped827) else throw(ParseError("No matching rule for formula")) end @@ -1879,7 +1879,7 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields848 = msg + fields853 = msg write(pp, "(") write(pp, "true") write(pp, ")") @@ -1887,7 +1887,7 @@ function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields849 = msg + fields854 = msg write(pp, "(") write(pp, "false") write(pp, ")") @@ -1895,27 +1895,27 @@ function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat854 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat854) - write(pp, flat854) + flat859 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat859) + write(pp, flat859) return nothing else - function _t1455(_dollar_dollar) - _t1456 = deconstruct_bindings(pp, _dollar_dollar.body) - return (_t1456, _dollar_dollar.body.value,) + function _t1465(_dollar_dollar) + _t1466 = deconstruct_bindings(pp, _dollar_dollar.body) + return (_t1466, _dollar_dollar.body.value,) end - _t1457 = _t1455(msg) - fields850 = _t1457 - unwrapped_fields851 = fields850 + _t1467 = _t1465(msg) + fields855 = _t1467 + unwrapped_fields856 = fields855 write(pp, "(") write(pp, "exists") indent_sexp!(pp) newline(pp) - field852 = unwrapped_fields851[1] - pretty_bindings(pp, field852) + field857 = unwrapped_fields856[1] + pretty_bindings(pp, field857) newline(pp) - field853 = unwrapped_fields851[2] - pretty_formula(pp, field853) + field858 = unwrapped_fields856[2] + pretty_formula(pp, field858) dedent!(pp) write(pp, ")") end @@ -1923,29 +1923,29 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat860 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat860) - write(pp, flat860) + flat865 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat865) + write(pp, flat865) return nothing else - function _t1458(_dollar_dollar) + function _t1468(_dollar_dollar) return (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) end - _t1459 = _t1458(msg) - fields855 = _t1459 - unwrapped_fields856 = fields855 + _t1469 = _t1468(msg) + fields860 = _t1469 + unwrapped_fields861 = fields860 write(pp, "(") write(pp, "reduce") indent_sexp!(pp) newline(pp) - field857 = unwrapped_fields856[1] - pretty_abstraction(pp, field857) + field862 = unwrapped_fields861[1] + pretty_abstraction(pp, field862) newline(pp) - field858 = unwrapped_fields856[2] - pretty_abstraction(pp, field858) + field863 = unwrapped_fields861[2] + pretty_abstraction(pp, field863) newline(pp) - field859 = unwrapped_fields856[3] - pretty_terms(pp, field859) + field864 = unwrapped_fields861[3] + pretty_terms(pp, field864) dedent!(pp) write(pp, ")") end @@ -1953,23 +1953,23 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat864 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat864) - write(pp, flat864) + flat869 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat869) + write(pp, flat869) return nothing else - fields861 = msg + fields866 = msg write(pp, "(") write(pp, "terms") indent_sexp!(pp) - if !isempty(fields861) + if !isempty(fields866) newline(pp) - for (i1460, elem862) in enumerate(fields861) - i863 = i1460 - 1 - if (i863 > 0) + for (i1470, elem867) in enumerate(fields866) + i868 = i1470 - 1 + if (i868 > 0) newline(pp) end - pretty_term(pp, elem862) + pretty_term(pp, elem867) end end dedent!(pp) @@ -1979,38 +1979,38 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat869 = try_flat(pp, msg, pretty_term) - if !isnothing(flat869) - write(pp, flat869) + flat874 = try_flat(pp, msg, pretty_term) + if !isnothing(flat874) + write(pp, flat874) return nothing else - function _t1461(_dollar_dollar) + function _t1471(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1462 = _get_oneof_field(_dollar_dollar, :var) + _t1472 = _get_oneof_field(_dollar_dollar, :var) else - _t1462 = nothing + _t1472 = nothing end - return _t1462 + return _t1472 end - _t1463 = _t1461(msg) - deconstruct_result867 = _t1463 - if !isnothing(deconstruct_result867) - unwrapped868 = deconstruct_result867 - pretty_var(pp, unwrapped868) + _t1473 = _t1471(msg) + deconstruct_result872 = _t1473 + if !isnothing(deconstruct_result872) + unwrapped873 = deconstruct_result872 + pretty_var(pp, unwrapped873) else - function _t1464(_dollar_dollar) + function _t1474(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1465 = _get_oneof_field(_dollar_dollar, :constant) + _t1475 = _get_oneof_field(_dollar_dollar, :constant) else - _t1465 = nothing + _t1475 = nothing end - return _t1465 + return _t1475 end - _t1466 = _t1464(msg) - deconstruct_result865 = _t1466 - if !isnothing(deconstruct_result865) - unwrapped866 = deconstruct_result865 - pretty_constant(pp, unwrapped866) + _t1476 = _t1474(msg) + deconstruct_result870 = _t1476 + if !isnothing(deconstruct_result870) + unwrapped871 = deconstruct_result870 + pretty_constant(pp, unwrapped871) else throw(ParseError("No matching rule for term")) end @@ -2020,57 +2020,57 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat872 = try_flat(pp, msg, pretty_var) - if !isnothing(flat872) - write(pp, flat872) + flat877 = try_flat(pp, msg, pretty_var) + if !isnothing(flat877) + write(pp, flat877) return nothing else - function _t1467(_dollar_dollar) + function _t1477(_dollar_dollar) return _dollar_dollar.name end - _t1468 = _t1467(msg) - fields870 = _t1468 - unwrapped_fields871 = fields870 - write(pp, unwrapped_fields871) + _t1478 = _t1477(msg) + fields875 = _t1478 + unwrapped_fields876 = fields875 + write(pp, unwrapped_fields876) end return nothing end function pretty_constant(pp::PrettyPrinter, msg::Proto.Value) - flat874 = try_flat(pp, msg, pretty_constant) - if !isnothing(flat874) - write(pp, flat874) + flat879 = try_flat(pp, msg, pretty_constant) + if !isnothing(flat879) + write(pp, flat879) return nothing else - fields873 = msg - pretty_value(pp, fields873) + fields878 = msg + pretty_value(pp, fields878) end return nothing end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat879 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat879) - write(pp, flat879) + flat884 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat884) + write(pp, flat884) return nothing else - function _t1469(_dollar_dollar) + function _t1479(_dollar_dollar) return _dollar_dollar.args end - _t1470 = _t1469(msg) - fields875 = _t1470 - unwrapped_fields876 = fields875 + _t1480 = _t1479(msg) + fields880 = _t1480 + unwrapped_fields881 = fields880 write(pp, "(") write(pp, "and") indent_sexp!(pp) - if !isempty(unwrapped_fields876) + if !isempty(unwrapped_fields881) newline(pp) - for (i1471, elem877) in enumerate(unwrapped_fields876) - i878 = i1471 - 1 - if (i878 > 0) + for (i1481, elem882) in enumerate(unwrapped_fields881) + i883 = i1481 - 1 + if (i883 > 0) newline(pp) end - pretty_formula(pp, elem877) + pretty_formula(pp, elem882) end end dedent!(pp) @@ -2080,28 +2080,28 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat884 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat884) - write(pp, flat884) + flat889 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat889) + write(pp, flat889) return nothing else - function _t1472(_dollar_dollar) + function _t1482(_dollar_dollar) return _dollar_dollar.args end - _t1473 = _t1472(msg) - fields880 = _t1473 - unwrapped_fields881 = fields880 + _t1483 = _t1482(msg) + fields885 = _t1483 + unwrapped_fields886 = fields885 write(pp, "(") write(pp, "or") indent_sexp!(pp) - if !isempty(unwrapped_fields881) + if !isempty(unwrapped_fields886) newline(pp) - for (i1474, elem882) in enumerate(unwrapped_fields881) - i883 = i1474 - 1 - if (i883 > 0) + for (i1484, elem887) in enumerate(unwrapped_fields886) + i888 = i1484 - 1 + if (i888 > 0) newline(pp) end - pretty_formula(pp, elem882) + pretty_formula(pp, elem887) end end dedent!(pp) @@ -2111,22 +2111,22 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat887 = try_flat(pp, msg, pretty_not) - if !isnothing(flat887) - write(pp, flat887) + flat892 = try_flat(pp, msg, pretty_not) + if !isnothing(flat892) + write(pp, flat892) return nothing else - function _t1475(_dollar_dollar) + function _t1485(_dollar_dollar) return _dollar_dollar.arg end - _t1476 = _t1475(msg) - fields885 = _t1476 - unwrapped_fields886 = fields885 + _t1486 = _t1485(msg) + fields890 = _t1486 + unwrapped_fields891 = fields890 write(pp, "(") write(pp, "not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields886) + pretty_formula(pp, unwrapped_fields891) dedent!(pp) write(pp, ")") end @@ -2134,29 +2134,29 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat893 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat893) - write(pp, flat893) + flat898 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat898) + write(pp, flat898) return nothing else - function _t1477(_dollar_dollar) + function _t1487(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) end - _t1478 = _t1477(msg) - fields888 = _t1478 - unwrapped_fields889 = fields888 + _t1488 = _t1487(msg) + fields893 = _t1488 + unwrapped_fields894 = fields893 write(pp, "(") write(pp, "ffi") indent_sexp!(pp) newline(pp) - field890 = unwrapped_fields889[1] - pretty_name(pp, field890) + field895 = unwrapped_fields894[1] + pretty_name(pp, field895) newline(pp) - field891 = unwrapped_fields889[2] - pretty_ffi_args(pp, field891) + field896 = unwrapped_fields894[2] + pretty_ffi_args(pp, field896) newline(pp) - field892 = unwrapped_fields889[3] - pretty_terms(pp, field892) + field897 = unwrapped_fields894[3] + pretty_terms(pp, field897) dedent!(pp) write(pp, ")") end @@ -2164,36 +2164,36 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat895 = try_flat(pp, msg, pretty_name) - if !isnothing(flat895) - write(pp, flat895) + flat900 = try_flat(pp, msg, pretty_name) + if !isnothing(flat900) + write(pp, flat900) return nothing else - fields894 = msg + fields899 = msg write(pp, ":") - write(pp, fields894) + write(pp, fields899) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat899 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat899) - write(pp, flat899) + flat904 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat904) + write(pp, flat904) return nothing else - fields896 = msg + fields901 = msg write(pp, "(") write(pp, "args") indent_sexp!(pp) - if !isempty(fields896) + if !isempty(fields901) newline(pp) - for (i1479, elem897) in enumerate(fields896) - i898 = i1479 - 1 - if (i898 > 0) + for (i1489, elem902) in enumerate(fields901) + i903 = i1489 - 1 + if (i903 > 0) newline(pp) end - pretty_abstraction(pp, elem897) + pretty_abstraction(pp, elem902) end end dedent!(pp) @@ -2203,32 +2203,32 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat906 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat906) - write(pp, flat906) + flat911 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat911) + write(pp, flat911) return nothing else - function _t1480(_dollar_dollar) + function _t1490(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1481 = _t1480(msg) - fields900 = _t1481 - unwrapped_fields901 = fields900 + _t1491 = _t1490(msg) + fields905 = _t1491 + unwrapped_fields906 = fields905 write(pp, "(") write(pp, "atom") indent_sexp!(pp) newline(pp) - field902 = unwrapped_fields901[1] - pretty_relation_id(pp, field902) - field903 = unwrapped_fields901[2] - if !isempty(field903) + field907 = unwrapped_fields906[1] + pretty_relation_id(pp, field907) + field908 = unwrapped_fields906[2] + if !isempty(field908) newline(pp) - for (i1482, elem904) in enumerate(field903) - i905 = i1482 - 1 - if (i905 > 0) + for (i1492, elem909) in enumerate(field908) + i910 = i1492 - 1 + if (i910 > 0) newline(pp) end - pretty_term(pp, elem904) + pretty_term(pp, elem909) end end dedent!(pp) @@ -2238,32 +2238,32 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat913 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat913) - write(pp, flat913) + flat918 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat918) + write(pp, flat918) return nothing else - function _t1483(_dollar_dollar) + function _t1493(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1484 = _t1483(msg) - fields907 = _t1484 - unwrapped_fields908 = fields907 + _t1494 = _t1493(msg) + fields912 = _t1494 + unwrapped_fields913 = fields912 write(pp, "(") write(pp, "pragma") indent_sexp!(pp) newline(pp) - field909 = unwrapped_fields908[1] - pretty_name(pp, field909) - field910 = unwrapped_fields908[2] - if !isempty(field910) + field914 = unwrapped_fields913[1] + pretty_name(pp, field914) + field915 = unwrapped_fields913[2] + if !isempty(field915) newline(pp) - for (i1485, elem911) in enumerate(field910) - i912 = i1485 - 1 - if (i912 > 0) + for (i1495, elem916) in enumerate(field915) + i917 = i1495 - 1 + if (i917 > 0) newline(pp) end - pretty_term(pp, elem911) + pretty_term(pp, elem916) end end dedent!(pp) @@ -2273,149 +2273,149 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat929 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat929) - write(pp, flat929) + flat934 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat934) + write(pp, flat934) return nothing else - function _t1486(_dollar_dollar) + function _t1496(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_eq" - _t1487 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1497 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1487 = nothing + _t1497 = nothing end - return _t1487 + return _t1497 end - _t1488 = _t1486(msg) - guard_result928 = _t1488 - if !isnothing(guard_result928) + _t1498 = _t1496(msg) + guard_result933 = _t1498 + if !isnothing(guard_result933) pretty_eq(pp, msg) else - function _t1489(_dollar_dollar) + function _t1499(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1490 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1500 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1490 = nothing + _t1500 = nothing end - return _t1490 + return _t1500 end - _t1491 = _t1489(msg) - guard_result927 = _t1491 - if !isnothing(guard_result927) + _t1501 = _t1499(msg) + guard_result932 = _t1501 + if !isnothing(guard_result932) pretty_lt(pp, msg) else - function _t1492(_dollar_dollar) + function _t1502(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1493 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1503 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1493 = nothing + _t1503 = nothing end - return _t1493 + return _t1503 end - _t1494 = _t1492(msg) - guard_result926 = _t1494 - if !isnothing(guard_result926) + _t1504 = _t1502(msg) + guard_result931 = _t1504 + if !isnothing(guard_result931) pretty_lt_eq(pp, msg) else - function _t1495(_dollar_dollar) + function _t1505(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1496 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1506 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1496 = nothing + _t1506 = nothing end - return _t1496 + return _t1506 end - _t1497 = _t1495(msg) - guard_result925 = _t1497 - if !isnothing(guard_result925) + _t1507 = _t1505(msg) + guard_result930 = _t1507 + if !isnothing(guard_result930) pretty_gt(pp, msg) else - function _t1498(_dollar_dollar) + function _t1508(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1499 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1509 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1499 = nothing + _t1509 = nothing end - return _t1499 + return _t1509 end - _t1500 = _t1498(msg) - guard_result924 = _t1500 - if !isnothing(guard_result924) + _t1510 = _t1508(msg) + guard_result929 = _t1510 + if !isnothing(guard_result929) pretty_gt_eq(pp, msg) else - function _t1501(_dollar_dollar) + function _t1511(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1502 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1512 = (_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 - _t1502 = nothing + _t1512 = nothing end - return _t1502 + return _t1512 end - _t1503 = _t1501(msg) - guard_result923 = _t1503 - if !isnothing(guard_result923) + _t1513 = _t1511(msg) + guard_result928 = _t1513 + if !isnothing(guard_result928) pretty_add(pp, msg) else - function _t1504(_dollar_dollar) + function _t1514(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1505 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1515 = (_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 - _t1505 = nothing + _t1515 = nothing end - return _t1505 + return _t1515 end - _t1506 = _t1504(msg) - guard_result922 = _t1506 - if !isnothing(guard_result922) + _t1516 = _t1514(msg) + guard_result927 = _t1516 + if !isnothing(guard_result927) pretty_minus(pp, msg) else - function _t1507(_dollar_dollar) + function _t1517(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1508 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1518 = (_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 - _t1508 = nothing + _t1518 = nothing end - return _t1508 + return _t1518 end - _t1509 = _t1507(msg) - guard_result921 = _t1509 - if !isnothing(guard_result921) + _t1519 = _t1517(msg) + guard_result926 = _t1519 + if !isnothing(guard_result926) pretty_multiply(pp, msg) else - function _t1510(_dollar_dollar) + function _t1520(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1511 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1521 = (_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 - _t1511 = nothing + _t1521 = nothing end - return _t1511 + return _t1521 end - _t1512 = _t1510(msg) - guard_result920 = _t1512 - if !isnothing(guard_result920) + _t1522 = _t1520(msg) + guard_result925 = _t1522 + if !isnothing(guard_result925) pretty_divide(pp, msg) else - function _t1513(_dollar_dollar) + function _t1523(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1514 = _t1513(msg) - fields914 = _t1514 - unwrapped_fields915 = fields914 + _t1524 = _t1523(msg) + fields919 = _t1524 + unwrapped_fields920 = fields919 write(pp, "(") write(pp, "primitive") indent_sexp!(pp) newline(pp) - field916 = unwrapped_fields915[1] - pretty_name(pp, field916) - field917 = unwrapped_fields915[2] - if !isempty(field917) + field921 = unwrapped_fields920[1] + pretty_name(pp, field921) + field922 = unwrapped_fields920[2] + if !isempty(field922) newline(pp) - for (i1515, elem918) in enumerate(field917) - i919 = i1515 - 1 - if (i919 > 0) + for (i1525, elem923) in enumerate(field922) + i924 = i1525 - 1 + if (i924 > 0) newline(pp) end - pretty_rel_term(pp, elem918) + pretty_rel_term(pp, elem923) end end dedent!(pp) @@ -2434,56 +2434,24 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat934 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat934) - write(pp, flat934) - return nothing - else - function _t1516(_dollar_dollar) - if _dollar_dollar.name == "rel_primitive_eq" - _t1517 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) - else - _t1517 = nothing - end - return _t1517 - end - _t1518 = _t1516(msg) - fields930 = _t1518 - unwrapped_fields931 = fields930 - write(pp, "(") - write(pp, "=") - indent_sexp!(pp) - newline(pp) - field932 = unwrapped_fields931[1] - pretty_term(pp, field932) - newline(pp) - field933 = unwrapped_fields931[2] - pretty_term(pp, field933) - dedent!(pp) - write(pp, ")") - end - return nothing -end - -function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat939 = try_flat(pp, msg, pretty_lt) + flat939 = try_flat(pp, msg, pretty_eq) if !isnothing(flat939) write(pp, flat939) return nothing else - function _t1519(_dollar_dollar) - if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1520 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + function _t1526(_dollar_dollar) + if _dollar_dollar.name == "rel_primitive_eq" + _t1527 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1520 = nothing + _t1527 = nothing end - return _t1520 + return _t1527 end - _t1521 = _t1519(msg) - fields935 = _t1521 + _t1528 = _t1526(msg) + fields935 = _t1528 unwrapped_fields936 = fields935 write(pp, "(") - write(pp, "<") + write(pp, "=") indent_sexp!(pp) newline(pp) field937 = unwrapped_fields936[1] @@ -2497,25 +2465,25 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat944 = try_flat(pp, msg, pretty_lt_eq) +function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) + flat944 = try_flat(pp, msg, pretty_lt) if !isnothing(flat944) write(pp, flat944) return nothing else - function _t1522(_dollar_dollar) - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1523 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + function _t1529(_dollar_dollar) + if _dollar_dollar.name == "rel_primitive_lt_monotype" + _t1530 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1523 = nothing + _t1530 = nothing end - return _t1523 + return _t1530 end - _t1524 = _t1522(msg) - fields940 = _t1524 + _t1531 = _t1529(msg) + fields940 = _t1531 unwrapped_fields941 = fields940 write(pp, "(") - write(pp, "<=") + write(pp, "<") indent_sexp!(pp) newline(pp) field942 = unwrapped_fields941[1] @@ -2529,25 +2497,25 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat949 = try_flat(pp, msg, pretty_gt) +function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) + flat949 = try_flat(pp, msg, pretty_lt_eq) if !isnothing(flat949) write(pp, flat949) return nothing else - function _t1525(_dollar_dollar) - if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1526 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + function _t1532(_dollar_dollar) + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" + _t1533 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1526 = nothing + _t1533 = nothing end - return _t1526 + return _t1533 end - _t1527 = _t1525(msg) - fields945 = _t1527 + _t1534 = _t1532(msg) + fields945 = _t1534 unwrapped_fields946 = fields945 write(pp, "(") - write(pp, ">") + write(pp, "<=") indent_sexp!(pp) newline(pp) field947 = unwrapped_fields946[1] @@ -2561,25 +2529,25 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat954 = try_flat(pp, msg, pretty_gt_eq) +function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) + flat954 = try_flat(pp, msg, pretty_gt) if !isnothing(flat954) write(pp, flat954) return nothing else - function _t1528(_dollar_dollar) - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1529 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + function _t1535(_dollar_dollar) + if _dollar_dollar.name == "rel_primitive_gt_monotype" + _t1536 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1529 = nothing + _t1536 = nothing end - return _t1529 + return _t1536 end - _t1530 = _t1528(msg) - fields950 = _t1530 + _t1537 = _t1535(msg) + fields950 = _t1537 unwrapped_fields951 = fields950 write(pp, "(") - write(pp, ">=") + write(pp, ">") indent_sexp!(pp) newline(pp) field952 = unwrapped_fields951[1] @@ -2593,25 +2561,25 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat960 = try_flat(pp, msg, pretty_add) - if !isnothing(flat960) - write(pp, flat960) +function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) + flat959 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat959) + write(pp, flat959) return nothing else - function _t1531(_dollar_dollar) - if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1532 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + function _t1538(_dollar_dollar) + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" + _t1539 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1532 = nothing + _t1539 = nothing end - return _t1532 + return _t1539 end - _t1533 = _t1531(msg) - fields955 = _t1533 + _t1540 = _t1538(msg) + fields955 = _t1540 unwrapped_fields956 = fields955 write(pp, "(") - write(pp, "+") + write(pp, ">=") indent_sexp!(pp) newline(pp) field957 = unwrapped_fields956[1] @@ -2619,9 +2587,41 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) newline(pp) field958 = unwrapped_fields956[2] pretty_term(pp, field958) + dedent!(pp) + write(pp, ")") + end + return nothing +end + +function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) + flat965 = try_flat(pp, msg, pretty_add) + if !isnothing(flat965) + write(pp, flat965) + return nothing + else + function _t1541(_dollar_dollar) + if _dollar_dollar.name == "rel_primitive_add_monotype" + _t1542 = (_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 + _t1542 = nothing + end + return _t1542 + end + _t1543 = _t1541(msg) + fields960 = _t1543 + unwrapped_fields961 = fields960 + write(pp, "(") + write(pp, "+") + indent_sexp!(pp) + newline(pp) + field962 = unwrapped_fields961[1] + pretty_term(pp, field962) newline(pp) - field959 = unwrapped_fields956[3] - pretty_term(pp, field959) + field963 = unwrapped_fields961[2] + pretty_term(pp, field963) + newline(pp) + field964 = unwrapped_fields961[3] + pretty_term(pp, field964) dedent!(pp) write(pp, ")") end @@ -2629,34 +2629,34 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat966 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat966) - write(pp, flat966) + flat971 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat971) + write(pp, flat971) return nothing else - function _t1534(_dollar_dollar) + function _t1544(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1535 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1545 = (_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 - _t1535 = nothing + _t1545 = nothing end - return _t1535 + return _t1545 end - _t1536 = _t1534(msg) - fields961 = _t1536 - unwrapped_fields962 = fields961 + _t1546 = _t1544(msg) + fields966 = _t1546 + unwrapped_fields967 = fields966 write(pp, "(") write(pp, "-") indent_sexp!(pp) newline(pp) - field963 = unwrapped_fields962[1] - pretty_term(pp, field963) + field968 = unwrapped_fields967[1] + pretty_term(pp, field968) newline(pp) - field964 = unwrapped_fields962[2] - pretty_term(pp, field964) + field969 = unwrapped_fields967[2] + pretty_term(pp, field969) newline(pp) - field965 = unwrapped_fields962[3] - pretty_term(pp, field965) + field970 = unwrapped_fields967[3] + pretty_term(pp, field970) dedent!(pp) write(pp, ")") end @@ -2664,34 +2664,34 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat972 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat972) - write(pp, flat972) + flat977 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat977) + write(pp, flat977) return nothing else - function _t1537(_dollar_dollar) + function _t1547(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1538 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1548 = (_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 - _t1538 = nothing + _t1548 = nothing end - return _t1538 + return _t1548 end - _t1539 = _t1537(msg) - fields967 = _t1539 - unwrapped_fields968 = fields967 + _t1549 = _t1547(msg) + fields972 = _t1549 + unwrapped_fields973 = fields972 write(pp, "(") write(pp, "*") indent_sexp!(pp) newline(pp) - field969 = unwrapped_fields968[1] - pretty_term(pp, field969) + field974 = unwrapped_fields973[1] + pretty_term(pp, field974) newline(pp) - field970 = unwrapped_fields968[2] - pretty_term(pp, field970) + field975 = unwrapped_fields973[2] + pretty_term(pp, field975) newline(pp) - field971 = unwrapped_fields968[3] - pretty_term(pp, field971) + field976 = unwrapped_fields973[3] + pretty_term(pp, field976) dedent!(pp) write(pp, ")") end @@ -2699,34 +2699,34 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat978 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat978) - write(pp, flat978) + flat983 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat983) + write(pp, flat983) return nothing else - function _t1540(_dollar_dollar) + function _t1550(_dollar_dollar) if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1541 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1551 = (_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 - _t1541 = nothing + _t1551 = nothing end - return _t1541 + return _t1551 end - _t1542 = _t1540(msg) - fields973 = _t1542 - unwrapped_fields974 = fields973 + _t1552 = _t1550(msg) + fields978 = _t1552 + unwrapped_fields979 = fields978 write(pp, "(") write(pp, "/") indent_sexp!(pp) newline(pp) - field975 = unwrapped_fields974[1] - pretty_term(pp, field975) + field980 = unwrapped_fields979[1] + pretty_term(pp, field980) newline(pp) - field976 = unwrapped_fields974[2] - pretty_term(pp, field976) + field981 = unwrapped_fields979[2] + pretty_term(pp, field981) newline(pp) - field977 = unwrapped_fields974[3] - pretty_term(pp, field977) + field982 = unwrapped_fields979[3] + pretty_term(pp, field982) dedent!(pp) write(pp, ")") end @@ -2734,38 +2734,38 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat983 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat983) - write(pp, flat983) + flat988 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat988) + write(pp, flat988) return nothing else - function _t1543(_dollar_dollar) + function _t1553(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1544 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1554 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1544 = nothing + _t1554 = nothing end - return _t1544 + return _t1554 end - _t1545 = _t1543(msg) - deconstruct_result981 = _t1545 - if !isnothing(deconstruct_result981) - unwrapped982 = deconstruct_result981 - pretty_specialized_value(pp, unwrapped982) + _t1555 = _t1553(msg) + deconstruct_result986 = _t1555 + if !isnothing(deconstruct_result986) + unwrapped987 = deconstruct_result986 + pretty_specialized_value(pp, unwrapped987) else - function _t1546(_dollar_dollar) + function _t1556(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1547 = _get_oneof_field(_dollar_dollar, :term) + _t1557 = _get_oneof_field(_dollar_dollar, :term) else - _t1547 = nothing + _t1557 = nothing end - return _t1547 + return _t1557 end - _t1548 = _t1546(msg) - deconstruct_result979 = _t1548 - if !isnothing(deconstruct_result979) - unwrapped980 = deconstruct_result979 - pretty_term(pp, unwrapped980) + _t1558 = _t1556(msg) + deconstruct_result984 = _t1558 + if !isnothing(deconstruct_result984) + unwrapped985 = deconstruct_result984 + pretty_term(pp, unwrapped985) else throw(ParseError("No matching rule for rel_term")) end @@ -2775,45 +2775,45 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat985 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat985) - write(pp, flat985) + flat990 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat990) + write(pp, flat990) return nothing else - fields984 = msg + fields989 = msg write(pp, "#") - pretty_value(pp, fields984) + pretty_value(pp, fields989) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat992 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat992) - write(pp, flat992) + flat997 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat997) + write(pp, flat997) return nothing else - function _t1549(_dollar_dollar) + function _t1559(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.terms,) end - _t1550 = _t1549(msg) - fields986 = _t1550 - unwrapped_fields987 = fields986 + _t1560 = _t1559(msg) + fields991 = _t1560 + unwrapped_fields992 = fields991 write(pp, "(") write(pp, "relatom") indent_sexp!(pp) newline(pp) - field988 = unwrapped_fields987[1] - pretty_name(pp, field988) - field989 = unwrapped_fields987[2] - if !isempty(field989) + field993 = unwrapped_fields992[1] + pretty_name(pp, field993) + field994 = unwrapped_fields992[2] + if !isempty(field994) newline(pp) - for (i1551, elem990) in enumerate(field989) - i991 = i1551 - 1 - if (i991 > 0) + for (i1561, elem995) in enumerate(field994) + i996 = i1561 - 1 + if (i996 > 0) newline(pp) end - pretty_rel_term(pp, elem990) + pretty_rel_term(pp, elem995) end end dedent!(pp) @@ -2823,26 +2823,26 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat997 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat997) - write(pp, flat997) + flat1002 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1002) + write(pp, flat1002) return nothing else - function _t1552(_dollar_dollar) + function _t1562(_dollar_dollar) return (_dollar_dollar.input, _dollar_dollar.result,) end - _t1553 = _t1552(msg) - fields993 = _t1553 - unwrapped_fields994 = fields993 + _t1563 = _t1562(msg) + fields998 = _t1563 + unwrapped_fields999 = fields998 write(pp, "(") write(pp, "cast") indent_sexp!(pp) newline(pp) - field995 = unwrapped_fields994[1] - pretty_term(pp, field995) + field1000 = unwrapped_fields999[1] + pretty_term(pp, field1000) newline(pp) - field996 = unwrapped_fields994[2] - pretty_term(pp, field996) + field1001 = unwrapped_fields999[2] + pretty_term(pp, field1001) dedent!(pp) write(pp, ")") end @@ -2850,23 +2850,23 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1001 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1001) - write(pp, flat1001) + flat1006 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1006) + write(pp, flat1006) return nothing else - fields998 = msg + fields1003 = msg write(pp, "(") write(pp, "attrs") indent_sexp!(pp) - if !isempty(fields998) + if !isempty(fields1003) newline(pp) - for (i1554, elem999) in enumerate(fields998) - i1000 = i1554 - 1 - if (i1000 > 0) + for (i1564, elem1004) in enumerate(fields1003) + i1005 = i1564 - 1 + if (i1005 > 0) newline(pp) end - pretty_attribute(pp, elem999) + pretty_attribute(pp, elem1004) end end dedent!(pp) @@ -2876,32 +2876,32 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1008 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1008) - write(pp, flat1008) + flat1013 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1013) + write(pp, flat1013) return nothing else - function _t1555(_dollar_dollar) + function _t1565(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.args,) end - _t1556 = _t1555(msg) - fields1002 = _t1556 - unwrapped_fields1003 = fields1002 + _t1566 = _t1565(msg) + fields1007 = _t1566 + unwrapped_fields1008 = fields1007 write(pp, "(") write(pp, "attribute") indent_sexp!(pp) newline(pp) - field1004 = unwrapped_fields1003[1] - pretty_name(pp, field1004) - field1005 = unwrapped_fields1003[2] - if !isempty(field1005) + field1009 = unwrapped_fields1008[1] + pretty_name(pp, field1009) + field1010 = unwrapped_fields1008[2] + if !isempty(field1010) newline(pp) - for (i1557, elem1006) in enumerate(field1005) - i1007 = i1557 - 1 - if (i1007 > 0) + for (i1567, elem1011) in enumerate(field1010) + i1012 = i1567 - 1 + if (i1012 > 0) newline(pp) end - pretty_value(pp, elem1006) + pretty_value(pp, elem1011) end end dedent!(pp) @@ -2911,34 +2911,34 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1015 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1015) - write(pp, flat1015) + flat1020 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1020) + write(pp, flat1020) return nothing else - function _t1558(_dollar_dollar) + function _t1568(_dollar_dollar) return (_dollar_dollar.var"#global", _dollar_dollar.body,) end - _t1559 = _t1558(msg) - fields1009 = _t1559 - unwrapped_fields1010 = fields1009 + _t1569 = _t1568(msg) + fields1014 = _t1569 + unwrapped_fields1015 = fields1014 write(pp, "(") write(pp, "algorithm") indent_sexp!(pp) - field1011 = unwrapped_fields1010[1] - if !isempty(field1011) + field1016 = unwrapped_fields1015[1] + if !isempty(field1016) newline(pp) - for (i1560, elem1012) in enumerate(field1011) - i1013 = i1560 - 1 - if (i1013 > 0) + for (i1570, elem1017) in enumerate(field1016) + i1018 = i1570 - 1 + if (i1018 > 0) newline(pp) end - pretty_relation_id(pp, elem1012) + pretty_relation_id(pp, elem1017) end end newline(pp) - field1014 = unwrapped_fields1010[2] - pretty_script(pp, field1014) + field1019 = unwrapped_fields1015[2] + pretty_script(pp, field1019) dedent!(pp) write(pp, ")") end @@ -2946,28 +2946,28 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1020 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1020) - write(pp, flat1020) + flat1025 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1025) + write(pp, flat1025) return nothing else - function _t1561(_dollar_dollar) + function _t1571(_dollar_dollar) return _dollar_dollar.constructs end - _t1562 = _t1561(msg) - fields1016 = _t1562 - unwrapped_fields1017 = fields1016 + _t1572 = _t1571(msg) + fields1021 = _t1572 + unwrapped_fields1022 = fields1021 write(pp, "(") write(pp, "script") indent_sexp!(pp) - if !isempty(unwrapped_fields1017) + if !isempty(unwrapped_fields1022) newline(pp) - for (i1563, elem1018) in enumerate(unwrapped_fields1017) - i1019 = i1563 - 1 - if (i1019 > 0) + for (i1573, elem1023) in enumerate(unwrapped_fields1022) + i1024 = i1573 - 1 + if (i1024 > 0) newline(pp) end - pretty_construct(pp, elem1018) + pretty_construct(pp, elem1023) end end dedent!(pp) @@ -2977,38 +2977,38 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1025 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1025) - write(pp, flat1025) + flat1030 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1030) + write(pp, flat1030) return nothing else - function _t1564(_dollar_dollar) + function _t1574(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1565 = _get_oneof_field(_dollar_dollar, :loop) + _t1575 = _get_oneof_field(_dollar_dollar, :loop) else - _t1565 = nothing + _t1575 = nothing end - return _t1565 + return _t1575 end - _t1566 = _t1564(msg) - deconstruct_result1023 = _t1566 - if !isnothing(deconstruct_result1023) - unwrapped1024 = deconstruct_result1023 - pretty_loop(pp, unwrapped1024) + _t1576 = _t1574(msg) + deconstruct_result1028 = _t1576 + if !isnothing(deconstruct_result1028) + unwrapped1029 = deconstruct_result1028 + pretty_loop(pp, unwrapped1029) else - function _t1567(_dollar_dollar) + function _t1577(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1568 = _get_oneof_field(_dollar_dollar, :instruction) + _t1578 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1568 = nothing + _t1578 = nothing end - return _t1568 + return _t1578 end - _t1569 = _t1567(msg) - deconstruct_result1021 = _t1569 - if !isnothing(deconstruct_result1021) - unwrapped1022 = deconstruct_result1021 - pretty_instruction(pp, unwrapped1022) + _t1579 = _t1577(msg) + deconstruct_result1026 = _t1579 + if !isnothing(deconstruct_result1026) + unwrapped1027 = deconstruct_result1026 + pretty_instruction(pp, unwrapped1027) else throw(ParseError("No matching rule for construct")) end @@ -3018,26 +3018,26 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1030 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1030) - write(pp, flat1030) + flat1035 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1035) + write(pp, flat1035) return nothing else - function _t1570(_dollar_dollar) + function _t1580(_dollar_dollar) return (_dollar_dollar.init, _dollar_dollar.body,) end - _t1571 = _t1570(msg) - fields1026 = _t1571 - unwrapped_fields1027 = fields1026 + _t1581 = _t1580(msg) + fields1031 = _t1581 + unwrapped_fields1032 = fields1031 write(pp, "(") write(pp, "loop") indent_sexp!(pp) newline(pp) - field1028 = unwrapped_fields1027[1] - pretty_init(pp, field1028) + field1033 = unwrapped_fields1032[1] + pretty_init(pp, field1033) newline(pp) - field1029 = unwrapped_fields1027[2] - pretty_script(pp, field1029) + field1034 = unwrapped_fields1032[2] + pretty_script(pp, field1034) dedent!(pp) write(pp, ")") end @@ -3045,23 +3045,23 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1034 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1034) - write(pp, flat1034) + flat1039 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1039) + write(pp, flat1039) return nothing else - fields1031 = msg + fields1036 = msg write(pp, "(") write(pp, "init") indent_sexp!(pp) - if !isempty(fields1031) + if !isempty(fields1036) newline(pp) - for (i1572, elem1032) in enumerate(fields1031) - i1033 = i1572 - 1 - if (i1033 > 0) + for (i1582, elem1037) in enumerate(fields1036) + i1038 = i1582 - 1 + if (i1038 > 0) newline(pp) end - pretty_instruction(pp, elem1032) + pretty_instruction(pp, elem1037) end end dedent!(pp) @@ -3071,80 +3071,80 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1045 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1045) - write(pp, flat1045) + flat1050 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1050) + write(pp, flat1050) return nothing else - function _t1573(_dollar_dollar) + function _t1583(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1574 = _get_oneof_field(_dollar_dollar, :assign) + _t1584 = _get_oneof_field(_dollar_dollar, :assign) else - _t1574 = nothing + _t1584 = nothing end - return _t1574 + return _t1584 end - _t1575 = _t1573(msg) - deconstruct_result1043 = _t1575 - if !isnothing(deconstruct_result1043) - unwrapped1044 = deconstruct_result1043 - pretty_assign(pp, unwrapped1044) + _t1585 = _t1583(msg) + deconstruct_result1048 = _t1585 + if !isnothing(deconstruct_result1048) + unwrapped1049 = deconstruct_result1048 + pretty_assign(pp, unwrapped1049) else - function _t1576(_dollar_dollar) + function _t1586(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1577 = _get_oneof_field(_dollar_dollar, :upsert) + _t1587 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1577 = nothing + _t1587 = nothing end - return _t1577 + return _t1587 end - _t1578 = _t1576(msg) - deconstruct_result1041 = _t1578 - if !isnothing(deconstruct_result1041) - unwrapped1042 = deconstruct_result1041 - pretty_upsert(pp, unwrapped1042) + _t1588 = _t1586(msg) + deconstruct_result1046 = _t1588 + if !isnothing(deconstruct_result1046) + unwrapped1047 = deconstruct_result1046 + pretty_upsert(pp, unwrapped1047) else - function _t1579(_dollar_dollar) + function _t1589(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1580 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1590 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1580 = nothing + _t1590 = nothing end - return _t1580 + return _t1590 end - _t1581 = _t1579(msg) - deconstruct_result1039 = _t1581 - if !isnothing(deconstruct_result1039) - unwrapped1040 = deconstruct_result1039 - pretty_break(pp, unwrapped1040) + _t1591 = _t1589(msg) + deconstruct_result1044 = _t1591 + if !isnothing(deconstruct_result1044) + unwrapped1045 = deconstruct_result1044 + pretty_break(pp, unwrapped1045) else - function _t1582(_dollar_dollar) + function _t1592(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1583 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1593 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1583 = nothing + _t1593 = nothing end - return _t1583 + return _t1593 end - _t1584 = _t1582(msg) - deconstruct_result1037 = _t1584 - if !isnothing(deconstruct_result1037) - unwrapped1038 = deconstruct_result1037 - pretty_monoid_def(pp, unwrapped1038) + _t1594 = _t1592(msg) + deconstruct_result1042 = _t1594 + if !isnothing(deconstruct_result1042) + unwrapped1043 = deconstruct_result1042 + pretty_monoid_def(pp, unwrapped1043) else - function _t1585(_dollar_dollar) + function _t1595(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1586 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1596 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1586 = nothing + _t1596 = nothing end - return _t1586 + return _t1596 end - _t1587 = _t1585(msg) - deconstruct_result1035 = _t1587 - if !isnothing(deconstruct_result1035) - unwrapped1036 = deconstruct_result1035 - pretty_monus_def(pp, unwrapped1036) + _t1597 = _t1595(msg) + deconstruct_result1040 = _t1597 + if !isnothing(deconstruct_result1040) + unwrapped1041 = deconstruct_result1040 + pretty_monus_def(pp, unwrapped1041) else throw(ParseError("No matching rule for instruction")) end @@ -3157,36 +3157,36 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1052 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1052) - write(pp, flat1052) + flat1057 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1057) + write(pp, flat1057) return nothing else - function _t1588(_dollar_dollar) + function _t1598(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1589 = _dollar_dollar.attrs + _t1599 = _dollar_dollar.attrs else - _t1589 = nothing + _t1599 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1589,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1599,) end - _t1590 = _t1588(msg) - fields1046 = _t1590 - unwrapped_fields1047 = fields1046 + _t1600 = _t1598(msg) + fields1051 = _t1600 + unwrapped_fields1052 = fields1051 write(pp, "(") write(pp, "assign") indent_sexp!(pp) newline(pp) - field1048 = unwrapped_fields1047[1] - pretty_relation_id(pp, field1048) + field1053 = unwrapped_fields1052[1] + pretty_relation_id(pp, field1053) newline(pp) - field1049 = unwrapped_fields1047[2] - pretty_abstraction(pp, field1049) - field1050 = unwrapped_fields1047[3] - if !isnothing(field1050) + field1054 = unwrapped_fields1052[2] + pretty_abstraction(pp, field1054) + field1055 = unwrapped_fields1052[3] + if !isnothing(field1055) newline(pp) - opt_val1051 = field1050 - pretty_attrs(pp, opt_val1051) + opt_val1056 = field1055 + pretty_attrs(pp, opt_val1056) end dedent!(pp) write(pp, ")") @@ -3195,36 +3195,36 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1059 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1059) - write(pp, flat1059) + flat1064 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1064) + write(pp, flat1064) return nothing else - function _t1591(_dollar_dollar) + function _t1601(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1592 = _dollar_dollar.attrs + _t1602 = _dollar_dollar.attrs else - _t1592 = nothing + _t1602 = nothing end - return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1592,) + return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1602,) end - _t1593 = _t1591(msg) - fields1053 = _t1593 - unwrapped_fields1054 = fields1053 + _t1603 = _t1601(msg) + fields1058 = _t1603 + unwrapped_fields1059 = fields1058 write(pp, "(") write(pp, "upsert") indent_sexp!(pp) newline(pp) - field1055 = unwrapped_fields1054[1] - pretty_relation_id(pp, field1055) + field1060 = unwrapped_fields1059[1] + pretty_relation_id(pp, field1060) newline(pp) - field1056 = unwrapped_fields1054[2] - pretty_abstraction_with_arity(pp, field1056) - field1057 = unwrapped_fields1054[3] - if !isnothing(field1057) + field1061 = unwrapped_fields1059[2] + pretty_abstraction_with_arity(pp, field1061) + field1062 = unwrapped_fields1059[3] + if !isnothing(field1062) newline(pp) - opt_val1058 = field1057 - pretty_attrs(pp, opt_val1058) + opt_val1063 = field1062 + pretty_attrs(pp, opt_val1063) end dedent!(pp) write(pp, ")") @@ -3233,25 +3233,25 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1064 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1064) - write(pp, flat1064) + flat1069 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1069) + write(pp, flat1069) return nothing else - function _t1594(_dollar_dollar) - _t1595 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - return (_t1595, _dollar_dollar[1].value,) + function _t1604(_dollar_dollar) + _t1605 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + return (_t1605, _dollar_dollar[1].value,) end - _t1596 = _t1594(msg) - fields1060 = _t1596 - unwrapped_fields1061 = fields1060 + _t1606 = _t1604(msg) + fields1065 = _t1606 + unwrapped_fields1066 = fields1065 write(pp, "(") indent!(pp) - field1062 = unwrapped_fields1061[1] - pretty_bindings(pp, field1062) + field1067 = unwrapped_fields1066[1] + pretty_bindings(pp, field1067) newline(pp) - field1063 = unwrapped_fields1061[2] - pretty_formula(pp, field1063) + field1068 = unwrapped_fields1066[2] + pretty_formula(pp, field1068) dedent!(pp) write(pp, ")") end @@ -3259,36 +3259,36 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1071 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1071) - write(pp, flat1071) + flat1076 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1076) + write(pp, flat1076) return nothing else - function _t1597(_dollar_dollar) + function _t1607(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1598 = _dollar_dollar.attrs + _t1608 = _dollar_dollar.attrs else - _t1598 = nothing + _t1608 = nothing end - return (_dollar_dollar.name, _dollar_dollar.body, _t1598,) + return (_dollar_dollar.name, _dollar_dollar.body, _t1608,) end - _t1599 = _t1597(msg) - fields1065 = _t1599 - unwrapped_fields1066 = fields1065 + _t1609 = _t1607(msg) + fields1070 = _t1609 + unwrapped_fields1071 = fields1070 write(pp, "(") write(pp, "break") indent_sexp!(pp) newline(pp) - field1067 = unwrapped_fields1066[1] - pretty_relation_id(pp, field1067) + field1072 = unwrapped_fields1071[1] + pretty_relation_id(pp, field1072) newline(pp) - field1068 = unwrapped_fields1066[2] - pretty_abstraction(pp, field1068) - field1069 = unwrapped_fields1066[3] - if !isnothing(field1069) + field1073 = unwrapped_fields1071[2] + pretty_abstraction(pp, field1073) + field1074 = unwrapped_fields1071[3] + if !isnothing(field1074) newline(pp) - opt_val1070 = field1069 - pretty_attrs(pp, opt_val1070) + opt_val1075 = field1074 + pretty_attrs(pp, opt_val1075) end dedent!(pp) write(pp, ")") @@ -3297,39 +3297,39 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1079 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1079) - write(pp, flat1079) + flat1084 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1084) + write(pp, flat1084) return nothing else - function _t1600(_dollar_dollar) + function _t1610(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1601 = _dollar_dollar.attrs + _t1611 = _dollar_dollar.attrs else - _t1601 = nothing + _t1611 = nothing end - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1601,) + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1611,) end - _t1602 = _t1600(msg) - fields1072 = _t1602 - unwrapped_fields1073 = fields1072 + _t1612 = _t1610(msg) + fields1077 = _t1612 + unwrapped_fields1078 = fields1077 write(pp, "(") write(pp, "monoid") indent_sexp!(pp) newline(pp) - field1074 = unwrapped_fields1073[1] - pretty_monoid(pp, field1074) + field1079 = unwrapped_fields1078[1] + pretty_monoid(pp, field1079) newline(pp) - field1075 = unwrapped_fields1073[2] - pretty_relation_id(pp, field1075) + field1080 = unwrapped_fields1078[2] + pretty_relation_id(pp, field1080) newline(pp) - field1076 = unwrapped_fields1073[3] - pretty_abstraction_with_arity(pp, field1076) - field1077 = unwrapped_fields1073[4] - if !isnothing(field1077) + field1081 = unwrapped_fields1078[3] + pretty_abstraction_with_arity(pp, field1081) + field1082 = unwrapped_fields1078[4] + if !isnothing(field1082) newline(pp) - opt_val1078 = field1077 - pretty_attrs(pp, opt_val1078) + opt_val1083 = field1082 + pretty_attrs(pp, opt_val1083) end dedent!(pp) write(pp, ")") @@ -3338,66 +3338,66 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1088 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1088) - write(pp, flat1088) + flat1093 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1093) + write(pp, flat1093) return nothing else - function _t1603(_dollar_dollar) + function _t1613(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1604 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1614 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1604 = nothing + _t1614 = nothing end - return _t1604 + return _t1614 end - _t1605 = _t1603(msg) - deconstruct_result1086 = _t1605 - if !isnothing(deconstruct_result1086) - unwrapped1087 = deconstruct_result1086 - pretty_or_monoid(pp, unwrapped1087) + _t1615 = _t1613(msg) + deconstruct_result1091 = _t1615 + if !isnothing(deconstruct_result1091) + unwrapped1092 = deconstruct_result1091 + pretty_or_monoid(pp, unwrapped1092) else - function _t1606(_dollar_dollar) + function _t1616(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1607 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1617 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1607 = nothing + _t1617 = nothing end - return _t1607 + return _t1617 end - _t1608 = _t1606(msg) - deconstruct_result1084 = _t1608 - if !isnothing(deconstruct_result1084) - unwrapped1085 = deconstruct_result1084 - pretty_min_monoid(pp, unwrapped1085) + _t1618 = _t1616(msg) + deconstruct_result1089 = _t1618 + if !isnothing(deconstruct_result1089) + unwrapped1090 = deconstruct_result1089 + pretty_min_monoid(pp, unwrapped1090) else - function _t1609(_dollar_dollar) + function _t1619(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1610 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1620 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1610 = nothing + _t1620 = nothing end - return _t1610 + return _t1620 end - _t1611 = _t1609(msg) - deconstruct_result1082 = _t1611 - if !isnothing(deconstruct_result1082) - unwrapped1083 = deconstruct_result1082 - pretty_max_monoid(pp, unwrapped1083) + _t1621 = _t1619(msg) + deconstruct_result1087 = _t1621 + if !isnothing(deconstruct_result1087) + unwrapped1088 = deconstruct_result1087 + pretty_max_monoid(pp, unwrapped1088) else - function _t1612(_dollar_dollar) + function _t1622(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1613 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1623 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1613 = nothing + _t1623 = nothing end - return _t1613 + return _t1623 end - _t1614 = _t1612(msg) - deconstruct_result1080 = _t1614 - if !isnothing(deconstruct_result1080) - unwrapped1081 = deconstruct_result1080 - pretty_sum_monoid(pp, unwrapped1081) + _t1624 = _t1622(msg) + deconstruct_result1085 = _t1624 + if !isnothing(deconstruct_result1085) + unwrapped1086 = deconstruct_result1085 + pretty_sum_monoid(pp, unwrapped1086) else throw(ParseError("No matching rule for monoid")) end @@ -3409,7 +3409,7 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1089 = msg + fields1094 = msg write(pp, "(") write(pp, "or") write(pp, ")") @@ -3417,22 +3417,22 @@ function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1092 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1092) - write(pp, flat1092) + flat1097 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1097) + write(pp, flat1097) return nothing else - function _t1615(_dollar_dollar) + function _t1625(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1616 = _t1615(msg) - fields1090 = _t1616 - unwrapped_fields1091 = fields1090 + _t1626 = _t1625(msg) + fields1095 = _t1626 + unwrapped_fields1096 = fields1095 write(pp, "(") write(pp, "min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1091) + pretty_type(pp, unwrapped_fields1096) dedent!(pp) write(pp, ")") end @@ -3440,22 +3440,22 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1095 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1095) - write(pp, flat1095) + flat1100 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1100) + write(pp, flat1100) return nothing else - function _t1617(_dollar_dollar) + function _t1627(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1618 = _t1617(msg) - fields1093 = _t1618 - unwrapped_fields1094 = fields1093 + _t1628 = _t1627(msg) + fields1098 = _t1628 + unwrapped_fields1099 = fields1098 write(pp, "(") write(pp, "max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1094) + pretty_type(pp, unwrapped_fields1099) dedent!(pp) write(pp, ")") end @@ -3463,22 +3463,22 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1098 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1098) - write(pp, flat1098) + flat1103 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1103) + write(pp, flat1103) return nothing else - function _t1619(_dollar_dollar) + function _t1629(_dollar_dollar) return _dollar_dollar.var"#type" end - _t1620 = _t1619(msg) - fields1096 = _t1620 - unwrapped_fields1097 = fields1096 + _t1630 = _t1629(msg) + fields1101 = _t1630 + unwrapped_fields1102 = fields1101 write(pp, "(") write(pp, "sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1097) + pretty_type(pp, unwrapped_fields1102) dedent!(pp) write(pp, ")") end @@ -3486,39 +3486,39 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1106 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1106) - write(pp, flat1106) + flat1111 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1111) + write(pp, flat1111) return nothing else - function _t1621(_dollar_dollar) + function _t1631(_dollar_dollar) if !isempty(_dollar_dollar.attrs) - _t1622 = _dollar_dollar.attrs + _t1632 = _dollar_dollar.attrs else - _t1622 = nothing + _t1632 = nothing end - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1622,) + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1632,) end - _t1623 = _t1621(msg) - fields1099 = _t1623 - unwrapped_fields1100 = fields1099 + _t1633 = _t1631(msg) + fields1104 = _t1633 + unwrapped_fields1105 = fields1104 write(pp, "(") write(pp, "monus") indent_sexp!(pp) newline(pp) - field1101 = unwrapped_fields1100[1] - pretty_monoid(pp, field1101) + field1106 = unwrapped_fields1105[1] + pretty_monoid(pp, field1106) newline(pp) - field1102 = unwrapped_fields1100[2] - pretty_relation_id(pp, field1102) + field1107 = unwrapped_fields1105[2] + pretty_relation_id(pp, field1107) newline(pp) - field1103 = unwrapped_fields1100[3] - pretty_abstraction_with_arity(pp, field1103) - field1104 = unwrapped_fields1100[4] - if !isnothing(field1104) + field1108 = unwrapped_fields1105[3] + pretty_abstraction_with_arity(pp, field1108) + field1109 = unwrapped_fields1105[4] + if !isnothing(field1109) newline(pp) - opt_val1105 = field1104 - pretty_attrs(pp, opt_val1105) + opt_val1110 = field1109 + pretty_attrs(pp, opt_val1110) end dedent!(pp) write(pp, ")") @@ -3527,32 +3527,32 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1113 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1113) - write(pp, flat1113) + flat1118 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1118) + write(pp, flat1118) return nothing else - function _t1624(_dollar_dollar) + function _t1634(_dollar_dollar) return (_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,) end - _t1625 = _t1624(msg) - fields1107 = _t1625 - unwrapped_fields1108 = fields1107 + _t1635 = _t1634(msg) + fields1112 = _t1635 + unwrapped_fields1113 = fields1112 write(pp, "(") write(pp, "functional_dependency") indent_sexp!(pp) newline(pp) - field1109 = unwrapped_fields1108[1] - pretty_relation_id(pp, field1109) + field1114 = unwrapped_fields1113[1] + pretty_relation_id(pp, field1114) newline(pp) - field1110 = unwrapped_fields1108[2] - pretty_abstraction(pp, field1110) + field1115 = unwrapped_fields1113[2] + pretty_abstraction(pp, field1115) newline(pp) - field1111 = unwrapped_fields1108[3] - pretty_functional_dependency_keys(pp, field1111) + field1116 = unwrapped_fields1113[3] + pretty_functional_dependency_keys(pp, field1116) newline(pp) - field1112 = unwrapped_fields1108[4] - pretty_functional_dependency_values(pp, field1112) + field1117 = unwrapped_fields1113[4] + pretty_functional_dependency_values(pp, field1117) dedent!(pp) write(pp, ")") end @@ -3560,23 +3560,23 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1117 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1117) - write(pp, flat1117) + flat1122 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1122) + write(pp, flat1122) return nothing else - fields1114 = msg + fields1119 = msg write(pp, "(") write(pp, "keys") indent_sexp!(pp) - if !isempty(fields1114) + if !isempty(fields1119) newline(pp) - for (i1626, elem1115) in enumerate(fields1114) - i1116 = i1626 - 1 - if (i1116 > 0) + for (i1636, elem1120) in enumerate(fields1119) + i1121 = i1636 - 1 + if (i1121 > 0) newline(pp) end - pretty_var(pp, elem1115) + pretty_var(pp, elem1120) end end dedent!(pp) @@ -3586,23 +3586,23 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1121 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1121) - write(pp, flat1121) + flat1126 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1126) + write(pp, flat1126) return nothing else - fields1118 = msg + fields1123 = msg write(pp, "(") write(pp, "values") indent_sexp!(pp) - if !isempty(fields1118) + if !isempty(fields1123) newline(pp) - for (i1627, elem1119) in enumerate(fields1118) - i1120 = i1627 - 1 - if (i1120 > 0) + for (i1637, elem1124) in enumerate(fields1123) + i1125 = i1637 - 1 + if (i1125 > 0) newline(pp) end - pretty_var(pp, elem1119) + pretty_var(pp, elem1124) end end dedent!(pp) @@ -3612,52 +3612,52 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1128 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1128) - write(pp, flat1128) + flat1133 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1133) + write(pp, flat1133) return nothing else - function _t1628(_dollar_dollar) + function _t1638(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1629 = _get_oneof_field(_dollar_dollar, :edb) + _t1639 = _get_oneof_field(_dollar_dollar, :edb) else - _t1629 = nothing + _t1639 = nothing end - return _t1629 + return _t1639 end - _t1630 = _t1628(msg) - deconstruct_result1126 = _t1630 - if !isnothing(deconstruct_result1126) - unwrapped1127 = deconstruct_result1126 - pretty_edb(pp, unwrapped1127) + _t1640 = _t1638(msg) + deconstruct_result1131 = _t1640 + if !isnothing(deconstruct_result1131) + unwrapped1132 = deconstruct_result1131 + pretty_edb(pp, unwrapped1132) else - function _t1631(_dollar_dollar) + function _t1641(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1632 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1642 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1632 = nothing + _t1642 = nothing end - return _t1632 + return _t1642 end - _t1633 = _t1631(msg) - deconstruct_result1124 = _t1633 - if !isnothing(deconstruct_result1124) - unwrapped1125 = deconstruct_result1124 - pretty_betree_relation(pp, unwrapped1125) + _t1643 = _t1641(msg) + deconstruct_result1129 = _t1643 + if !isnothing(deconstruct_result1129) + unwrapped1130 = deconstruct_result1129 + pretty_betree_relation(pp, unwrapped1130) else - function _t1634(_dollar_dollar) + function _t1644(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1635 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1645 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1635 = nothing + _t1645 = nothing end - return _t1635 + return _t1645 end - _t1636 = _t1634(msg) - deconstruct_result1122 = _t1636 - if !isnothing(deconstruct_result1122) - unwrapped1123 = deconstruct_result1122 - pretty_csv_data(pp, unwrapped1123) + _t1646 = _t1644(msg) + deconstruct_result1127 = _t1646 + if !isnothing(deconstruct_result1127) + unwrapped1128 = deconstruct_result1127 + pretty_csv_data(pp, unwrapped1128) else throw(ParseError("No matching rule for data")) end @@ -3668,29 +3668,29 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1134 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1134) - write(pp, flat1134) + flat1139 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1139) + write(pp, flat1139) return nothing else - function _t1637(_dollar_dollar) + function _t1647(_dollar_dollar) return (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) end - _t1638 = _t1637(msg) - fields1129 = _t1638 - unwrapped_fields1130 = fields1129 + _t1648 = _t1647(msg) + fields1134 = _t1648 + unwrapped_fields1135 = fields1134 write(pp, "(") write(pp, "edb") indent_sexp!(pp) newline(pp) - field1131 = unwrapped_fields1130[1] - pretty_relation_id(pp, field1131) + field1136 = unwrapped_fields1135[1] + pretty_relation_id(pp, field1136) newline(pp) - field1132 = unwrapped_fields1130[2] - pretty_edb_path(pp, field1132) + field1137 = unwrapped_fields1135[2] + pretty_edb_path(pp, field1137) newline(pp) - field1133 = unwrapped_fields1130[3] - pretty_edb_types(pp, field1133) + field1138 = unwrapped_fields1135[3] + pretty_edb_types(pp, field1138) dedent!(pp) write(pp, ")") end @@ -3698,20 +3698,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1138 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1138) - write(pp, flat1138) + flat1143 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1143) + write(pp, flat1143) return nothing else - fields1135 = msg + fields1140 = msg write(pp, "[") indent!(pp) - for (i1639, elem1136) in enumerate(fields1135) - i1137 = i1639 - 1 - if (i1137 > 0) + for (i1649, elem1141) in enumerate(fields1140) + i1142 = i1649 - 1 + if (i1142 > 0) newline(pp) end - write(pp, format_string(pp, elem1136)) + write(pp, format_string(pp, elem1141)) end dedent!(pp) write(pp, "]") @@ -3720,20 +3720,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1142 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1142) - write(pp, flat1142) + flat1147 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1147) + write(pp, flat1147) return nothing else - fields1139 = msg + fields1144 = msg write(pp, "[") indent!(pp) - for (i1640, elem1140) in enumerate(fields1139) - i1141 = i1640 - 1 - if (i1141 > 0) + for (i1650, elem1145) in enumerate(fields1144) + i1146 = i1650 - 1 + if (i1146 > 0) newline(pp) end - pretty_type(pp, elem1140) + pretty_type(pp, elem1145) end dedent!(pp) write(pp, "]") @@ -3742,26 +3742,26 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1147 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1147) - write(pp, flat1147) + flat1152 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1152) + write(pp, flat1152) return nothing else - function _t1641(_dollar_dollar) + function _t1651(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.relation_info,) end - _t1642 = _t1641(msg) - fields1143 = _t1642 - unwrapped_fields1144 = fields1143 + _t1652 = _t1651(msg) + fields1148 = _t1652 + unwrapped_fields1149 = fields1148 write(pp, "(") write(pp, "betree_relation") indent_sexp!(pp) newline(pp) - field1145 = unwrapped_fields1144[1] - pretty_relation_id(pp, field1145) + field1150 = unwrapped_fields1149[1] + pretty_relation_id(pp, field1150) newline(pp) - field1146 = unwrapped_fields1144[2] - pretty_betree_info(pp, field1146) + field1151 = unwrapped_fields1149[2] + pretty_betree_info(pp, field1151) dedent!(pp) write(pp, ")") end @@ -3769,30 +3769,30 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1153 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1153) - write(pp, flat1153) + flat1158 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1158) + write(pp, flat1158) return nothing else - function _t1643(_dollar_dollar) - _t1644 = deconstruct_betree_info_config(pp, _dollar_dollar) - return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1644,) + function _t1653(_dollar_dollar) + _t1654 = deconstruct_betree_info_config(pp, _dollar_dollar) + return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1654,) end - _t1645 = _t1643(msg) - fields1148 = _t1645 - unwrapped_fields1149 = fields1148 + _t1655 = _t1653(msg) + fields1153 = _t1655 + unwrapped_fields1154 = fields1153 write(pp, "(") write(pp, "betree_info") indent_sexp!(pp) newline(pp) - field1150 = unwrapped_fields1149[1] - pretty_betree_info_key_types(pp, field1150) + field1155 = unwrapped_fields1154[1] + pretty_betree_info_key_types(pp, field1155) newline(pp) - field1151 = unwrapped_fields1149[2] - pretty_betree_info_value_types(pp, field1151) + field1156 = unwrapped_fields1154[2] + pretty_betree_info_value_types(pp, field1156) newline(pp) - field1152 = unwrapped_fields1149[3] - pretty_config_dict(pp, field1152) + field1157 = unwrapped_fields1154[3] + pretty_config_dict(pp, field1157) dedent!(pp) write(pp, ")") end @@ -3800,23 +3800,23 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1157 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1157) - write(pp, flat1157) + flat1162 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1162) + write(pp, flat1162) return nothing else - fields1154 = msg + fields1159 = msg write(pp, "(") write(pp, "key_types") indent_sexp!(pp) - if !isempty(fields1154) + if !isempty(fields1159) newline(pp) - for (i1646, elem1155) in enumerate(fields1154) - i1156 = i1646 - 1 - if (i1156 > 0) + for (i1656, elem1160) in enumerate(fields1159) + i1161 = i1656 - 1 + if (i1161 > 0) newline(pp) end - pretty_type(pp, elem1155) + pretty_type(pp, elem1160) end end dedent!(pp) @@ -3826,23 +3826,23 @@ 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"}) - flat1161 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1161) - write(pp, flat1161) + flat1166 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1166) + write(pp, flat1166) return nothing else - fields1158 = msg + fields1163 = msg write(pp, "(") write(pp, "value_types") indent_sexp!(pp) - if !isempty(fields1158) + if !isempty(fields1163) newline(pp) - for (i1647, elem1159) in enumerate(fields1158) - i1160 = i1647 - 1 - if (i1160 > 0) + for (i1657, elem1164) in enumerate(fields1163) + i1165 = i1657 - 1 + if (i1165 > 0) newline(pp) end - pretty_type(pp, elem1159) + pretty_type(pp, elem1164) end end dedent!(pp) @@ -3852,32 +3852,32 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1168 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1168) - write(pp, flat1168) + flat1173 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1173) + write(pp, flat1173) return nothing else - function _t1648(_dollar_dollar) + function _t1658(_dollar_dollar) return (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) end - _t1649 = _t1648(msg) - fields1162 = _t1649 - unwrapped_fields1163 = fields1162 + _t1659 = _t1658(msg) + fields1167 = _t1659 + unwrapped_fields1168 = fields1167 write(pp, "(") write(pp, "csv_data") indent_sexp!(pp) newline(pp) - field1164 = unwrapped_fields1163[1] - pretty_csvlocator(pp, field1164) + field1169 = unwrapped_fields1168[1] + pretty_csvlocator(pp, field1169) newline(pp) - field1165 = unwrapped_fields1163[2] - pretty_csv_config(pp, field1165) + field1170 = unwrapped_fields1168[2] + pretty_csv_config(pp, field1170) newline(pp) - field1166 = unwrapped_fields1163[3] - pretty_gnf_columns(pp, field1166) + field1171 = unwrapped_fields1168[3] + pretty_gnf_columns(pp, field1171) newline(pp) - field1167 = unwrapped_fields1163[4] - pretty_csv_asof(pp, field1167) + field1172 = unwrapped_fields1168[4] + pretty_csv_asof(pp, field1172) dedent!(pp) write(pp, ")") end @@ -3885,41 +3885,41 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1175 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1175) - write(pp, flat1175) + flat1180 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1180) + write(pp, flat1180) return nothing else - function _t1650(_dollar_dollar) + function _t1660(_dollar_dollar) if !isempty(_dollar_dollar.paths) - _t1651 = _dollar_dollar.paths + _t1661 = _dollar_dollar.paths else - _t1651 = nothing + _t1661 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1652 = String(copy(_dollar_dollar.inline_data)) + _t1662 = String(copy(_dollar_dollar.inline_data)) else - _t1652 = nothing + _t1662 = nothing end - return (_t1651, _t1652,) + return (_t1661, _t1662,) end - _t1653 = _t1650(msg) - fields1169 = _t1653 - unwrapped_fields1170 = fields1169 + _t1663 = _t1660(msg) + fields1174 = _t1663 + unwrapped_fields1175 = fields1174 write(pp, "(") write(pp, "csv_locator") indent_sexp!(pp) - field1171 = unwrapped_fields1170[1] - if !isnothing(field1171) + field1176 = unwrapped_fields1175[1] + if !isnothing(field1176) newline(pp) - opt_val1172 = field1171 - pretty_csv_locator_paths(pp, opt_val1172) + opt_val1177 = field1176 + pretty_csv_locator_paths(pp, opt_val1177) end - field1173 = unwrapped_fields1170[2] - if !isnothing(field1173) + field1178 = unwrapped_fields1175[2] + if !isnothing(field1178) newline(pp) - opt_val1174 = field1173 - pretty_csv_locator_inline_data(pp, opt_val1174) + opt_val1179 = field1178 + pretty_csv_locator_inline_data(pp, opt_val1179) end dedent!(pp) write(pp, ")") @@ -3928,23 +3928,23 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1179 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1179) - write(pp, flat1179) + flat1184 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1184) + write(pp, flat1184) return nothing else - fields1176 = msg + fields1181 = msg write(pp, "(") write(pp, "paths") indent_sexp!(pp) - if !isempty(fields1176) + if !isempty(fields1181) newline(pp) - for (i1654, elem1177) in enumerate(fields1176) - i1178 = i1654 - 1 - if (i1178 > 0) + for (i1664, elem1182) in enumerate(fields1181) + i1183 = i1664 - 1 + if (i1183 > 0) newline(pp) end - write(pp, format_string(pp, elem1177)) + write(pp, format_string(pp, elem1182)) end end dedent!(pp) @@ -3954,17 +3954,17 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1181 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1181) - write(pp, flat1181) + flat1186 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1186) + write(pp, flat1186) return nothing else - fields1180 = msg + fields1185 = msg write(pp, "(") write(pp, "inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1180)) + write(pp, format_string(pp, fields1185)) dedent!(pp) write(pp, ")") end @@ -3972,23 +3972,23 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1184 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1184) - write(pp, flat1184) + flat1189 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1189) + write(pp, flat1189) return nothing else - function _t1655(_dollar_dollar) - _t1656 = deconstruct_csv_config(pp, _dollar_dollar) - return _t1656 + function _t1665(_dollar_dollar) + _t1666 = deconstruct_csv_config(pp, _dollar_dollar) + return _t1666 end - _t1657 = _t1655(msg) - fields1182 = _t1657 - unwrapped_fields1183 = fields1182 + _t1667 = _t1665(msg) + fields1187 = _t1667 + unwrapped_fields1188 = fields1187 write(pp, "(") write(pp, "csv_config") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields1183) + pretty_config_dict(pp, unwrapped_fields1188) dedent!(pp) write(pp, ")") end @@ -3996,23 +3996,23 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1188 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1188) - write(pp, flat1188) + flat1193 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1193) + write(pp, flat1193) return nothing else - fields1185 = msg + fields1190 = msg write(pp, "(") write(pp, "columns") indent_sexp!(pp) - if !isempty(fields1185) + if !isempty(fields1190) newline(pp) - for (i1658, elem1186) in enumerate(fields1185) - i1187 = i1658 - 1 - if (i1187 > 0) + for (i1668, elem1191) in enumerate(fields1190) + i1192 = i1668 - 1 + if (i1192 > 0) newline(pp) end - pretty_gnf_column(pp, elem1186) + pretty_gnf_column(pp, elem1191) end end dedent!(pp) @@ -4022,43 +4022,43 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1197 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1197) - write(pp, flat1197) + flat1202 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1202) + write(pp, flat1202) return nothing else - function _t1659(_dollar_dollar) + function _t1669(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1660 = _dollar_dollar.target_id + _t1670 = _dollar_dollar.target_id else - _t1660 = nothing + _t1670 = nothing end - return (_dollar_dollar.column_path, _t1660, _dollar_dollar.types,) + return (_dollar_dollar.column_path, _t1670, _dollar_dollar.types,) end - _t1661 = _t1659(msg) - fields1189 = _t1661 - unwrapped_fields1190 = fields1189 + _t1671 = _t1669(msg) + fields1194 = _t1671 + unwrapped_fields1195 = fields1194 write(pp, "(") write(pp, "column") indent_sexp!(pp) newline(pp) - field1191 = unwrapped_fields1190[1] - pretty_gnf_column_path(pp, field1191) - field1192 = unwrapped_fields1190[2] - if !isnothing(field1192) + field1196 = unwrapped_fields1195[1] + pretty_gnf_column_path(pp, field1196) + field1197 = unwrapped_fields1195[2] + if !isnothing(field1197) newline(pp) - opt_val1193 = field1192 - pretty_relation_id(pp, opt_val1193) + opt_val1198 = field1197 + pretty_relation_id(pp, opt_val1198) end newline(pp) write(pp, "[") - field1194 = unwrapped_fields1190[3] - for (i1662, elem1195) in enumerate(field1194) - i1196 = i1662 - 1 - if (i1196 > 0) + field1199 = unwrapped_fields1195[3] + for (i1672, elem1200) in enumerate(field1199) + i1201 = i1672 - 1 + if (i1201 > 0) newline(pp) end - pretty_type(pp, elem1195) + pretty_type(pp, elem1200) end write(pp, "]") dedent!(pp) @@ -4068,45 +4068,45 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1204 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1204) - write(pp, flat1204) + flat1209 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1209) + write(pp, flat1209) return nothing else - function _t1663(_dollar_dollar) + function _t1673(_dollar_dollar) if length(_dollar_dollar) == 1 - _t1664 = _dollar_dollar[1] + _t1674 = _dollar_dollar[1] else - _t1664 = nothing + _t1674 = nothing end - return _t1664 + return _t1674 end - _t1665 = _t1663(msg) - deconstruct_result1202 = _t1665 - if !isnothing(deconstruct_result1202) - unwrapped1203 = deconstruct_result1202 - write(pp, format_string(pp, unwrapped1203)) + _t1675 = _t1673(msg) + deconstruct_result1207 = _t1675 + if !isnothing(deconstruct_result1207) + unwrapped1208 = deconstruct_result1207 + write(pp, format_string(pp, unwrapped1208)) else - function _t1666(_dollar_dollar) + function _t1676(_dollar_dollar) if length(_dollar_dollar) != 1 - _t1667 = _dollar_dollar + _t1677 = _dollar_dollar else - _t1667 = nothing + _t1677 = nothing end - return _t1667 + return _t1677 end - _t1668 = _t1666(msg) - deconstruct_result1198 = _t1668 - if !isnothing(deconstruct_result1198) - unwrapped1199 = deconstruct_result1198 + _t1678 = _t1676(msg) + deconstruct_result1203 = _t1678 + if !isnothing(deconstruct_result1203) + unwrapped1204 = deconstruct_result1203 write(pp, "[") indent!(pp) - for (i1669, elem1200) in enumerate(unwrapped1199) - i1201 = i1669 - 1 - if (i1201 > 0) + for (i1679, elem1205) in enumerate(unwrapped1204) + i1206 = i1679 - 1 + if (i1206 > 0) newline(pp) end - write(pp, format_string(pp, elem1200)) + write(pp, format_string(pp, elem1205)) end dedent!(pp) write(pp, "]") @@ -4119,17 +4119,17 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1206 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1206) - write(pp, flat1206) + flat1211 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1211) + write(pp, flat1211) return nothing else - fields1205 = msg + fields1210 = msg write(pp, "(") write(pp, "asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1205)) + write(pp, format_string(pp, fields1210)) dedent!(pp) write(pp, ")") end @@ -4137,22 +4137,22 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1209 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1209) - write(pp, flat1209) + flat1214 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1214) + write(pp, flat1214) return nothing else - function _t1670(_dollar_dollar) + function _t1680(_dollar_dollar) return _dollar_dollar.fragment_id end - _t1671 = _t1670(msg) - fields1207 = _t1671 - unwrapped_fields1208 = fields1207 + _t1681 = _t1680(msg) + fields1212 = _t1681 + unwrapped_fields1213 = fields1212 write(pp, "(") write(pp, "undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1208) + pretty_fragment_id(pp, unwrapped_fields1213) dedent!(pp) write(pp, ")") end @@ -4160,28 +4160,28 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1214 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1214) - write(pp, flat1214) + flat1219 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1219) + write(pp, flat1219) return nothing else - function _t1672(_dollar_dollar) + function _t1682(_dollar_dollar) return _dollar_dollar.relations end - _t1673 = _t1672(msg) - fields1210 = _t1673 - unwrapped_fields1211 = fields1210 + _t1683 = _t1682(msg) + fields1215 = _t1683 + unwrapped_fields1216 = fields1215 write(pp, "(") write(pp, "context") indent_sexp!(pp) - if !isempty(unwrapped_fields1211) + if !isempty(unwrapped_fields1216) newline(pp) - for (i1674, elem1212) in enumerate(unwrapped_fields1211) - i1213 = i1674 - 1 - if (i1213 > 0) + for (i1684, elem1217) in enumerate(unwrapped_fields1216) + i1218 = i1684 - 1 + if (i1218 > 0) newline(pp) end - pretty_relation_id(pp, elem1212) + pretty_relation_id(pp, elem1217) end end dedent!(pp) @@ -4191,50 +4191,75 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1219 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1219) - write(pp, flat1219) + flat1224 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1224) + write(pp, flat1224) return nothing else - function _t1675(_dollar_dollar) - return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + function _t1685(_dollar_dollar) + return _dollar_dollar.mappings end - _t1676 = _t1675(msg) - fields1215 = _t1676 - unwrapped_fields1216 = fields1215 + _t1686 = _t1685(msg) + fields1220 = _t1686 + unwrapped_fields1221 = fields1220 write(pp, "(") write(pp, "snapshot") indent_sexp!(pp) - newline(pp) - field1217 = unwrapped_fields1216[1] - pretty_edb_path(pp, field1217) - newline(pp) - field1218 = unwrapped_fields1216[2] - pretty_relation_id(pp, field1218) + if !isempty(unwrapped_fields1221) + newline(pp) + for (i1687, elem1222) in enumerate(unwrapped_fields1221) + i1223 = i1687 - 1 + if (i1223 > 0) + newline(pp) + end + pretty_snapshot_mapping(pp, elem1222) + end + end dedent!(pp) write(pp, ")") end return nothing end +function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) + flat1229 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1229) + write(pp, flat1229) + return nothing + else + function _t1688(_dollar_dollar) + return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + end + _t1689 = _t1688(msg) + fields1225 = _t1689 + unwrapped_fields1226 = fields1225 + field1227 = unwrapped_fields1226[1] + pretty_edb_path(pp, field1227) + write(pp, " ") + field1228 = unwrapped_fields1226[2] + pretty_relation_id(pp, field1228) + end + return nothing +end + function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1223 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1223) - write(pp, flat1223) + flat1233 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1233) + write(pp, flat1233) return nothing else - fields1220 = msg + fields1230 = msg write(pp, "(") write(pp, "reads") indent_sexp!(pp) - if !isempty(fields1220) + if !isempty(fields1230) newline(pp) - for (i1677, elem1221) in enumerate(fields1220) - i1222 = i1677 - 1 - if (i1222 > 0) + for (i1690, elem1231) in enumerate(fields1230) + i1232 = i1690 - 1 + if (i1232 > 0) newline(pp) end - pretty_read(pp, elem1221) + pretty_read(pp, elem1231) end end dedent!(pp) @@ -4244,80 +4269,80 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1234 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1234) - write(pp, flat1234) + flat1244 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1244) + write(pp, flat1244) return nothing else - function _t1678(_dollar_dollar) + function _t1691(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1679 = _get_oneof_field(_dollar_dollar, :demand) + _t1692 = _get_oneof_field(_dollar_dollar, :demand) else - _t1679 = nothing + _t1692 = nothing end - return _t1679 + return _t1692 end - _t1680 = _t1678(msg) - deconstruct_result1232 = _t1680 - if !isnothing(deconstruct_result1232) - unwrapped1233 = deconstruct_result1232 - pretty_demand(pp, unwrapped1233) + _t1693 = _t1691(msg) + deconstruct_result1242 = _t1693 + if !isnothing(deconstruct_result1242) + unwrapped1243 = deconstruct_result1242 + pretty_demand(pp, unwrapped1243) else - function _t1681(_dollar_dollar) + function _t1694(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1682 = _get_oneof_field(_dollar_dollar, :output) + _t1695 = _get_oneof_field(_dollar_dollar, :output) else - _t1682 = nothing + _t1695 = nothing end - return _t1682 + return _t1695 end - _t1683 = _t1681(msg) - deconstruct_result1230 = _t1683 - if !isnothing(deconstruct_result1230) - unwrapped1231 = deconstruct_result1230 - pretty_output(pp, unwrapped1231) + _t1696 = _t1694(msg) + deconstruct_result1240 = _t1696 + if !isnothing(deconstruct_result1240) + unwrapped1241 = deconstruct_result1240 + pretty_output(pp, unwrapped1241) else - function _t1684(_dollar_dollar) + function _t1697(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1685 = _get_oneof_field(_dollar_dollar, :what_if) + _t1698 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1685 = nothing + _t1698 = nothing end - return _t1685 + return _t1698 end - _t1686 = _t1684(msg) - deconstruct_result1228 = _t1686 - if !isnothing(deconstruct_result1228) - unwrapped1229 = deconstruct_result1228 - pretty_what_if(pp, unwrapped1229) + _t1699 = _t1697(msg) + deconstruct_result1238 = _t1699 + if !isnothing(deconstruct_result1238) + unwrapped1239 = deconstruct_result1238 + pretty_what_if(pp, unwrapped1239) else - function _t1687(_dollar_dollar) + function _t1700(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1688 = _get_oneof_field(_dollar_dollar, :abort) + _t1701 = _get_oneof_field(_dollar_dollar, :abort) else - _t1688 = nothing + _t1701 = nothing end - return _t1688 + return _t1701 end - _t1689 = _t1687(msg) - deconstruct_result1226 = _t1689 - if !isnothing(deconstruct_result1226) - unwrapped1227 = deconstruct_result1226 - pretty_abort(pp, unwrapped1227) + _t1702 = _t1700(msg) + deconstruct_result1236 = _t1702 + if !isnothing(deconstruct_result1236) + unwrapped1237 = deconstruct_result1236 + pretty_abort(pp, unwrapped1237) else - function _t1690(_dollar_dollar) + function _t1703(_dollar_dollar) if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1691 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1704 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1691 = nothing + _t1704 = nothing end - return _t1691 + return _t1704 end - _t1692 = _t1690(msg) - deconstruct_result1224 = _t1692 - if !isnothing(deconstruct_result1224) - unwrapped1225 = deconstruct_result1224 - pretty_export(pp, unwrapped1225) + _t1705 = _t1703(msg) + deconstruct_result1234 = _t1705 + if !isnothing(deconstruct_result1234) + unwrapped1235 = deconstruct_result1234 + pretty_export(pp, unwrapped1235) else throw(ParseError("No matching rule for read")) end @@ -4330,22 +4355,22 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1237 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1237) - write(pp, flat1237) + flat1247 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1247) + write(pp, flat1247) return nothing else - function _t1693(_dollar_dollar) + function _t1706(_dollar_dollar) return _dollar_dollar.relation_id end - _t1694 = _t1693(msg) - fields1235 = _t1694 - unwrapped_fields1236 = fields1235 + _t1707 = _t1706(msg) + fields1245 = _t1707 + unwrapped_fields1246 = fields1245 write(pp, "(") write(pp, "demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1236) + pretty_relation_id(pp, unwrapped_fields1246) dedent!(pp) write(pp, ")") end @@ -4353,26 +4378,26 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1242 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1242) - write(pp, flat1242) + flat1252 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1252) + write(pp, flat1252) return nothing else - function _t1695(_dollar_dollar) + function _t1708(_dollar_dollar) return (_dollar_dollar.name, _dollar_dollar.relation_id,) end - _t1696 = _t1695(msg) - fields1238 = _t1696 - unwrapped_fields1239 = fields1238 + _t1709 = _t1708(msg) + fields1248 = _t1709 + unwrapped_fields1249 = fields1248 write(pp, "(") write(pp, "output") indent_sexp!(pp) newline(pp) - field1240 = unwrapped_fields1239[1] - pretty_name(pp, field1240) + field1250 = unwrapped_fields1249[1] + pretty_name(pp, field1250) newline(pp) - field1241 = unwrapped_fields1239[2] - pretty_relation_id(pp, field1241) + field1251 = unwrapped_fields1249[2] + pretty_relation_id(pp, field1251) dedent!(pp) write(pp, ")") end @@ -4380,26 +4405,26 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1247 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1247) - write(pp, flat1247) + flat1257 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1257) + write(pp, flat1257) return nothing else - function _t1697(_dollar_dollar) + function _t1710(_dollar_dollar) return (_dollar_dollar.branch, _dollar_dollar.epoch,) end - _t1698 = _t1697(msg) - fields1243 = _t1698 - unwrapped_fields1244 = fields1243 + _t1711 = _t1710(msg) + fields1253 = _t1711 + unwrapped_fields1254 = fields1253 write(pp, "(") write(pp, "what_if") indent_sexp!(pp) newline(pp) - field1245 = unwrapped_fields1244[1] - pretty_name(pp, field1245) + field1255 = unwrapped_fields1254[1] + pretty_name(pp, field1255) newline(pp) - field1246 = unwrapped_fields1244[2] - pretty_epoch(pp, field1246) + field1256 = unwrapped_fields1254[2] + pretty_epoch(pp, field1256) dedent!(pp) write(pp, ")") end @@ -4407,34 +4432,34 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1253 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1253) - write(pp, flat1253) + flat1263 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1263) + write(pp, flat1263) return nothing else - function _t1699(_dollar_dollar) + function _t1712(_dollar_dollar) if _dollar_dollar.name != "abort" - _t1700 = _dollar_dollar.name + _t1713 = _dollar_dollar.name else - _t1700 = nothing + _t1713 = nothing end - return (_t1700, _dollar_dollar.relation_id,) + return (_t1713, _dollar_dollar.relation_id,) end - _t1701 = _t1699(msg) - fields1248 = _t1701 - unwrapped_fields1249 = fields1248 + _t1714 = _t1712(msg) + fields1258 = _t1714 + unwrapped_fields1259 = fields1258 write(pp, "(") write(pp, "abort") indent_sexp!(pp) - field1250 = unwrapped_fields1249[1] - if !isnothing(field1250) + field1260 = unwrapped_fields1259[1] + if !isnothing(field1260) newline(pp) - opt_val1251 = field1250 - pretty_name(pp, opt_val1251) + opt_val1261 = field1260 + pretty_name(pp, opt_val1261) end newline(pp) - field1252 = unwrapped_fields1249[2] - pretty_relation_id(pp, field1252) + field1262 = unwrapped_fields1259[2] + pretty_relation_id(pp, field1262) dedent!(pp) write(pp, ")") end @@ -4442,22 +4467,22 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1256 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1256) - write(pp, flat1256) + flat1266 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1266) + write(pp, flat1266) return nothing else - function _t1702(_dollar_dollar) + function _t1715(_dollar_dollar) return _get_oneof_field(_dollar_dollar, :csv_config) end - _t1703 = _t1702(msg) - fields1254 = _t1703 - unwrapped_fields1255 = fields1254 + _t1716 = _t1715(msg) + fields1264 = _t1716 + unwrapped_fields1265 = fields1264 write(pp, "(") write(pp, "export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped_fields1255) + pretty_export_csv_config(pp, unwrapped_fields1265) dedent!(pp) write(pp, ")") end @@ -4465,30 +4490,30 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1262 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1262) - write(pp, flat1262) + flat1272 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1272) + write(pp, flat1272) return nothing else - function _t1704(_dollar_dollar) - _t1705 = deconstruct_export_csv_config(pp, _dollar_dollar) - return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1705,) + function _t1717(_dollar_dollar) + _t1718 = deconstruct_export_csv_config(pp, _dollar_dollar) + return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1718,) end - _t1706 = _t1704(msg) - fields1257 = _t1706 - unwrapped_fields1258 = fields1257 + _t1719 = _t1717(msg) + fields1267 = _t1719 + unwrapped_fields1268 = fields1267 write(pp, "(") write(pp, "export_csv_config") indent_sexp!(pp) newline(pp) - field1259 = unwrapped_fields1258[1] - pretty_export_csv_path(pp, field1259) + field1269 = unwrapped_fields1268[1] + pretty_export_csv_path(pp, field1269) newline(pp) - field1260 = unwrapped_fields1258[2] - pretty_export_csv_columns(pp, field1260) + field1270 = unwrapped_fields1268[2] + pretty_export_csv_columns(pp, field1270) newline(pp) - field1261 = unwrapped_fields1258[3] - pretty_config_dict(pp, field1261) + field1271 = unwrapped_fields1268[3] + pretty_config_dict(pp, field1271) dedent!(pp) write(pp, ")") end @@ -4496,17 +4521,17 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1264 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1264) - write(pp, flat1264) + flat1274 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1274) + write(pp, flat1274) return nothing else - fields1263 = msg + fields1273 = msg write(pp, "(") write(pp, "path") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1263)) + write(pp, format_string(pp, fields1273)) dedent!(pp) write(pp, ")") end @@ -4514,23 +4539,23 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1268 = try_flat(pp, msg, pretty_export_csv_columns) - if !isnothing(flat1268) - write(pp, flat1268) + flat1278 = try_flat(pp, msg, pretty_export_csv_columns) + if !isnothing(flat1278) + write(pp, flat1278) return nothing else - fields1265 = msg + fields1275 = msg write(pp, "(") write(pp, "columns") indent_sexp!(pp) - if !isempty(fields1265) + if !isempty(fields1275) newline(pp) - for (i1707, elem1266) in enumerate(fields1265) - i1267 = i1707 - 1 - if (i1267 > 0) + for (i1720, elem1276) in enumerate(fields1275) + i1277 = i1720 - 1 + if (i1277 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1266) + pretty_export_csv_column(pp, elem1276) end end dedent!(pp) @@ -4540,26 +4565,26 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCS end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1273 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1273) - write(pp, flat1273) + flat1283 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1283) + write(pp, flat1283) return nothing else - function _t1708(_dollar_dollar) + function _t1721(_dollar_dollar) return (_dollar_dollar.column_name, _dollar_dollar.column_data,) end - _t1709 = _t1708(msg) - fields1269 = _t1709 - unwrapped_fields1270 = fields1269 + _t1722 = _t1721(msg) + fields1279 = _t1722 + unwrapped_fields1280 = fields1279 write(pp, "(") write(pp, "column") indent_sexp!(pp) newline(pp) - field1271 = unwrapped_fields1270[1] - write(pp, format_string(pp, field1271)) + field1281 = unwrapped_fields1280[1] + write(pp, format_string(pp, field1281)) newline(pp) - field1272 = unwrapped_fields1270[2] - pretty_relation_id(pp, field1272) + field1282 = unwrapped_fields1280[2] + pretty_relation_id(pp, field1282) dedent!(pp) write(pp, ")") end @@ -4572,12 +4597,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1747, _rid) in enumerate(msg.ids) - _idx = i1747 - 1 + for (i1760, _rid) in enumerate(msg.ids) + _idx = i1760 - 1 newline(pp) write(pp, "(") - _t1748 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1748) + _t1761 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1761) write(pp, " ") write(pp, format_string(pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -4650,8 +4675,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe newline(pp) write(pp, ":keys ") write(pp, "(") - for (i1749, _elem) in enumerate(msg.keys) - _idx = i1749 - 1 + for (i1762, _elem) in enumerate(msg.keys) + _idx = i1762 - 1 if (_idx > 0) write(pp, " ") end @@ -4661,8 +4686,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe newline(pp) write(pp, ":values ") write(pp, "(") - for (i1750, _elem) in enumerate(msg.values) - _idx = i1750 - 1 + for (i1763, _elem) in enumerate(msg.values) + _idx = i1763 - 1 if (_idx > 0) write(pp, " ") end @@ -4807,6 +4832,7 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.GNFColumn) = pretty_gnf_column(pp, _pprint_dispatch(pp::PrettyPrinter, x::Proto.Undefine) = pretty_undefine(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Context) = pretty_context(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Snapshot) = pretty_snapshot(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Proto.SnapshotMapping) = pretty_snapshot_mapping(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.Read}) = pretty_epoch_reads(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Read) = pretty_read(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Demand) = pretty_demand(pp, x) diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index 14fbfd20..ce27d659 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl @@ -1363,23 +1363,67 @@ end @test d1 == d2 && d2 == d4 && d1 == d4 end +@testitem "Equality for SnapshotMapping" tags=[:ring1, :unit] begin + using LogicalQueryProtocol: SnapshotMapping, RelationId + + r1 = RelationId(id_low=0x1234, id_high=0x0) + r2 = RelationId(id_low=0x1234, id_high=0x0) + r3 = RelationId(id_low=0x5678, id_high=0x0) + + m1 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1) + m2 = SnapshotMapping(destination_path=["my_edb"], source_relation=r2) + m3 = SnapshotMapping(destination_path=["other_edb"], source_relation=r1) + m4 = SnapshotMapping(destination_path=["my_edb"], source_relation=r3) + m5 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1) + + # Equality and inequality + @test m1 == m2 + @test m1 != m3 + @test m1 != m4 + @test isequal(m1, m2) + + # Hash consistency + @test hash(m1) == hash(m2) + + # Reflexivity + @test m1 == m1 + @test isequal(m1, m1) + + # Symmetry + @test m1 == m2 && m2 == m1 + + # Transitivity + @test m1 == m2 && m2 == m5 && m1 == m5 + + # Multi-segment path + m6 = SnapshotMapping(destination_path=["schema", "table"], source_relation=r1) + m7 = SnapshotMapping(destination_path=["schema", "table"], source_relation=r1) + @test m6 == m7 + @test hash(m6) == hash(m7) + @test m6 != m1 +end + @testitem "Equality for Snapshot" tags=[:ring1, :unit] begin - using LogicalQueryProtocol: Snapshot, RelationId + using LogicalQueryProtocol: Snapshot, SnapshotMapping, RelationId r1 = RelationId(id_low=0x1234, id_high=0x0) r2 = RelationId(id_low=0x1234, id_high=0x0) r3 = RelationId(id_low=0x5678, id_high=0x0) - s1 = Snapshot(destination_path=["my_edb"], source_relation=r1) - s2 = Snapshot(destination_path=["my_edb"], source_relation=r2) - s3 = Snapshot(destination_path=["other_edb"], source_relation=r1) - s4 = Snapshot(destination_path=["my_edb"], source_relation=r3) - s5 = Snapshot(destination_path=["my_edb"], source_relation=r1) + m1 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1) + m2 = SnapshotMapping(destination_path=["other_edb"], source_relation=r3) + + s1 = Snapshot(mappings=[m1, m2]) + s2 = Snapshot(mappings=[ + SnapshotMapping(destination_path=["my_edb"], source_relation=r2), + SnapshotMapping(destination_path=["other_edb"], source_relation=r3), + ]) + s3 = Snapshot(mappings=[m1]) + s4 = Snapshot(mappings=[m1, m2]) # Equality and inequality @test s1 == s2 @test s1 != s3 - @test s1 != s4 @test isequal(s1, s2) # Hash consistency @@ -1393,14 +1437,7 @@ end @test s1 == s2 && s2 == s1 # Transitivity - @test s1 == s2 && s2 == s5 && s1 == s5 - - # Multi-segment path - s6 = Snapshot(destination_path=["schema", "table"], source_relation=r1) - s7 = Snapshot(destination_path=["schema", "table"], source_relation=r1) - @test s6 == s7 - @test hash(s6) == hash(s7) - @test s6 != s1 + @test s1 == s2 && s2 == s4 && s1 == s4 end @testitem "Equality for Configure" tags=[:ring1, :unit] begin diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 04f419fb..2199507e 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -298,177 +298,177 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: Optional[logic_pb2.Value], default: int) -> int: if value is not None: assert value is not None - _t1329 = value.HasField("int_value") + _t1339 = value.HasField("int_value") else: - _t1329 = False - if _t1329: + _t1339 = False + if _t1339: assert value is not None return int(value.int_value) else: - _t1330 = None + _t1340 = None return int(default) def _extract_value_int64(self, value: Optional[logic_pb2.Value], default: int) -> int: if value is not None: assert value is not None - _t1331 = value.HasField("int_value") + _t1341 = value.HasField("int_value") else: - _t1331 = False - if _t1331: + _t1341 = False + if _t1341: assert value is not None return value.int_value else: - _t1332 = None + _t1342 = None return default def _extract_value_string(self, value: Optional[logic_pb2.Value], default: str) -> str: if value is not None: assert value is not None - _t1333 = value.HasField("string_value") + _t1343 = value.HasField("string_value") else: - _t1333 = False - if _t1333: + _t1343 = False + if _t1343: assert value is not None return value.string_value else: - _t1334 = None + _t1344 = None return default def _extract_value_boolean(self, value: Optional[logic_pb2.Value], default: bool) -> bool: if value is not None: assert value is not None - _t1335 = value.HasField("boolean_value") + _t1345 = value.HasField("boolean_value") else: - _t1335 = False - if _t1335: + _t1345 = False + if _t1345: assert value is not None return value.boolean_value else: - _t1336 = None + _t1346 = None return default def _extract_value_string_list(self, value: Optional[logic_pb2.Value], default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t1337 = value.HasField("string_value") + _t1347 = value.HasField("string_value") else: - _t1337 = False - if _t1337: + _t1347 = False + if _t1347: assert value is not None return [value.string_value] else: - _t1338 = None + _t1348 = None return default def _try_extract_value_int64(self, value: Optional[logic_pb2.Value]) -> Optional[int]: if value is not None: assert value is not None - _t1339 = value.HasField("int_value") + _t1349 = value.HasField("int_value") else: - _t1339 = False - if _t1339: + _t1349 = False + if _t1349: assert value is not None return value.int_value else: - _t1340 = None + _t1350 = None return None def _try_extract_value_float64(self, value: Optional[logic_pb2.Value]) -> Optional[float]: if value is not None: assert value is not None - _t1341 = value.HasField("float_value") + _t1351 = value.HasField("float_value") else: - _t1341 = False - if _t1341: + _t1351 = False + if _t1351: assert value is not None return value.float_value else: - _t1342 = None + _t1352 = None return None def _try_extract_value_bytes(self, value: Optional[logic_pb2.Value]) -> Optional[bytes]: if value is not None: assert value is not None - _t1343 = value.HasField("string_value") + _t1353 = value.HasField("string_value") else: - _t1343 = False - if _t1343: + _t1353 = False + if _t1353: assert value is not None return value.string_value.encode() else: - _t1344 = None + _t1354 = None return None def _try_extract_value_uint128(self, value: Optional[logic_pb2.Value]) -> Optional[logic_pb2.UInt128Value]: if value is not None: assert value is not None - _t1345 = value.HasField("uint128_value") + _t1355 = value.HasField("uint128_value") else: - _t1345 = False - if _t1345: + _t1355 = False + if _t1355: assert value is not None return value.uint128_value else: - _t1346 = None + _t1356 = None return None def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t1347 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t1347 - _t1348 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t1348 - _t1349 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t1349 - _t1350 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t1350 - _t1351 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t1351 - _t1352 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t1352 - _t1353 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t1353 - _t1354 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t1354 - _t1355 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t1355 - _t1356 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t1356 - _t1357 = self._extract_value_string(config.get("csv_compression"), "auto") - compression = _t1357 - _t1358 = 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) - return _t1358 + _t1357 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t1357 + _t1358 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t1358 + _t1359 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t1359 + _t1360 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t1360 + _t1361 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t1361 + _t1362 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t1362 + _t1363 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t1363 + _t1364 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t1364 + _t1365 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t1365 + _t1366 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t1366 + _t1367 = self._extract_value_string(config.get("csv_compression"), "auto") + compression = _t1367 + _t1368 = 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) + return _t1368 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) - _t1359 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t1359 - _t1360 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t1360 - _t1361 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t1361 - _t1362 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t1362 - _t1363 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t1363 - _t1364 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t1364 - _t1365 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t1365 - _t1366 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t1366 - _t1367 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t1367 - _t1368 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t1368 - _t1369 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t1369 + _t1369 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t1369 + _t1370 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t1370 + _t1371 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t1371 + _t1372 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t1372 + _t1373 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t1373 + _t1374 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t1374 + _t1375 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t1375 + _t1376 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t1376 + _t1377 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t1377 + _t1378 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t1378 + _t1379 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t1379 def default_configure(self) -> transactions_pb2.Configure: - _t1370 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t1370 - _t1371 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t1371 + _t1380 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t1380 + _t1381 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t1381 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -485,31 +485,31 @@ 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 - _t1372 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t1372 - _t1373 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t1373 - _t1374 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t1374 + _t1382 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t1382 + _t1383 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t1383 + _t1384 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t1384 def 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) - _t1375 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t1375 - _t1376 = self._extract_value_string(config.get("compression"), "") - compression = _t1376 - _t1377 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t1377 - _t1378 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t1378 - _t1379 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t1379 - _t1380 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t1380 - _t1381 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t1381 - _t1382 = 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 _t1382 + _t1385 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t1385 + _t1386 = self._extract_value_string(config.get("compression"), "") + compression = _t1386 + _t1387 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t1387 + _t1388 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t1388 + _t1389 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t1389 + _t1390 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t1390 + _t1391 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t1391 + _t1392 = 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 _t1392 # --- Parse methods --- @@ -517,2371 +517,2383 @@ def parse_transaction(self) -> transactions_pb2.Transaction: self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t725 = self.parse_configure() - _t724 = _t725 + _t733 = self.parse_configure() + _t732 = _t733 else: - _t724 = None - configure362 = _t724 + _t732 = None + configure366 = _t732 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t727 = self.parse_sync() - _t726 = _t727 - else: - _t726 = None - sync363 = _t726 - xs364 = [] - cond365 = self.match_lookahead_literal("(", 0) - while cond365: - _t728 = self.parse_epoch() - item366 = _t728 - xs364.append(item366) - cond365 = self.match_lookahead_literal("(", 0) - epochs367 = xs364 - self.consume_literal(")") - _t729 = self.default_configure() - _t730 = transactions_pb2.Transaction(epochs=epochs367, configure=(configure362 if configure362 is not None else _t729), sync=sync363) - return _t730 + _t735 = self.parse_sync() + _t734 = _t735 + else: + _t734 = None + sync367 = _t734 + xs368 = [] + cond369 = self.match_lookahead_literal("(", 0) + while cond369: + _t736 = self.parse_epoch() + item370 = _t736 + xs368.append(item370) + cond369 = self.match_lookahead_literal("(", 0) + epochs371 = xs368 + self.consume_literal(")") + _t737 = self.default_configure() + _t738 = transactions_pb2.Transaction(epochs=epochs371, configure=(configure366 if configure366 is not None else _t737), sync=sync367) + return _t738 def parse_configure(self) -> transactions_pb2.Configure: self.consume_literal("(") self.consume_literal("configure") - _t731 = self.parse_config_dict() - config_dict368 = _t731 + _t739 = self.parse_config_dict() + config_dict372 = _t739 self.consume_literal(")") - _t732 = self.construct_configure(config_dict368) - return _t732 + _t740 = self.construct_configure(config_dict372) + return _t740 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs369 = [] - cond370 = self.match_lookahead_literal(":", 0) - while cond370: - _t733 = self.parse_config_key_value() - item371 = _t733 - xs369.append(item371) - cond370 = self.match_lookahead_literal(":", 0) - config_key_values372 = xs369 + xs373 = [] + cond374 = self.match_lookahead_literal(":", 0) + while cond374: + _t741 = self.parse_config_key_value() + item375 = _t741 + xs373.append(item375) + cond374 = self.match_lookahead_literal(":", 0) + config_key_values376 = xs373 self.consume_literal("}") - return config_key_values372 + return config_key_values376 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol373 = self.consume_terminal("SYMBOL") - _t734 = self.parse_value() - value374 = _t734 - return (symbol373, value374,) + symbol377 = self.consume_terminal("SYMBOL") + _t742 = self.parse_value() + value378 = _t742 + return (symbol377, value378,) def parse_value(self) -> logic_pb2.Value: if self.match_lookahead_literal("true", 0): - _t735 = 9 + _t743 = 9 else: if self.match_lookahead_literal("missing", 0): - _t736 = 8 + _t744 = 8 else: if self.match_lookahead_literal("false", 0): - _t737 = 9 + _t745 = 9 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t739 = 1 + _t747 = 1 else: if self.match_lookahead_literal("date", 1): - _t740 = 0 + _t748 = 0 else: - _t740 = -1 - _t739 = _t740 - _t738 = _t739 + _t748 = -1 + _t747 = _t748 + _t746 = _t747 else: if self.match_lookahead_terminal("UINT128", 0): - _t741 = 5 + _t749 = 5 else: if self.match_lookahead_terminal("STRING", 0): - _t742 = 2 + _t750 = 2 else: if self.match_lookahead_terminal("INT128", 0): - _t743 = 6 + _t751 = 6 else: if self.match_lookahead_terminal("INT", 0): - _t744 = 3 + _t752 = 3 else: if self.match_lookahead_terminal("FLOAT", 0): - _t745 = 4 + _t753 = 4 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t746 = 7 + _t754 = 7 else: - _t746 = -1 - _t745 = _t746 - _t744 = _t745 - _t743 = _t744 - _t742 = _t743 - _t741 = _t742 - _t738 = _t741 - _t737 = _t738 - _t736 = _t737 - _t735 = _t736 - prediction375 = _t735 - if prediction375 == 9: - _t748 = self.parse_boolean_value() - boolean_value384 = _t748 - _t749 = logic_pb2.Value(boolean_value=boolean_value384) - _t747 = _t749 - else: - if prediction375 == 8: + _t754 = -1 + _t753 = _t754 + _t752 = _t753 + _t751 = _t752 + _t750 = _t751 + _t749 = _t750 + _t746 = _t749 + _t745 = _t746 + _t744 = _t745 + _t743 = _t744 + prediction379 = _t743 + if prediction379 == 9: + _t756 = self.parse_boolean_value() + boolean_value388 = _t756 + _t757 = logic_pb2.Value(boolean_value=boolean_value388) + _t755 = _t757 + else: + if prediction379 == 8: self.consume_literal("missing") - _t751 = logic_pb2.MissingValue() - _t752 = logic_pb2.Value(missing_value=_t751) - _t750 = _t752 + _t759 = logic_pb2.MissingValue() + _t760 = logic_pb2.Value(missing_value=_t759) + _t758 = _t760 else: - if prediction375 == 7: - decimal383 = self.consume_terminal("DECIMAL") - _t754 = logic_pb2.Value(decimal_value=decimal383) - _t753 = _t754 + if prediction379 == 7: + decimal387 = self.consume_terminal("DECIMAL") + _t762 = logic_pb2.Value(decimal_value=decimal387) + _t761 = _t762 else: - if prediction375 == 6: - int128382 = self.consume_terminal("INT128") - _t756 = logic_pb2.Value(int128_value=int128382) - _t755 = _t756 + if prediction379 == 6: + int128386 = self.consume_terminal("INT128") + _t764 = logic_pb2.Value(int128_value=int128386) + _t763 = _t764 else: - if prediction375 == 5: - uint128381 = self.consume_terminal("UINT128") - _t758 = logic_pb2.Value(uint128_value=uint128381) - _t757 = _t758 + if prediction379 == 5: + uint128385 = self.consume_terminal("UINT128") + _t766 = logic_pb2.Value(uint128_value=uint128385) + _t765 = _t766 else: - if prediction375 == 4: - float380 = self.consume_terminal("FLOAT") - _t760 = logic_pb2.Value(float_value=float380) - _t759 = _t760 + if prediction379 == 4: + float384 = self.consume_terminal("FLOAT") + _t768 = logic_pb2.Value(float_value=float384) + _t767 = _t768 else: - if prediction375 == 3: - int379 = self.consume_terminal("INT") - _t762 = logic_pb2.Value(int_value=int379) - _t761 = _t762 + if prediction379 == 3: + int383 = self.consume_terminal("INT") + _t770 = logic_pb2.Value(int_value=int383) + _t769 = _t770 else: - if prediction375 == 2: - string378 = self.consume_terminal("STRING") - _t764 = logic_pb2.Value(string_value=string378) - _t763 = _t764 + if prediction379 == 2: + string382 = self.consume_terminal("STRING") + _t772 = logic_pb2.Value(string_value=string382) + _t771 = _t772 else: - if prediction375 == 1: - _t766 = self.parse_datetime() - datetime377 = _t766 - _t767 = logic_pb2.Value(datetime_value=datetime377) - _t765 = _t767 + if prediction379 == 1: + _t774 = self.parse_datetime() + datetime381 = _t774 + _t775 = logic_pb2.Value(datetime_value=datetime381) + _t773 = _t775 else: - if prediction375 == 0: - _t769 = self.parse_date() - date376 = _t769 - _t770 = logic_pb2.Value(date_value=date376) - _t768 = _t770 + if prediction379 == 0: + _t777 = self.parse_date() + date380 = _t777 + _t778 = logic_pb2.Value(date_value=date380) + _t776 = _t778 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t765 = _t768 - _t763 = _t765 - _t761 = _t763 - _t759 = _t761 - _t757 = _t759 - _t755 = _t757 - _t753 = _t755 - _t750 = _t753 - _t747 = _t750 - return _t747 + _t773 = _t776 + _t771 = _t773 + _t769 = _t771 + _t767 = _t769 + _t765 = _t767 + _t763 = _t765 + _t761 = _t763 + _t758 = _t761 + _t755 = _t758 + return _t755 def parse_date(self) -> logic_pb2.DateValue: self.consume_literal("(") self.consume_literal("date") - int385 = self.consume_terminal("INT") - int_3386 = self.consume_terminal("INT") - int_4387 = self.consume_terminal("INT") + int389 = self.consume_terminal("INT") + int_3390 = self.consume_terminal("INT") + int_4391 = self.consume_terminal("INT") self.consume_literal(")") - _t771 = logic_pb2.DateValue(year=int(int385), month=int(int_3386), day=int(int_4387)) - return _t771 + _t779 = logic_pb2.DateValue(year=int(int389), month=int(int_3390), day=int(int_4391)) + return _t779 def parse_datetime(self) -> logic_pb2.DateTimeValue: self.consume_literal("(") self.consume_literal("datetime") - int388 = self.consume_terminal("INT") - int_3389 = self.consume_terminal("INT") - int_4390 = self.consume_terminal("INT") - int_5391 = self.consume_terminal("INT") - int_6392 = self.consume_terminal("INT") - int_7393 = self.consume_terminal("INT") + int392 = self.consume_terminal("INT") + int_3393 = self.consume_terminal("INT") + int_4394 = self.consume_terminal("INT") + int_5395 = self.consume_terminal("INT") + int_6396 = self.consume_terminal("INT") + int_7397 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t772 = self.consume_terminal("INT") + _t780 = self.consume_terminal("INT") else: - _t772 = None - int_8394 = _t772 + _t780 = None + int_8398 = _t780 self.consume_literal(")") - _t773 = logic_pb2.DateTimeValue(year=int(int388), month=int(int_3389), day=int(int_4390), hour=int(int_5391), minute=int(int_6392), second=int(int_7393), microsecond=int((int_8394 if int_8394 is not None else 0))) - return _t773 + _t781 = logic_pb2.DateTimeValue(year=int(int392), month=int(int_3393), day=int(int_4394), hour=int(int_5395), minute=int(int_6396), second=int(int_7397), microsecond=int((int_8398 if int_8398 is not None else 0))) + return _t781 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t774 = 0 + _t782 = 0 else: if self.match_lookahead_literal("false", 0): - _t775 = 1 + _t783 = 1 else: - _t775 = -1 - _t774 = _t775 - prediction395 = _t774 - if prediction395 == 1: + _t783 = -1 + _t782 = _t783 + prediction399 = _t782 + if prediction399 == 1: self.consume_literal("false") - _t776 = False + _t784 = False else: - if prediction395 == 0: + if prediction399 == 0: self.consume_literal("true") - _t777 = True + _t785 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t776 = _t777 - return _t776 + _t784 = _t785 + return _t784 def parse_sync(self) -> transactions_pb2.Sync: self.consume_literal("(") self.consume_literal("sync") - xs396 = [] - cond397 = self.match_lookahead_literal(":", 0) - while cond397: - _t778 = self.parse_fragment_id() - item398 = _t778 - xs396.append(item398) - cond397 = self.match_lookahead_literal(":", 0) - fragment_ids399 = xs396 - self.consume_literal(")") - _t779 = transactions_pb2.Sync(fragments=fragment_ids399) - return _t779 + xs400 = [] + cond401 = self.match_lookahead_literal(":", 0) + while cond401: + _t786 = self.parse_fragment_id() + item402 = _t786 + xs400.append(item402) + cond401 = self.match_lookahead_literal(":", 0) + fragment_ids403 = xs400 + self.consume_literal(")") + _t787 = transactions_pb2.Sync(fragments=fragment_ids403) + return _t787 def parse_fragment_id(self) -> fragments_pb2.FragmentId: self.consume_literal(":") - symbol400 = self.consume_terminal("SYMBOL") - return fragments_pb2.FragmentId(id=symbol400.encode()) + symbol404 = self.consume_terminal("SYMBOL") + return fragments_pb2.FragmentId(id=symbol404.encode()) def parse_epoch(self) -> transactions_pb2.Epoch: self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t781 = self.parse_epoch_writes() - _t780 = _t781 + _t789 = self.parse_epoch_writes() + _t788 = _t789 else: - _t780 = None - epoch_writes401 = _t780 + _t788 = None + epoch_writes405 = _t788 if self.match_lookahead_literal("(", 0): - _t783 = self.parse_epoch_reads() - _t782 = _t783 + _t791 = self.parse_epoch_reads() + _t790 = _t791 else: - _t782 = None - epoch_reads402 = _t782 + _t790 = None + epoch_reads406 = _t790 self.consume_literal(")") - _t784 = transactions_pb2.Epoch(writes=(epoch_writes401 if epoch_writes401 is not None else []), reads=(epoch_reads402 if epoch_reads402 is not None else [])) - return _t784 + _t792 = transactions_pb2.Epoch(writes=(epoch_writes405 if epoch_writes405 is not None else []), reads=(epoch_reads406 if epoch_reads406 is not None else [])) + return _t792 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs403 = [] - cond404 = self.match_lookahead_literal("(", 0) - while cond404: - _t785 = self.parse_write() - item405 = _t785 - xs403.append(item405) - cond404 = self.match_lookahead_literal("(", 0) - writes406 = xs403 + xs407 = [] + cond408 = self.match_lookahead_literal("(", 0) + while cond408: + _t793 = self.parse_write() + item409 = _t793 + xs407.append(item409) + cond408 = self.match_lookahead_literal("(", 0) + writes410 = xs407 self.consume_literal(")") - return writes406 + return writes410 def parse_write(self) -> transactions_pb2.Write: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t787 = 1 + _t795 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t788 = 3 + _t796 = 3 else: if self.match_lookahead_literal("define", 1): - _t789 = 0 + _t797 = 0 else: if self.match_lookahead_literal("context", 1): - _t790 = 2 + _t798 = 2 else: - _t790 = -1 - _t789 = _t790 - _t788 = _t789 - _t787 = _t788 - _t786 = _t787 - else: - _t786 = -1 - prediction407 = _t786 - if prediction407 == 3: - _t792 = self.parse_snapshot() - snapshot411 = _t792 - _t793 = transactions_pb2.Write(snapshot=snapshot411) - _t791 = _t793 - else: - if prediction407 == 2: - _t795 = self.parse_context() - context410 = _t795 - _t796 = transactions_pb2.Write(context=context410) - _t794 = _t796 + _t798 = -1 + _t797 = _t798 + _t796 = _t797 + _t795 = _t796 + _t794 = _t795 + else: + _t794 = -1 + prediction411 = _t794 + if prediction411 == 3: + _t800 = self.parse_snapshot() + snapshot415 = _t800 + _t801 = transactions_pb2.Write(snapshot=snapshot415) + _t799 = _t801 + else: + if prediction411 == 2: + _t803 = self.parse_context() + context414 = _t803 + _t804 = transactions_pb2.Write(context=context414) + _t802 = _t804 else: - if prediction407 == 1: - _t798 = self.parse_undefine() - undefine409 = _t798 - _t799 = transactions_pb2.Write(undefine=undefine409) - _t797 = _t799 + if prediction411 == 1: + _t806 = self.parse_undefine() + undefine413 = _t806 + _t807 = transactions_pb2.Write(undefine=undefine413) + _t805 = _t807 else: - if prediction407 == 0: - _t801 = self.parse_define() - define408 = _t801 - _t802 = transactions_pb2.Write(define=define408) - _t800 = _t802 + if prediction411 == 0: + _t809 = self.parse_define() + define412 = _t809 + _t810 = transactions_pb2.Write(define=define412) + _t808 = _t810 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t797 = _t800 - _t794 = _t797 - _t791 = _t794 - return _t791 + _t805 = _t808 + _t802 = _t805 + _t799 = _t802 + return _t799 def parse_define(self) -> transactions_pb2.Define: self.consume_literal("(") self.consume_literal("define") - _t803 = self.parse_fragment() - fragment412 = _t803 + _t811 = self.parse_fragment() + fragment416 = _t811 self.consume_literal(")") - _t804 = transactions_pb2.Define(fragment=fragment412) - return _t804 + _t812 = transactions_pb2.Define(fragment=fragment416) + return _t812 def parse_fragment(self) -> fragments_pb2.Fragment: self.consume_literal("(") self.consume_literal("fragment") - _t805 = self.parse_new_fragment_id() - new_fragment_id413 = _t805 - xs414 = [] - cond415 = self.match_lookahead_literal("(", 0) - while cond415: - _t806 = self.parse_declaration() - item416 = _t806 - xs414.append(item416) - cond415 = self.match_lookahead_literal("(", 0) - declarations417 = xs414 - self.consume_literal(")") - return self.construct_fragment(new_fragment_id413, declarations417) + _t813 = self.parse_new_fragment_id() + new_fragment_id417 = _t813 + xs418 = [] + cond419 = self.match_lookahead_literal("(", 0) + while cond419: + _t814 = self.parse_declaration() + item420 = _t814 + xs418.append(item420) + cond419 = self.match_lookahead_literal("(", 0) + declarations421 = xs418 + self.consume_literal(")") + return self.construct_fragment(new_fragment_id417, declarations421) def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - _t807 = self.parse_fragment_id() - fragment_id418 = _t807 - self.start_fragment(fragment_id418) - return fragment_id418 + _t815 = self.parse_fragment_id() + fragment_id422 = _t815 + self.start_fragment(fragment_id422) + return fragment_id422 def parse_declaration(self) -> logic_pb2.Declaration: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("functional_dependency", 1): - _t809 = 2 + _t817 = 2 else: if self.match_lookahead_literal("edb", 1): - _t810 = 3 + _t818 = 3 else: if self.match_lookahead_literal("def", 1): - _t811 = 0 + _t819 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t812 = 3 + _t820 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t813 = 3 + _t821 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t814 = 1 + _t822 = 1 else: - _t814 = -1 - _t813 = _t814 - _t812 = _t813 - _t811 = _t812 - _t810 = _t811 - _t809 = _t810 - _t808 = _t809 - else: - _t808 = -1 - prediction419 = _t808 - if prediction419 == 3: - _t816 = self.parse_data() - data423 = _t816 - _t817 = logic_pb2.Declaration(data=data423) - _t815 = _t817 - else: - if prediction419 == 2: - _t819 = self.parse_constraint() - constraint422 = _t819 - _t820 = logic_pb2.Declaration(constraint=constraint422) - _t818 = _t820 + _t822 = -1 + _t821 = _t822 + _t820 = _t821 + _t819 = _t820 + _t818 = _t819 + _t817 = _t818 + _t816 = _t817 + else: + _t816 = -1 + prediction423 = _t816 + if prediction423 == 3: + _t824 = self.parse_data() + data427 = _t824 + _t825 = logic_pb2.Declaration(data=data427) + _t823 = _t825 + else: + if prediction423 == 2: + _t827 = self.parse_constraint() + constraint426 = _t827 + _t828 = logic_pb2.Declaration(constraint=constraint426) + _t826 = _t828 else: - if prediction419 == 1: - _t822 = self.parse_algorithm() - algorithm421 = _t822 - _t823 = logic_pb2.Declaration(algorithm=algorithm421) - _t821 = _t823 + if prediction423 == 1: + _t830 = self.parse_algorithm() + algorithm425 = _t830 + _t831 = logic_pb2.Declaration(algorithm=algorithm425) + _t829 = _t831 else: - if prediction419 == 0: - _t825 = self.parse_def() - def420 = _t825 - _t826 = logic_pb2.Declaration() - getattr(_t826, 'def').CopyFrom(def420) - _t824 = _t826 + if prediction423 == 0: + _t833 = self.parse_def() + def424 = _t833 + _t834 = logic_pb2.Declaration() + getattr(_t834, 'def').CopyFrom(def424) + _t832 = _t834 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t821 = _t824 - _t818 = _t821 - _t815 = _t818 - return _t815 + _t829 = _t832 + _t826 = _t829 + _t823 = _t826 + return _t823 def parse_def(self) -> logic_pb2.Def: self.consume_literal("(") self.consume_literal("def") - _t827 = self.parse_relation_id() - relation_id424 = _t827 - _t828 = self.parse_abstraction() - abstraction425 = _t828 + _t835 = self.parse_relation_id() + relation_id428 = _t835 + _t836 = self.parse_abstraction() + abstraction429 = _t836 if self.match_lookahead_literal("(", 0): - _t830 = self.parse_attrs() - _t829 = _t830 + _t838 = self.parse_attrs() + _t837 = _t838 else: - _t829 = None - attrs426 = _t829 + _t837 = None + attrs430 = _t837 self.consume_literal(")") - _t831 = logic_pb2.Def(name=relation_id424, body=abstraction425, attrs=(attrs426 if attrs426 is not None else [])) - return _t831 + _t839 = logic_pb2.Def(name=relation_id428, body=abstraction429, attrs=(attrs430 if attrs430 is not None else [])) + return _t839 def parse_relation_id(self) -> logic_pb2.RelationId: if self.match_lookahead_literal(":", 0): - _t832 = 0 + _t840 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t833 = 1 + _t841 = 1 else: - _t833 = -1 - _t832 = _t833 - prediction427 = _t832 - if prediction427 == 1: - uint128429 = self.consume_terminal("UINT128") - _t834 = logic_pb2.RelationId(id_low=uint128429.low, id_high=uint128429.high) - else: - if prediction427 == 0: + _t841 = -1 + _t840 = _t841 + prediction431 = _t840 + if prediction431 == 1: + uint128433 = self.consume_terminal("UINT128") + _t842 = logic_pb2.RelationId(id_low=uint128433.low, id_high=uint128433.high) + else: + if prediction431 == 0: self.consume_literal(":") - symbol428 = self.consume_terminal("SYMBOL") - _t835 = self.relation_id_from_string(symbol428) + symbol432 = self.consume_terminal("SYMBOL") + _t843 = self.relation_id_from_string(symbol432) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t834 = _t835 - return _t834 + _t842 = _t843 + return _t842 def parse_abstraction(self) -> logic_pb2.Abstraction: self.consume_literal("(") - _t836 = self.parse_bindings() - bindings430 = _t836 - _t837 = self.parse_formula() - formula431 = _t837 + _t844 = self.parse_bindings() + bindings434 = _t844 + _t845 = self.parse_formula() + formula435 = _t845 self.consume_literal(")") - _t838 = logic_pb2.Abstraction(vars=(list(bindings430[0]) + list(bindings430[1] if bindings430[1] is not None else [])), value=formula431) - return _t838 + _t846 = logic_pb2.Abstraction(vars=(list(bindings434[0]) + list(bindings434[1] if bindings434[1] is not None else [])), value=formula435) + return _t846 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs432 = [] - cond433 = self.match_lookahead_terminal("SYMBOL", 0) - while cond433: - _t839 = self.parse_binding() - item434 = _t839 - xs432.append(item434) - cond433 = self.match_lookahead_terminal("SYMBOL", 0) - bindings435 = xs432 + xs436 = [] + cond437 = self.match_lookahead_terminal("SYMBOL", 0) + while cond437: + _t847 = self.parse_binding() + item438 = _t847 + xs436.append(item438) + cond437 = self.match_lookahead_terminal("SYMBOL", 0) + bindings439 = xs436 if self.match_lookahead_literal("|", 0): - _t841 = self.parse_value_bindings() - _t840 = _t841 + _t849 = self.parse_value_bindings() + _t848 = _t849 else: - _t840 = None - value_bindings436 = _t840 + _t848 = None + value_bindings440 = _t848 self.consume_literal("]") - return (bindings435, (value_bindings436 if value_bindings436 is not None else []),) + return (bindings439, (value_bindings440 if value_bindings440 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - symbol437 = self.consume_terminal("SYMBOL") + symbol441 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t842 = self.parse_type() - type438 = _t842 - _t843 = logic_pb2.Var(name=symbol437) - _t844 = logic_pb2.Binding(var=_t843, type=type438) - return _t844 + _t850 = self.parse_type() + type442 = _t850 + _t851 = logic_pb2.Var(name=symbol441) + _t852 = logic_pb2.Binding(var=_t851, type=type442) + return _t852 def parse_type(self) -> logic_pb2.Type: if self.match_lookahead_literal("UNKNOWN", 0): - _t845 = 0 + _t853 = 0 else: if self.match_lookahead_literal("UINT128", 0): - _t846 = 4 + _t854 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t847 = 1 + _t855 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t848 = 8 + _t856 = 8 else: if self.match_lookahead_literal("INT128", 0): - _t849 = 5 + _t857 = 5 else: if self.match_lookahead_literal("INT", 0): - _t850 = 2 + _t858 = 2 else: if self.match_lookahead_literal("FLOAT", 0): - _t851 = 3 + _t859 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t852 = 7 + _t860 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t853 = 6 + _t861 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t854 = 10 + _t862 = 10 else: if self.match_lookahead_literal("(", 0): - _t855 = 9 + _t863 = 9 else: - _t855 = -1 - _t854 = _t855 - _t853 = _t854 - _t852 = _t853 - _t851 = _t852 - _t850 = _t851 - _t849 = _t850 - _t848 = _t849 - _t847 = _t848 - _t846 = _t847 - _t845 = _t846 - prediction439 = _t845 - if prediction439 == 10: - _t857 = self.parse_boolean_type() - boolean_type450 = _t857 - _t858 = logic_pb2.Type(boolean_type=boolean_type450) - _t856 = _t858 - else: - if prediction439 == 9: - _t860 = self.parse_decimal_type() - decimal_type449 = _t860 - _t861 = logic_pb2.Type(decimal_type=decimal_type449) - _t859 = _t861 + _t863 = -1 + _t862 = _t863 + _t861 = _t862 + _t860 = _t861 + _t859 = _t860 + _t858 = _t859 + _t857 = _t858 + _t856 = _t857 + _t855 = _t856 + _t854 = _t855 + _t853 = _t854 + prediction443 = _t853 + if prediction443 == 10: + _t865 = self.parse_boolean_type() + boolean_type454 = _t865 + _t866 = logic_pb2.Type(boolean_type=boolean_type454) + _t864 = _t866 + else: + if prediction443 == 9: + _t868 = self.parse_decimal_type() + decimal_type453 = _t868 + _t869 = logic_pb2.Type(decimal_type=decimal_type453) + _t867 = _t869 else: - if prediction439 == 8: - _t863 = self.parse_missing_type() - missing_type448 = _t863 - _t864 = logic_pb2.Type(missing_type=missing_type448) - _t862 = _t864 + if prediction443 == 8: + _t871 = self.parse_missing_type() + missing_type452 = _t871 + _t872 = logic_pb2.Type(missing_type=missing_type452) + _t870 = _t872 else: - if prediction439 == 7: - _t866 = self.parse_datetime_type() - datetime_type447 = _t866 - _t867 = logic_pb2.Type(datetime_type=datetime_type447) - _t865 = _t867 + if prediction443 == 7: + _t874 = self.parse_datetime_type() + datetime_type451 = _t874 + _t875 = logic_pb2.Type(datetime_type=datetime_type451) + _t873 = _t875 else: - if prediction439 == 6: - _t869 = self.parse_date_type() - date_type446 = _t869 - _t870 = logic_pb2.Type(date_type=date_type446) - _t868 = _t870 + if prediction443 == 6: + _t877 = self.parse_date_type() + date_type450 = _t877 + _t878 = logic_pb2.Type(date_type=date_type450) + _t876 = _t878 else: - if prediction439 == 5: - _t872 = self.parse_int128_type() - int128_type445 = _t872 - _t873 = logic_pb2.Type(int128_type=int128_type445) - _t871 = _t873 + if prediction443 == 5: + _t880 = self.parse_int128_type() + int128_type449 = _t880 + _t881 = logic_pb2.Type(int128_type=int128_type449) + _t879 = _t881 else: - if prediction439 == 4: - _t875 = self.parse_uint128_type() - uint128_type444 = _t875 - _t876 = logic_pb2.Type(uint128_type=uint128_type444) - _t874 = _t876 + if prediction443 == 4: + _t883 = self.parse_uint128_type() + uint128_type448 = _t883 + _t884 = logic_pb2.Type(uint128_type=uint128_type448) + _t882 = _t884 else: - if prediction439 == 3: - _t878 = self.parse_float_type() - float_type443 = _t878 - _t879 = logic_pb2.Type(float_type=float_type443) - _t877 = _t879 + if prediction443 == 3: + _t886 = self.parse_float_type() + float_type447 = _t886 + _t887 = logic_pb2.Type(float_type=float_type447) + _t885 = _t887 else: - if prediction439 == 2: - _t881 = self.parse_int_type() - int_type442 = _t881 - _t882 = logic_pb2.Type(int_type=int_type442) - _t880 = _t882 + if prediction443 == 2: + _t889 = self.parse_int_type() + int_type446 = _t889 + _t890 = logic_pb2.Type(int_type=int_type446) + _t888 = _t890 else: - if prediction439 == 1: - _t884 = self.parse_string_type() - string_type441 = _t884 - _t885 = logic_pb2.Type(string_type=string_type441) - _t883 = _t885 + if prediction443 == 1: + _t892 = self.parse_string_type() + string_type445 = _t892 + _t893 = logic_pb2.Type(string_type=string_type445) + _t891 = _t893 else: - if prediction439 == 0: - _t887 = self.parse_unspecified_type() - unspecified_type440 = _t887 - _t888 = logic_pb2.Type(unspecified_type=unspecified_type440) - _t886 = _t888 + if prediction443 == 0: + _t895 = self.parse_unspecified_type() + unspecified_type444 = _t895 + _t896 = logic_pb2.Type(unspecified_type=unspecified_type444) + _t894 = _t896 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t883 = _t886 - _t880 = _t883 - _t877 = _t880 - _t874 = _t877 - _t871 = _t874 - _t868 = _t871 - _t865 = _t868 - _t862 = _t865 - _t859 = _t862 - _t856 = _t859 - return _t856 + _t891 = _t894 + _t888 = _t891 + _t885 = _t888 + _t882 = _t885 + _t879 = _t882 + _t876 = _t879 + _t873 = _t876 + _t870 = _t873 + _t867 = _t870 + _t864 = _t867 + return _t864 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: self.consume_literal("UNKNOWN") - _t889 = logic_pb2.UnspecifiedType() - return _t889 + _t897 = logic_pb2.UnspecifiedType() + return _t897 def parse_string_type(self) -> logic_pb2.StringType: self.consume_literal("STRING") - _t890 = logic_pb2.StringType() - return _t890 + _t898 = logic_pb2.StringType() + return _t898 def parse_int_type(self) -> logic_pb2.IntType: self.consume_literal("INT") - _t891 = logic_pb2.IntType() - return _t891 + _t899 = logic_pb2.IntType() + return _t899 def parse_float_type(self) -> logic_pb2.FloatType: self.consume_literal("FLOAT") - _t892 = logic_pb2.FloatType() - return _t892 + _t900 = logic_pb2.FloatType() + return _t900 def parse_uint128_type(self) -> logic_pb2.UInt128Type: self.consume_literal("UINT128") - _t893 = logic_pb2.UInt128Type() - return _t893 + _t901 = logic_pb2.UInt128Type() + return _t901 def parse_int128_type(self) -> logic_pb2.Int128Type: self.consume_literal("INT128") - _t894 = logic_pb2.Int128Type() - return _t894 + _t902 = logic_pb2.Int128Type() + return _t902 def parse_date_type(self) -> logic_pb2.DateType: self.consume_literal("DATE") - _t895 = logic_pb2.DateType() - return _t895 + _t903 = logic_pb2.DateType() + return _t903 def parse_datetime_type(self) -> logic_pb2.DateTimeType: self.consume_literal("DATETIME") - _t896 = logic_pb2.DateTimeType() - return _t896 + _t904 = logic_pb2.DateTimeType() + return _t904 def parse_missing_type(self) -> logic_pb2.MissingType: self.consume_literal("MISSING") - _t897 = logic_pb2.MissingType() - return _t897 + _t905 = logic_pb2.MissingType() + return _t905 def parse_decimal_type(self) -> logic_pb2.DecimalType: self.consume_literal("(") self.consume_literal("DECIMAL") - int451 = self.consume_terminal("INT") - int_3452 = self.consume_terminal("INT") + int455 = self.consume_terminal("INT") + int_3456 = self.consume_terminal("INT") self.consume_literal(")") - _t898 = logic_pb2.DecimalType(precision=int(int451), scale=int(int_3452)) - return _t898 + _t906 = logic_pb2.DecimalType(precision=int(int455), scale=int(int_3456)) + return _t906 def parse_boolean_type(self) -> logic_pb2.BooleanType: self.consume_literal("BOOLEAN") - _t899 = logic_pb2.BooleanType() - return _t899 + _t907 = logic_pb2.BooleanType() + return _t907 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs453 = [] - cond454 = self.match_lookahead_terminal("SYMBOL", 0) - while cond454: - _t900 = self.parse_binding() - item455 = _t900 - xs453.append(item455) - cond454 = self.match_lookahead_terminal("SYMBOL", 0) - bindings456 = xs453 - return bindings456 + xs457 = [] + cond458 = self.match_lookahead_terminal("SYMBOL", 0) + while cond458: + _t908 = self.parse_binding() + item459 = _t908 + xs457.append(item459) + cond458 = self.match_lookahead_terminal("SYMBOL", 0) + bindings460 = xs457 + return bindings460 def parse_formula(self) -> logic_pb2.Formula: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t902 = 0 + _t910 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t903 = 11 + _t911 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t904 = 3 + _t912 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t905 = 10 + _t913 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t906 = 9 + _t914 = 9 else: if self.match_lookahead_literal("or", 1): - _t907 = 5 + _t915 = 5 else: if self.match_lookahead_literal("not", 1): - _t908 = 6 + _t916 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t909 = 7 + _t917 = 7 else: if self.match_lookahead_literal("false", 1): - _t910 = 1 + _t918 = 1 else: if self.match_lookahead_literal("exists", 1): - _t911 = 2 + _t919 = 2 else: if self.match_lookahead_literal("cast", 1): - _t912 = 12 + _t920 = 12 else: if self.match_lookahead_literal("atom", 1): - _t913 = 8 + _t921 = 8 else: if self.match_lookahead_literal("and", 1): - _t914 = 4 + _t922 = 4 else: if self.match_lookahead_literal(">=", 1): - _t915 = 10 + _t923 = 10 else: if self.match_lookahead_literal(">", 1): - _t916 = 10 + _t924 = 10 else: if self.match_lookahead_literal("=", 1): - _t917 = 10 + _t925 = 10 else: if self.match_lookahead_literal("<=", 1): - _t918 = 10 + _t926 = 10 else: if self.match_lookahead_literal("<", 1): - _t919 = 10 + _t927 = 10 else: if self.match_lookahead_literal("/", 1): - _t920 = 10 + _t928 = 10 else: if self.match_lookahead_literal("-", 1): - _t921 = 10 + _t929 = 10 else: if self.match_lookahead_literal("+", 1): - _t922 = 10 + _t930 = 10 else: if self.match_lookahead_literal("*", 1): - _t923 = 10 + _t931 = 10 else: - _t923 = -1 - _t922 = _t923 - _t921 = _t922 - _t920 = _t921 - _t919 = _t920 - _t918 = _t919 - _t917 = _t918 - _t916 = _t917 - _t915 = _t916 - _t914 = _t915 - _t913 = _t914 - _t912 = _t913 - _t911 = _t912 - _t910 = _t911 - _t909 = _t910 - _t908 = _t909 - _t907 = _t908 - _t906 = _t907 - _t905 = _t906 - _t904 = _t905 - _t903 = _t904 - _t902 = _t903 - _t901 = _t902 - else: - _t901 = -1 - prediction457 = _t901 - if prediction457 == 12: - _t925 = self.parse_cast() - cast470 = _t925 - _t926 = logic_pb2.Formula(cast=cast470) - _t924 = _t926 - else: - if prediction457 == 11: - _t928 = self.parse_rel_atom() - rel_atom469 = _t928 - _t929 = logic_pb2.Formula(rel_atom=rel_atom469) - _t927 = _t929 + _t931 = -1 + _t930 = _t931 + _t929 = _t930 + _t928 = _t929 + _t927 = _t928 + _t926 = _t927 + _t925 = _t926 + _t924 = _t925 + _t923 = _t924 + _t922 = _t923 + _t921 = _t922 + _t920 = _t921 + _t919 = _t920 + _t918 = _t919 + _t917 = _t918 + _t916 = _t917 + _t915 = _t916 + _t914 = _t915 + _t913 = _t914 + _t912 = _t913 + _t911 = _t912 + _t910 = _t911 + _t909 = _t910 + else: + _t909 = -1 + prediction461 = _t909 + if prediction461 == 12: + _t933 = self.parse_cast() + cast474 = _t933 + _t934 = logic_pb2.Formula(cast=cast474) + _t932 = _t934 + else: + if prediction461 == 11: + _t936 = self.parse_rel_atom() + rel_atom473 = _t936 + _t937 = logic_pb2.Formula(rel_atom=rel_atom473) + _t935 = _t937 else: - if prediction457 == 10: - _t931 = self.parse_primitive() - primitive468 = _t931 - _t932 = logic_pb2.Formula(primitive=primitive468) - _t930 = _t932 + if prediction461 == 10: + _t939 = self.parse_primitive() + primitive472 = _t939 + _t940 = logic_pb2.Formula(primitive=primitive472) + _t938 = _t940 else: - if prediction457 == 9: - _t934 = self.parse_pragma() - pragma467 = _t934 - _t935 = logic_pb2.Formula(pragma=pragma467) - _t933 = _t935 + if prediction461 == 9: + _t942 = self.parse_pragma() + pragma471 = _t942 + _t943 = logic_pb2.Formula(pragma=pragma471) + _t941 = _t943 else: - if prediction457 == 8: - _t937 = self.parse_atom() - atom466 = _t937 - _t938 = logic_pb2.Formula(atom=atom466) - _t936 = _t938 + if prediction461 == 8: + _t945 = self.parse_atom() + atom470 = _t945 + _t946 = logic_pb2.Formula(atom=atom470) + _t944 = _t946 else: - if prediction457 == 7: - _t940 = self.parse_ffi() - ffi465 = _t940 - _t941 = logic_pb2.Formula(ffi=ffi465) - _t939 = _t941 + if prediction461 == 7: + _t948 = self.parse_ffi() + ffi469 = _t948 + _t949 = logic_pb2.Formula(ffi=ffi469) + _t947 = _t949 else: - if prediction457 == 6: - _t943 = self.parse_not() - not464 = _t943 - _t944 = logic_pb2.Formula() - getattr(_t944, 'not').CopyFrom(not464) - _t942 = _t944 + if prediction461 == 6: + _t951 = self.parse_not() + not468 = _t951 + _t952 = logic_pb2.Formula() + getattr(_t952, 'not').CopyFrom(not468) + _t950 = _t952 else: - if prediction457 == 5: - _t946 = self.parse_disjunction() - disjunction463 = _t946 - _t947 = logic_pb2.Formula(disjunction=disjunction463) - _t945 = _t947 + if prediction461 == 5: + _t954 = self.parse_disjunction() + disjunction467 = _t954 + _t955 = logic_pb2.Formula(disjunction=disjunction467) + _t953 = _t955 else: - if prediction457 == 4: - _t949 = self.parse_conjunction() - conjunction462 = _t949 - _t950 = logic_pb2.Formula(conjunction=conjunction462) - _t948 = _t950 + if prediction461 == 4: + _t957 = self.parse_conjunction() + conjunction466 = _t957 + _t958 = logic_pb2.Formula(conjunction=conjunction466) + _t956 = _t958 else: - if prediction457 == 3: - _t952 = self.parse_reduce() - reduce461 = _t952 - _t953 = logic_pb2.Formula(reduce=reduce461) - _t951 = _t953 + if prediction461 == 3: + _t960 = self.parse_reduce() + reduce465 = _t960 + _t961 = logic_pb2.Formula(reduce=reduce465) + _t959 = _t961 else: - if prediction457 == 2: - _t955 = self.parse_exists() - exists460 = _t955 - _t956 = logic_pb2.Formula(exists=exists460) - _t954 = _t956 + if prediction461 == 2: + _t963 = self.parse_exists() + exists464 = _t963 + _t964 = logic_pb2.Formula(exists=exists464) + _t962 = _t964 else: - if prediction457 == 1: - _t958 = self.parse_false() - false459 = _t958 - _t959 = logic_pb2.Formula(disjunction=false459) - _t957 = _t959 + if prediction461 == 1: + _t966 = self.parse_false() + false463 = _t966 + _t967 = logic_pb2.Formula(disjunction=false463) + _t965 = _t967 else: - if prediction457 == 0: - _t961 = self.parse_true() - true458 = _t961 - _t962 = logic_pb2.Formula(conjunction=true458) - _t960 = _t962 + if prediction461 == 0: + _t969 = self.parse_true() + true462 = _t969 + _t970 = logic_pb2.Formula(conjunction=true462) + _t968 = _t970 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t957 = _t960 - _t954 = _t957 - _t951 = _t954 - _t948 = _t951 - _t945 = _t948 - _t942 = _t945 - _t939 = _t942 - _t936 = _t939 - _t933 = _t936 - _t930 = _t933 - _t927 = _t930 - _t924 = _t927 - return _t924 + _t965 = _t968 + _t962 = _t965 + _t959 = _t962 + _t956 = _t959 + _t953 = _t956 + _t950 = _t953 + _t947 = _t950 + _t944 = _t947 + _t941 = _t944 + _t938 = _t941 + _t935 = _t938 + _t932 = _t935 + return _t932 def parse_true(self) -> logic_pb2.Conjunction: self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t963 = logic_pb2.Conjunction(args=[]) - return _t963 + _t971 = logic_pb2.Conjunction(args=[]) + return _t971 def parse_false(self) -> logic_pb2.Disjunction: self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t964 = logic_pb2.Disjunction(args=[]) - return _t964 + _t972 = logic_pb2.Disjunction(args=[]) + return _t972 def parse_exists(self) -> logic_pb2.Exists: self.consume_literal("(") self.consume_literal("exists") - _t965 = self.parse_bindings() - bindings471 = _t965 - _t966 = self.parse_formula() - formula472 = _t966 + _t973 = self.parse_bindings() + bindings475 = _t973 + _t974 = self.parse_formula() + formula476 = _t974 self.consume_literal(")") - _t967 = logic_pb2.Abstraction(vars=(list(bindings471[0]) + list(bindings471[1] if bindings471[1] is not None else [])), value=formula472) - _t968 = logic_pb2.Exists(body=_t967) - return _t968 + _t975 = logic_pb2.Abstraction(vars=(list(bindings475[0]) + list(bindings475[1] if bindings475[1] is not None else [])), value=formula476) + _t976 = logic_pb2.Exists(body=_t975) + return _t976 def parse_reduce(self) -> logic_pb2.Reduce: self.consume_literal("(") self.consume_literal("reduce") - _t969 = self.parse_abstraction() - abstraction473 = _t969 - _t970 = self.parse_abstraction() - abstraction_3474 = _t970 - _t971 = self.parse_terms() - terms475 = _t971 - self.consume_literal(")") - _t972 = logic_pb2.Reduce(op=abstraction473, body=abstraction_3474, terms=terms475) - return _t972 + _t977 = self.parse_abstraction() + abstraction477 = _t977 + _t978 = self.parse_abstraction() + abstraction_3478 = _t978 + _t979 = self.parse_terms() + terms479 = _t979 + self.consume_literal(")") + _t980 = logic_pb2.Reduce(op=abstraction477, body=abstraction_3478, terms=terms479) + return _t980 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs476 = [] - cond477 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond477: - _t973 = self.parse_term() - item478 = _t973 - xs476.append(item478) - cond477 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms479 = xs476 + xs480 = [] + cond481 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond481: + _t981 = self.parse_term() + item482 = _t981 + xs480.append(item482) + cond481 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms483 = xs480 self.consume_literal(")") - return terms479 + return terms483 def parse_term(self) -> logic_pb2.Term: if self.match_lookahead_literal("true", 0): - _t974 = 1 + _t982 = 1 else: if self.match_lookahead_literal("missing", 0): - _t975 = 1 + _t983 = 1 else: if self.match_lookahead_literal("false", 0): - _t976 = 1 + _t984 = 1 else: if self.match_lookahead_literal("(", 0): - _t977 = 1 + _t985 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t978 = 1 + _t986 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t979 = 0 + _t987 = 0 else: if self.match_lookahead_terminal("STRING", 0): - _t980 = 1 + _t988 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t981 = 1 + _t989 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t982 = 1 + _t990 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t983 = 1 + _t991 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t984 = 1 + _t992 = 1 else: - _t984 = -1 - _t983 = _t984 - _t982 = _t983 - _t981 = _t982 - _t980 = _t981 - _t979 = _t980 - _t978 = _t979 - _t977 = _t978 - _t976 = _t977 - _t975 = _t976 - _t974 = _t975 - prediction480 = _t974 - if prediction480 == 1: - _t986 = self.parse_constant() - constant482 = _t986 - _t987 = logic_pb2.Term(constant=constant482) - _t985 = _t987 - else: - if prediction480 == 0: - _t989 = self.parse_var() - var481 = _t989 - _t990 = logic_pb2.Term(var=var481) - _t988 = _t990 + _t992 = -1 + _t991 = _t992 + _t990 = _t991 + _t989 = _t990 + _t988 = _t989 + _t987 = _t988 + _t986 = _t987 + _t985 = _t986 + _t984 = _t985 + _t983 = _t984 + _t982 = _t983 + prediction484 = _t982 + if prediction484 == 1: + _t994 = self.parse_constant() + constant486 = _t994 + _t995 = logic_pb2.Term(constant=constant486) + _t993 = _t995 + else: + if prediction484 == 0: + _t997 = self.parse_var() + var485 = _t997 + _t998 = logic_pb2.Term(var=var485) + _t996 = _t998 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t985 = _t988 - return _t985 + _t993 = _t996 + return _t993 def parse_var(self) -> logic_pb2.Var: - symbol483 = self.consume_terminal("SYMBOL") - _t991 = logic_pb2.Var(name=symbol483) - return _t991 + symbol487 = self.consume_terminal("SYMBOL") + _t999 = logic_pb2.Var(name=symbol487) + return _t999 def parse_constant(self) -> logic_pb2.Value: - _t992 = self.parse_value() - value484 = _t992 - return value484 + _t1000 = self.parse_value() + value488 = _t1000 + return value488 def parse_conjunction(self) -> logic_pb2.Conjunction: self.consume_literal("(") self.consume_literal("and") - xs485 = [] - cond486 = self.match_lookahead_literal("(", 0) - while cond486: - _t993 = self.parse_formula() - item487 = _t993 - xs485.append(item487) - cond486 = self.match_lookahead_literal("(", 0) - formulas488 = xs485 - self.consume_literal(")") - _t994 = logic_pb2.Conjunction(args=formulas488) - return _t994 - - def parse_disjunction(self) -> logic_pb2.Disjunction: - self.consume_literal("(") - self.consume_literal("or") xs489 = [] cond490 = self.match_lookahead_literal("(", 0) while cond490: - _t995 = self.parse_formula() - item491 = _t995 + _t1001 = self.parse_formula() + item491 = _t1001 xs489.append(item491) cond490 = self.match_lookahead_literal("(", 0) formulas492 = xs489 self.consume_literal(")") - _t996 = logic_pb2.Disjunction(args=formulas492) - return _t996 + _t1002 = logic_pb2.Conjunction(args=formulas492) + return _t1002 + + def parse_disjunction(self) -> logic_pb2.Disjunction: + self.consume_literal("(") + self.consume_literal("or") + xs493 = [] + cond494 = self.match_lookahead_literal("(", 0) + while cond494: + _t1003 = self.parse_formula() + item495 = _t1003 + xs493.append(item495) + cond494 = self.match_lookahead_literal("(", 0) + formulas496 = xs493 + self.consume_literal(")") + _t1004 = logic_pb2.Disjunction(args=formulas496) + return _t1004 def parse_not(self) -> logic_pb2.Not: self.consume_literal("(") self.consume_literal("not") - _t997 = self.parse_formula() - formula493 = _t997 + _t1005 = self.parse_formula() + formula497 = _t1005 self.consume_literal(")") - _t998 = logic_pb2.Not(arg=formula493) - return _t998 + _t1006 = logic_pb2.Not(arg=formula497) + return _t1006 def parse_ffi(self) -> logic_pb2.FFI: self.consume_literal("(") self.consume_literal("ffi") - _t999 = self.parse_name() - name494 = _t999 - _t1000 = self.parse_ffi_args() - ffi_args495 = _t1000 - _t1001 = self.parse_terms() - terms496 = _t1001 - self.consume_literal(")") - _t1002 = logic_pb2.FFI(name=name494, args=ffi_args495, terms=terms496) - return _t1002 + _t1007 = self.parse_name() + name498 = _t1007 + _t1008 = self.parse_ffi_args() + ffi_args499 = _t1008 + _t1009 = self.parse_terms() + terms500 = _t1009 + self.consume_literal(")") + _t1010 = logic_pb2.FFI(name=name498, args=ffi_args499, terms=terms500) + return _t1010 def parse_name(self) -> str: self.consume_literal(":") - symbol497 = self.consume_terminal("SYMBOL") - return symbol497 + symbol501 = self.consume_terminal("SYMBOL") + return symbol501 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs498 = [] - cond499 = self.match_lookahead_literal("(", 0) - while cond499: - _t1003 = self.parse_abstraction() - item500 = _t1003 - xs498.append(item500) - cond499 = self.match_lookahead_literal("(", 0) - abstractions501 = xs498 + xs502 = [] + cond503 = self.match_lookahead_literal("(", 0) + while cond503: + _t1011 = self.parse_abstraction() + item504 = _t1011 + xs502.append(item504) + cond503 = self.match_lookahead_literal("(", 0) + abstractions505 = xs502 self.consume_literal(")") - return abstractions501 + return abstractions505 def parse_atom(self) -> logic_pb2.Atom: self.consume_literal("(") self.consume_literal("atom") - _t1004 = self.parse_relation_id() - relation_id502 = _t1004 - xs503 = [] - cond504 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond504: - _t1005 = self.parse_term() - item505 = _t1005 - xs503.append(item505) - cond504 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms506 = xs503 - self.consume_literal(")") - _t1006 = logic_pb2.Atom(name=relation_id502, terms=terms506) - return _t1006 + _t1012 = self.parse_relation_id() + relation_id506 = _t1012 + xs507 = [] + cond508 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond508: + _t1013 = self.parse_term() + item509 = _t1013 + xs507.append(item509) + cond508 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms510 = xs507 + self.consume_literal(")") + _t1014 = logic_pb2.Atom(name=relation_id506, terms=terms510) + return _t1014 def parse_pragma(self) -> logic_pb2.Pragma: self.consume_literal("(") self.consume_literal("pragma") - _t1007 = self.parse_name() - name507 = _t1007 - xs508 = [] - cond509 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond509: - _t1008 = self.parse_term() - item510 = _t1008 - xs508.append(item510) - cond509 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - terms511 = xs508 - self.consume_literal(")") - _t1009 = logic_pb2.Pragma(name=name507, terms=terms511) - return _t1009 + _t1015 = self.parse_name() + name511 = _t1015 + xs512 = [] + cond513 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond513: + _t1016 = self.parse_term() + item514 = _t1016 + xs512.append(item514) + cond513 = ((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + terms515 = xs512 + self.consume_literal(")") + _t1017 = logic_pb2.Pragma(name=name511, terms=terms515) + return _t1017 def parse_primitive(self) -> logic_pb2.Primitive: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1011 = 9 + _t1019 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1012 = 4 + _t1020 = 4 else: if self.match_lookahead_literal(">", 1): - _t1013 = 3 + _t1021 = 3 else: if self.match_lookahead_literal("=", 1): - _t1014 = 0 + _t1022 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1015 = 2 + _t1023 = 2 else: if self.match_lookahead_literal("<", 1): - _t1016 = 1 + _t1024 = 1 else: if self.match_lookahead_literal("/", 1): - _t1017 = 8 + _t1025 = 8 else: if self.match_lookahead_literal("-", 1): - _t1018 = 6 + _t1026 = 6 else: if self.match_lookahead_literal("+", 1): - _t1019 = 5 + _t1027 = 5 else: if self.match_lookahead_literal("*", 1): - _t1020 = 7 + _t1028 = 7 else: - _t1020 = -1 - _t1019 = _t1020 - _t1018 = _t1019 - _t1017 = _t1018 - _t1016 = _t1017 - _t1015 = _t1016 - _t1014 = _t1015 - _t1013 = _t1014 - _t1012 = _t1013 - _t1011 = _t1012 - _t1010 = _t1011 - else: - _t1010 = -1 - prediction512 = _t1010 - if prediction512 == 9: + _t1028 = -1 + _t1027 = _t1028 + _t1026 = _t1027 + _t1025 = _t1026 + _t1024 = _t1025 + _t1023 = _t1024 + _t1022 = _t1023 + _t1021 = _t1022 + _t1020 = _t1021 + _t1019 = _t1020 + _t1018 = _t1019 + else: + _t1018 = -1 + prediction516 = _t1018 + if prediction516 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1022 = self.parse_name() - name522 = _t1022 - xs523 = [] - cond524 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond524: - _t1023 = self.parse_rel_term() - item525 = _t1023 - xs523.append(item525) - cond524 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - rel_terms526 = xs523 + _t1030 = self.parse_name() + name526 = _t1030 + xs527 = [] + cond528 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond528: + _t1031 = self.parse_rel_term() + item529 = _t1031 + xs527.append(item529) + cond528 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + rel_terms530 = xs527 self.consume_literal(")") - _t1024 = logic_pb2.Primitive(name=name522, terms=rel_terms526) - _t1021 = _t1024 + _t1032 = logic_pb2.Primitive(name=name526, terms=rel_terms530) + _t1029 = _t1032 else: - if prediction512 == 8: - _t1026 = self.parse_divide() - divide521 = _t1026 - _t1025 = divide521 + if prediction516 == 8: + _t1034 = self.parse_divide() + divide525 = _t1034 + _t1033 = divide525 else: - if prediction512 == 7: - _t1028 = self.parse_multiply() - multiply520 = _t1028 - _t1027 = multiply520 + if prediction516 == 7: + _t1036 = self.parse_multiply() + multiply524 = _t1036 + _t1035 = multiply524 else: - if prediction512 == 6: - _t1030 = self.parse_minus() - minus519 = _t1030 - _t1029 = minus519 + if prediction516 == 6: + _t1038 = self.parse_minus() + minus523 = _t1038 + _t1037 = minus523 else: - if prediction512 == 5: - _t1032 = self.parse_add() - add518 = _t1032 - _t1031 = add518 + if prediction516 == 5: + _t1040 = self.parse_add() + add522 = _t1040 + _t1039 = add522 else: - if prediction512 == 4: - _t1034 = self.parse_gt_eq() - gt_eq517 = _t1034 - _t1033 = gt_eq517 + if prediction516 == 4: + _t1042 = self.parse_gt_eq() + gt_eq521 = _t1042 + _t1041 = gt_eq521 else: - if prediction512 == 3: - _t1036 = self.parse_gt() - gt516 = _t1036 - _t1035 = gt516 + if prediction516 == 3: + _t1044 = self.parse_gt() + gt520 = _t1044 + _t1043 = gt520 else: - if prediction512 == 2: - _t1038 = self.parse_lt_eq() - lt_eq515 = _t1038 - _t1037 = lt_eq515 + if prediction516 == 2: + _t1046 = self.parse_lt_eq() + lt_eq519 = _t1046 + _t1045 = lt_eq519 else: - if prediction512 == 1: - _t1040 = self.parse_lt() - lt514 = _t1040 - _t1039 = lt514 + if prediction516 == 1: + _t1048 = self.parse_lt() + lt518 = _t1048 + _t1047 = lt518 else: - if prediction512 == 0: - _t1042 = self.parse_eq() - eq513 = _t1042 - _t1041 = eq513 + if prediction516 == 0: + _t1050 = self.parse_eq() + eq517 = _t1050 + _t1049 = eq517 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1039 = _t1041 - _t1037 = _t1039 - _t1035 = _t1037 - _t1033 = _t1035 - _t1031 = _t1033 - _t1029 = _t1031 - _t1027 = _t1029 - _t1025 = _t1027 - _t1021 = _t1025 - return _t1021 + _t1047 = _t1049 + _t1045 = _t1047 + _t1043 = _t1045 + _t1041 = _t1043 + _t1039 = _t1041 + _t1037 = _t1039 + _t1035 = _t1037 + _t1033 = _t1035 + _t1029 = _t1033 + return _t1029 def parse_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("=") - _t1043 = self.parse_term() - term527 = _t1043 - _t1044 = self.parse_term() - term_3528 = _t1044 + _t1051 = self.parse_term() + term531 = _t1051 + _t1052 = self.parse_term() + term_3532 = _t1052 self.consume_literal(")") - _t1045 = logic_pb2.RelTerm(term=term527) - _t1046 = logic_pb2.RelTerm(term=term_3528) - _t1047 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1045, _t1046]) - return _t1047 + _t1053 = logic_pb2.RelTerm(term=term531) + _t1054 = logic_pb2.RelTerm(term=term_3532) + _t1055 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1053, _t1054]) + return _t1055 def parse_lt(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("<") - _t1048 = self.parse_term() - term529 = _t1048 - _t1049 = self.parse_term() - term_3530 = _t1049 + _t1056 = self.parse_term() + term533 = _t1056 + _t1057 = self.parse_term() + term_3534 = _t1057 self.consume_literal(")") - _t1050 = logic_pb2.RelTerm(term=term529) - _t1051 = logic_pb2.RelTerm(term=term_3530) - _t1052 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1050, _t1051]) - return _t1052 + _t1058 = logic_pb2.RelTerm(term=term533) + _t1059 = logic_pb2.RelTerm(term=term_3534) + _t1060 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1058, _t1059]) + return _t1060 def parse_lt_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("<=") - _t1053 = self.parse_term() - term531 = _t1053 - _t1054 = self.parse_term() - term_3532 = _t1054 + _t1061 = self.parse_term() + term535 = _t1061 + _t1062 = self.parse_term() + term_3536 = _t1062 self.consume_literal(")") - _t1055 = logic_pb2.RelTerm(term=term531) - _t1056 = logic_pb2.RelTerm(term=term_3532) - _t1057 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1055, _t1056]) - return _t1057 + _t1063 = logic_pb2.RelTerm(term=term535) + _t1064 = logic_pb2.RelTerm(term=term_3536) + _t1065 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1063, _t1064]) + return _t1065 def parse_gt(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal(">") - _t1058 = self.parse_term() - term533 = _t1058 - _t1059 = self.parse_term() - term_3534 = _t1059 + _t1066 = self.parse_term() + term537 = _t1066 + _t1067 = self.parse_term() + term_3538 = _t1067 self.consume_literal(")") - _t1060 = logic_pb2.RelTerm(term=term533) - _t1061 = logic_pb2.RelTerm(term=term_3534) - _t1062 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1060, _t1061]) - return _t1062 + _t1068 = logic_pb2.RelTerm(term=term537) + _t1069 = logic_pb2.RelTerm(term=term_3538) + _t1070 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1068, _t1069]) + return _t1070 def parse_gt_eq(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal(">=") - _t1063 = self.parse_term() - term535 = _t1063 - _t1064 = self.parse_term() - term_3536 = _t1064 + _t1071 = self.parse_term() + term539 = _t1071 + _t1072 = self.parse_term() + term_3540 = _t1072 self.consume_literal(")") - _t1065 = logic_pb2.RelTerm(term=term535) - _t1066 = logic_pb2.RelTerm(term=term_3536) - _t1067 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1065, _t1066]) - return _t1067 + _t1073 = logic_pb2.RelTerm(term=term539) + _t1074 = logic_pb2.RelTerm(term=term_3540) + _t1075 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1073, _t1074]) + return _t1075 def parse_add(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("+") - _t1068 = self.parse_term() - term537 = _t1068 - _t1069 = self.parse_term() - term_3538 = _t1069 - _t1070 = self.parse_term() - term_4539 = _t1070 - self.consume_literal(")") - _t1071 = logic_pb2.RelTerm(term=term537) - _t1072 = logic_pb2.RelTerm(term=term_3538) - _t1073 = logic_pb2.RelTerm(term=term_4539) - _t1074 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1071, _t1072, _t1073]) - return _t1074 + _t1076 = self.parse_term() + term541 = _t1076 + _t1077 = self.parse_term() + term_3542 = _t1077 + _t1078 = self.parse_term() + term_4543 = _t1078 + self.consume_literal(")") + _t1079 = logic_pb2.RelTerm(term=term541) + _t1080 = logic_pb2.RelTerm(term=term_3542) + _t1081 = logic_pb2.RelTerm(term=term_4543) + _t1082 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1079, _t1080, _t1081]) + return _t1082 def parse_minus(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("-") - _t1075 = self.parse_term() - term540 = _t1075 - _t1076 = self.parse_term() - term_3541 = _t1076 - _t1077 = self.parse_term() - term_4542 = _t1077 + _t1083 = self.parse_term() + term544 = _t1083 + _t1084 = self.parse_term() + term_3545 = _t1084 + _t1085 = self.parse_term() + term_4546 = _t1085 self.consume_literal(")") - _t1078 = logic_pb2.RelTerm(term=term540) - _t1079 = logic_pb2.RelTerm(term=term_3541) - _t1080 = logic_pb2.RelTerm(term=term_4542) - _t1081 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1078, _t1079, _t1080]) - return _t1081 + _t1086 = logic_pb2.RelTerm(term=term544) + _t1087 = logic_pb2.RelTerm(term=term_3545) + _t1088 = logic_pb2.RelTerm(term=term_4546) + _t1089 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1086, _t1087, _t1088]) + return _t1089 def parse_multiply(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("*") - _t1082 = self.parse_term() - term543 = _t1082 - _t1083 = self.parse_term() - term_3544 = _t1083 - _t1084 = self.parse_term() - term_4545 = _t1084 + _t1090 = self.parse_term() + term547 = _t1090 + _t1091 = self.parse_term() + term_3548 = _t1091 + _t1092 = self.parse_term() + term_4549 = _t1092 self.consume_literal(")") - _t1085 = logic_pb2.RelTerm(term=term543) - _t1086 = logic_pb2.RelTerm(term=term_3544) - _t1087 = logic_pb2.RelTerm(term=term_4545) - _t1088 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1085, _t1086, _t1087]) - return _t1088 + _t1093 = logic_pb2.RelTerm(term=term547) + _t1094 = logic_pb2.RelTerm(term=term_3548) + _t1095 = logic_pb2.RelTerm(term=term_4549) + _t1096 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1093, _t1094, _t1095]) + return _t1096 def parse_divide(self) -> logic_pb2.Primitive: self.consume_literal("(") self.consume_literal("/") - _t1089 = self.parse_term() - term546 = _t1089 - _t1090 = self.parse_term() - term_3547 = _t1090 - _t1091 = self.parse_term() - term_4548 = _t1091 - self.consume_literal(")") - _t1092 = logic_pb2.RelTerm(term=term546) - _t1093 = logic_pb2.RelTerm(term=term_3547) - _t1094 = logic_pb2.RelTerm(term=term_4548) - _t1095 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1092, _t1093, _t1094]) - return _t1095 + _t1097 = self.parse_term() + term550 = _t1097 + _t1098 = self.parse_term() + term_3551 = _t1098 + _t1099 = self.parse_term() + term_4552 = _t1099 + self.consume_literal(")") + _t1100 = logic_pb2.RelTerm(term=term550) + _t1101 = logic_pb2.RelTerm(term=term_3551) + _t1102 = logic_pb2.RelTerm(term=term_4552) + _t1103 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1100, _t1101, _t1102]) + return _t1103 def parse_rel_term(self) -> logic_pb2.RelTerm: if self.match_lookahead_literal("true", 0): - _t1096 = 1 + _t1104 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1097 = 1 + _t1105 = 1 else: if self.match_lookahead_literal("false", 0): - _t1098 = 1 + _t1106 = 1 else: if self.match_lookahead_literal("(", 0): - _t1099 = 1 + _t1107 = 1 else: if self.match_lookahead_literal("#", 0): - _t1100 = 0 + _t1108 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1101 = 1 + _t1109 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1102 = 1 + _t1110 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1103 = 1 + _t1111 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1104 = 1 + _t1112 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1105 = 1 + _t1113 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1106 = 1 + _t1114 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1107 = 1 + _t1115 = 1 else: - _t1107 = -1 - _t1106 = _t1107 - _t1105 = _t1106 - _t1104 = _t1105 - _t1103 = _t1104 - _t1102 = _t1103 - _t1101 = _t1102 - _t1100 = _t1101 - _t1099 = _t1100 - _t1098 = _t1099 - _t1097 = _t1098 - _t1096 = _t1097 - prediction549 = _t1096 - if prediction549 == 1: - _t1109 = self.parse_term() - term551 = _t1109 - _t1110 = logic_pb2.RelTerm(term=term551) - _t1108 = _t1110 - else: - if prediction549 == 0: - _t1112 = self.parse_specialized_value() - specialized_value550 = _t1112 - _t1113 = logic_pb2.RelTerm(specialized_value=specialized_value550) - _t1111 = _t1113 + _t1115 = -1 + _t1114 = _t1115 + _t1113 = _t1114 + _t1112 = _t1113 + _t1111 = _t1112 + _t1110 = _t1111 + _t1109 = _t1110 + _t1108 = _t1109 + _t1107 = _t1108 + _t1106 = _t1107 + _t1105 = _t1106 + _t1104 = _t1105 + prediction553 = _t1104 + if prediction553 == 1: + _t1117 = self.parse_term() + term555 = _t1117 + _t1118 = logic_pb2.RelTerm(term=term555) + _t1116 = _t1118 + else: + if prediction553 == 0: + _t1120 = self.parse_specialized_value() + specialized_value554 = _t1120 + _t1121 = logic_pb2.RelTerm(specialized_value=specialized_value554) + _t1119 = _t1121 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1108 = _t1111 - return _t1108 + _t1116 = _t1119 + return _t1116 def parse_specialized_value(self) -> logic_pb2.Value: self.consume_literal("#") - _t1114 = self.parse_value() - value552 = _t1114 - return value552 + _t1122 = self.parse_value() + value556 = _t1122 + return value556 def parse_rel_atom(self) -> logic_pb2.RelAtom: self.consume_literal("(") self.consume_literal("relatom") - _t1115 = self.parse_name() - name553 = _t1115 - xs554 = [] - cond555 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond555: - _t1116 = self.parse_rel_term() - item556 = _t1116 - xs554.append(item556) - cond555 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) - rel_terms557 = xs554 - self.consume_literal(")") - _t1117 = logic_pb2.RelAtom(name=name553, terms=rel_terms557) - return _t1117 + _t1123 = self.parse_name() + name557 = _t1123 + xs558 = [] + cond559 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + while cond559: + _t1124 = self.parse_rel_term() + item560 = _t1124 + xs558.append(item560) + cond559 = (((((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0)) + rel_terms561 = xs558 + self.consume_literal(")") + _t1125 = logic_pb2.RelAtom(name=name557, terms=rel_terms561) + return _t1125 def parse_cast(self) -> logic_pb2.Cast: self.consume_literal("(") self.consume_literal("cast") - _t1118 = self.parse_term() - term558 = _t1118 - _t1119 = self.parse_term() - term_3559 = _t1119 + _t1126 = self.parse_term() + term562 = _t1126 + _t1127 = self.parse_term() + term_3563 = _t1127 self.consume_literal(")") - _t1120 = logic_pb2.Cast(input=term558, result=term_3559) - return _t1120 + _t1128 = logic_pb2.Cast(input=term562, result=term_3563) + return _t1128 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs560 = [] - cond561 = self.match_lookahead_literal("(", 0) - while cond561: - _t1121 = self.parse_attribute() - item562 = _t1121 - xs560.append(item562) - cond561 = self.match_lookahead_literal("(", 0) - attributes563 = xs560 + xs564 = [] + cond565 = self.match_lookahead_literal("(", 0) + while cond565: + _t1129 = self.parse_attribute() + item566 = _t1129 + xs564.append(item566) + cond565 = self.match_lookahead_literal("(", 0) + attributes567 = xs564 self.consume_literal(")") - return attributes563 + return attributes567 def parse_attribute(self) -> logic_pb2.Attribute: self.consume_literal("(") self.consume_literal("attribute") - _t1122 = self.parse_name() - name564 = _t1122 - xs565 = [] - cond566 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) - while cond566: - _t1123 = self.parse_value() - item567 = _t1123 - xs565.append(item567) - cond566 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) - values568 = xs565 - self.consume_literal(")") - _t1124 = logic_pb2.Attribute(name=name564, args=values568) - return _t1124 - - def parse_algorithm(self) -> logic_pb2.Algorithm: - self.consume_literal("(") - self.consume_literal("algorithm") + _t1130 = self.parse_name() + name568 = _t1130 xs569 = [] - cond570 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + cond570 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) while cond570: - _t1125 = self.parse_relation_id() - item571 = _t1125 + _t1131 = self.parse_value() + item571 = _t1131 xs569.append(item571) - cond570 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids572 = xs569 - _t1126 = self.parse_script() - script573 = _t1126 + cond570 = (((((((((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("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) + values572 = xs569 self.consume_literal(")") - _t1127 = logic_pb2.Algorithm(body=script573) - getattr(_t1127, 'global').extend(relation_ids572) - return _t1127 + _t1132 = logic_pb2.Attribute(name=name568, args=values572) + return _t1132 + + def parse_algorithm(self) -> logic_pb2.Algorithm: + self.consume_literal("(") + self.consume_literal("algorithm") + xs573 = [] + cond574 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond574: + _t1133 = self.parse_relation_id() + item575 = _t1133 + xs573.append(item575) + cond574 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids576 = xs573 + _t1134 = self.parse_script() + script577 = _t1134 + self.consume_literal(")") + _t1135 = logic_pb2.Algorithm(body=script577) + getattr(_t1135, 'global').extend(relation_ids576) + return _t1135 def parse_script(self) -> logic_pb2.Script: self.consume_literal("(") self.consume_literal("script") - xs574 = [] - cond575 = self.match_lookahead_literal("(", 0) - while cond575: - _t1128 = self.parse_construct() - item576 = _t1128 - xs574.append(item576) - cond575 = self.match_lookahead_literal("(", 0) - constructs577 = xs574 - self.consume_literal(")") - _t1129 = logic_pb2.Script(constructs=constructs577) - return _t1129 + xs578 = [] + cond579 = self.match_lookahead_literal("(", 0) + while cond579: + _t1136 = self.parse_construct() + item580 = _t1136 + xs578.append(item580) + cond579 = self.match_lookahead_literal("(", 0) + constructs581 = xs578 + self.consume_literal(")") + _t1137 = logic_pb2.Script(constructs=constructs581) + return _t1137 def parse_construct(self) -> logic_pb2.Construct: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1131 = 1 + _t1139 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1132 = 1 + _t1140 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1133 = 1 + _t1141 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1134 = 0 + _t1142 = 0 else: if self.match_lookahead_literal("break", 1): - _t1135 = 1 + _t1143 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1136 = 1 + _t1144 = 1 else: - _t1136 = -1 - _t1135 = _t1136 - _t1134 = _t1135 - _t1133 = _t1134 - _t1132 = _t1133 - _t1131 = _t1132 - _t1130 = _t1131 - else: - _t1130 = -1 - prediction578 = _t1130 - if prediction578 == 1: - _t1138 = self.parse_instruction() - instruction580 = _t1138 - _t1139 = logic_pb2.Construct(instruction=instruction580) - _t1137 = _t1139 - else: - if prediction578 == 0: - _t1141 = self.parse_loop() - loop579 = _t1141 - _t1142 = logic_pb2.Construct(loop=loop579) - _t1140 = _t1142 + _t1144 = -1 + _t1143 = _t1144 + _t1142 = _t1143 + _t1141 = _t1142 + _t1140 = _t1141 + _t1139 = _t1140 + _t1138 = _t1139 + else: + _t1138 = -1 + prediction582 = _t1138 + if prediction582 == 1: + _t1146 = self.parse_instruction() + instruction584 = _t1146 + _t1147 = logic_pb2.Construct(instruction=instruction584) + _t1145 = _t1147 + else: + if prediction582 == 0: + _t1149 = self.parse_loop() + loop583 = _t1149 + _t1150 = logic_pb2.Construct(loop=loop583) + _t1148 = _t1150 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1137 = _t1140 - return _t1137 + _t1145 = _t1148 + return _t1145 def parse_loop(self) -> logic_pb2.Loop: self.consume_literal("(") self.consume_literal("loop") - _t1143 = self.parse_init() - init581 = _t1143 - _t1144 = self.parse_script() - script582 = _t1144 + _t1151 = self.parse_init() + init585 = _t1151 + _t1152 = self.parse_script() + script586 = _t1152 self.consume_literal(")") - _t1145 = logic_pb2.Loop(init=init581, body=script582) - return _t1145 + _t1153 = logic_pb2.Loop(init=init585, body=script586) + return _t1153 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs583 = [] - cond584 = self.match_lookahead_literal("(", 0) - while cond584: - _t1146 = self.parse_instruction() - item585 = _t1146 - xs583.append(item585) - cond584 = self.match_lookahead_literal("(", 0) - instructions586 = xs583 + xs587 = [] + cond588 = self.match_lookahead_literal("(", 0) + while cond588: + _t1154 = self.parse_instruction() + item589 = _t1154 + xs587.append(item589) + cond588 = self.match_lookahead_literal("(", 0) + instructions590 = xs587 self.consume_literal(")") - return instructions586 + return instructions590 def parse_instruction(self) -> logic_pb2.Instruction: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1148 = 1 + _t1156 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1149 = 4 + _t1157 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1150 = 3 + _t1158 = 3 else: if self.match_lookahead_literal("break", 1): - _t1151 = 2 + _t1159 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1152 = 0 + _t1160 = 0 else: - _t1152 = -1 - _t1151 = _t1152 - _t1150 = _t1151 - _t1149 = _t1150 - _t1148 = _t1149 - _t1147 = _t1148 - else: - _t1147 = -1 - prediction587 = _t1147 - if prediction587 == 4: - _t1154 = self.parse_monus_def() - monus_def592 = _t1154 - _t1155 = logic_pb2.Instruction(monus_def=monus_def592) - _t1153 = _t1155 - else: - if prediction587 == 3: - _t1157 = self.parse_monoid_def() - monoid_def591 = _t1157 - _t1158 = logic_pb2.Instruction(monoid_def=monoid_def591) - _t1156 = _t1158 + _t1160 = -1 + _t1159 = _t1160 + _t1158 = _t1159 + _t1157 = _t1158 + _t1156 = _t1157 + _t1155 = _t1156 + else: + _t1155 = -1 + prediction591 = _t1155 + if prediction591 == 4: + _t1162 = self.parse_monus_def() + monus_def596 = _t1162 + _t1163 = logic_pb2.Instruction(monus_def=monus_def596) + _t1161 = _t1163 + else: + if prediction591 == 3: + _t1165 = self.parse_monoid_def() + monoid_def595 = _t1165 + _t1166 = logic_pb2.Instruction(monoid_def=monoid_def595) + _t1164 = _t1166 else: - if prediction587 == 2: - _t1160 = self.parse_break() - break590 = _t1160 - _t1161 = logic_pb2.Instruction() - getattr(_t1161, 'break').CopyFrom(break590) - _t1159 = _t1161 + if prediction591 == 2: + _t1168 = self.parse_break() + break594 = _t1168 + _t1169 = logic_pb2.Instruction() + getattr(_t1169, 'break').CopyFrom(break594) + _t1167 = _t1169 else: - if prediction587 == 1: - _t1163 = self.parse_upsert() - upsert589 = _t1163 - _t1164 = logic_pb2.Instruction(upsert=upsert589) - _t1162 = _t1164 + if prediction591 == 1: + _t1171 = self.parse_upsert() + upsert593 = _t1171 + _t1172 = logic_pb2.Instruction(upsert=upsert593) + _t1170 = _t1172 else: - if prediction587 == 0: - _t1166 = self.parse_assign() - assign588 = _t1166 - _t1167 = logic_pb2.Instruction(assign=assign588) - _t1165 = _t1167 + if prediction591 == 0: + _t1174 = self.parse_assign() + assign592 = _t1174 + _t1175 = logic_pb2.Instruction(assign=assign592) + _t1173 = _t1175 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1162 = _t1165 - _t1159 = _t1162 - _t1156 = _t1159 - _t1153 = _t1156 - return _t1153 + _t1170 = _t1173 + _t1167 = _t1170 + _t1164 = _t1167 + _t1161 = _t1164 + return _t1161 def parse_assign(self) -> logic_pb2.Assign: self.consume_literal("(") self.consume_literal("assign") - _t1168 = self.parse_relation_id() - relation_id593 = _t1168 - _t1169 = self.parse_abstraction() - abstraction594 = _t1169 + _t1176 = self.parse_relation_id() + relation_id597 = _t1176 + _t1177 = self.parse_abstraction() + abstraction598 = _t1177 if self.match_lookahead_literal("(", 0): - _t1171 = self.parse_attrs() - _t1170 = _t1171 + _t1179 = self.parse_attrs() + _t1178 = _t1179 else: - _t1170 = None - attrs595 = _t1170 + _t1178 = None + attrs599 = _t1178 self.consume_literal(")") - _t1172 = logic_pb2.Assign(name=relation_id593, body=abstraction594, attrs=(attrs595 if attrs595 is not None else [])) - return _t1172 + _t1180 = logic_pb2.Assign(name=relation_id597, body=abstraction598, attrs=(attrs599 if attrs599 is not None else [])) + return _t1180 def parse_upsert(self) -> logic_pb2.Upsert: self.consume_literal("(") self.consume_literal("upsert") - _t1173 = self.parse_relation_id() - relation_id596 = _t1173 - _t1174 = self.parse_abstraction_with_arity() - abstraction_with_arity597 = _t1174 + _t1181 = self.parse_relation_id() + relation_id600 = _t1181 + _t1182 = self.parse_abstraction_with_arity() + abstraction_with_arity601 = _t1182 if self.match_lookahead_literal("(", 0): - _t1176 = self.parse_attrs() - _t1175 = _t1176 + _t1184 = self.parse_attrs() + _t1183 = _t1184 else: - _t1175 = None - attrs598 = _t1175 + _t1183 = None + attrs602 = _t1183 self.consume_literal(")") - _t1177 = logic_pb2.Upsert(name=relation_id596, body=abstraction_with_arity597[0], attrs=(attrs598 if attrs598 is not None else []), value_arity=abstraction_with_arity597[1]) - return _t1177 + _t1185 = logic_pb2.Upsert(name=relation_id600, body=abstraction_with_arity601[0], attrs=(attrs602 if attrs602 is not None else []), value_arity=abstraction_with_arity601[1]) + return _t1185 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1178 = self.parse_bindings() - bindings599 = _t1178 - _t1179 = self.parse_formula() - formula600 = _t1179 + _t1186 = self.parse_bindings() + bindings603 = _t1186 + _t1187 = self.parse_formula() + formula604 = _t1187 self.consume_literal(")") - _t1180 = logic_pb2.Abstraction(vars=(list(bindings599[0]) + list(bindings599[1] if bindings599[1] is not None else [])), value=formula600) - return (_t1180, len(bindings599[1]),) + _t1188 = logic_pb2.Abstraction(vars=(list(bindings603[0]) + list(bindings603[1] if bindings603[1] is not None else [])), value=formula604) + return (_t1188, len(bindings603[1]),) def parse_break(self) -> logic_pb2.Break: self.consume_literal("(") self.consume_literal("break") - _t1181 = self.parse_relation_id() - relation_id601 = _t1181 - _t1182 = self.parse_abstraction() - abstraction602 = _t1182 + _t1189 = self.parse_relation_id() + relation_id605 = _t1189 + _t1190 = self.parse_abstraction() + abstraction606 = _t1190 if self.match_lookahead_literal("(", 0): - _t1184 = self.parse_attrs() - _t1183 = _t1184 + _t1192 = self.parse_attrs() + _t1191 = _t1192 else: - _t1183 = None - attrs603 = _t1183 + _t1191 = None + attrs607 = _t1191 self.consume_literal(")") - _t1185 = logic_pb2.Break(name=relation_id601, body=abstraction602, attrs=(attrs603 if attrs603 is not None else [])) - return _t1185 + _t1193 = logic_pb2.Break(name=relation_id605, body=abstraction606, attrs=(attrs607 if attrs607 is not None else [])) + return _t1193 def parse_monoid_def(self) -> logic_pb2.MonoidDef: self.consume_literal("(") self.consume_literal("monoid") - _t1186 = self.parse_monoid() - monoid604 = _t1186 - _t1187 = self.parse_relation_id() - relation_id605 = _t1187 - _t1188 = self.parse_abstraction_with_arity() - abstraction_with_arity606 = _t1188 + _t1194 = self.parse_monoid() + monoid608 = _t1194 + _t1195 = self.parse_relation_id() + relation_id609 = _t1195 + _t1196 = self.parse_abstraction_with_arity() + abstraction_with_arity610 = _t1196 if self.match_lookahead_literal("(", 0): - _t1190 = self.parse_attrs() - _t1189 = _t1190 + _t1198 = self.parse_attrs() + _t1197 = _t1198 else: - _t1189 = None - attrs607 = _t1189 + _t1197 = None + attrs611 = _t1197 self.consume_literal(")") - _t1191 = logic_pb2.MonoidDef(monoid=monoid604, name=relation_id605, body=abstraction_with_arity606[0], attrs=(attrs607 if attrs607 is not None else []), value_arity=abstraction_with_arity606[1]) - return _t1191 + _t1199 = logic_pb2.MonoidDef(monoid=monoid608, name=relation_id609, body=abstraction_with_arity610[0], attrs=(attrs611 if attrs611 is not None else []), value_arity=abstraction_with_arity610[1]) + return _t1199 def parse_monoid(self) -> logic_pb2.Monoid: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1193 = 3 + _t1201 = 3 else: if self.match_lookahead_literal("or", 1): - _t1194 = 0 + _t1202 = 0 else: if self.match_lookahead_literal("min", 1): - _t1195 = 1 + _t1203 = 1 else: if self.match_lookahead_literal("max", 1): - _t1196 = 2 + _t1204 = 2 else: - _t1196 = -1 - _t1195 = _t1196 - _t1194 = _t1195 - _t1193 = _t1194 - _t1192 = _t1193 - else: - _t1192 = -1 - prediction608 = _t1192 - if prediction608 == 3: - _t1198 = self.parse_sum_monoid() - sum_monoid612 = _t1198 - _t1199 = logic_pb2.Monoid(sum_monoid=sum_monoid612) - _t1197 = _t1199 - else: - if prediction608 == 2: - _t1201 = self.parse_max_monoid() - max_monoid611 = _t1201 - _t1202 = logic_pb2.Monoid(max_monoid=max_monoid611) - _t1200 = _t1202 + _t1204 = -1 + _t1203 = _t1204 + _t1202 = _t1203 + _t1201 = _t1202 + _t1200 = _t1201 + else: + _t1200 = -1 + prediction612 = _t1200 + if prediction612 == 3: + _t1206 = self.parse_sum_monoid() + sum_monoid616 = _t1206 + _t1207 = logic_pb2.Monoid(sum_monoid=sum_monoid616) + _t1205 = _t1207 + else: + if prediction612 == 2: + _t1209 = self.parse_max_monoid() + max_monoid615 = _t1209 + _t1210 = logic_pb2.Monoid(max_monoid=max_monoid615) + _t1208 = _t1210 else: - if prediction608 == 1: - _t1204 = self.parse_min_monoid() - min_monoid610 = _t1204 - _t1205 = logic_pb2.Monoid(min_monoid=min_monoid610) - _t1203 = _t1205 + if prediction612 == 1: + _t1212 = self.parse_min_monoid() + min_monoid614 = _t1212 + _t1213 = logic_pb2.Monoid(min_monoid=min_monoid614) + _t1211 = _t1213 else: - if prediction608 == 0: - _t1207 = self.parse_or_monoid() - or_monoid609 = _t1207 - _t1208 = logic_pb2.Monoid(or_monoid=or_monoid609) - _t1206 = _t1208 + if prediction612 == 0: + _t1215 = self.parse_or_monoid() + or_monoid613 = _t1215 + _t1216 = logic_pb2.Monoid(or_monoid=or_monoid613) + _t1214 = _t1216 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1203 = _t1206 - _t1200 = _t1203 - _t1197 = _t1200 - return _t1197 + _t1211 = _t1214 + _t1208 = _t1211 + _t1205 = _t1208 + return _t1205 def parse_or_monoid(self) -> logic_pb2.OrMonoid: self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1209 = logic_pb2.OrMonoid() - return _t1209 + _t1217 = logic_pb2.OrMonoid() + return _t1217 def parse_min_monoid(self) -> logic_pb2.MinMonoid: self.consume_literal("(") self.consume_literal("min") - _t1210 = self.parse_type() - type613 = _t1210 + _t1218 = self.parse_type() + type617 = _t1218 self.consume_literal(")") - _t1211 = logic_pb2.MinMonoid(type=type613) - return _t1211 + _t1219 = logic_pb2.MinMonoid(type=type617) + return _t1219 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: self.consume_literal("(") self.consume_literal("max") - _t1212 = self.parse_type() - type614 = _t1212 + _t1220 = self.parse_type() + type618 = _t1220 self.consume_literal(")") - _t1213 = logic_pb2.MaxMonoid(type=type614) - return _t1213 + _t1221 = logic_pb2.MaxMonoid(type=type618) + return _t1221 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: self.consume_literal("(") self.consume_literal("sum") - _t1214 = self.parse_type() - type615 = _t1214 + _t1222 = self.parse_type() + type619 = _t1222 self.consume_literal(")") - _t1215 = logic_pb2.SumMonoid(type=type615) - return _t1215 + _t1223 = logic_pb2.SumMonoid(type=type619) + return _t1223 def parse_monus_def(self) -> logic_pb2.MonusDef: self.consume_literal("(") self.consume_literal("monus") - _t1216 = self.parse_monoid() - monoid616 = _t1216 - _t1217 = self.parse_relation_id() - relation_id617 = _t1217 - _t1218 = self.parse_abstraction_with_arity() - abstraction_with_arity618 = _t1218 + _t1224 = self.parse_monoid() + monoid620 = _t1224 + _t1225 = self.parse_relation_id() + relation_id621 = _t1225 + _t1226 = self.parse_abstraction_with_arity() + abstraction_with_arity622 = _t1226 if self.match_lookahead_literal("(", 0): - _t1220 = self.parse_attrs() - _t1219 = _t1220 + _t1228 = self.parse_attrs() + _t1227 = _t1228 else: - _t1219 = None - attrs619 = _t1219 + _t1227 = None + attrs623 = _t1227 self.consume_literal(")") - _t1221 = logic_pb2.MonusDef(monoid=monoid616, name=relation_id617, body=abstraction_with_arity618[0], attrs=(attrs619 if attrs619 is not None else []), value_arity=abstraction_with_arity618[1]) - return _t1221 + _t1229 = logic_pb2.MonusDef(monoid=monoid620, name=relation_id621, body=abstraction_with_arity622[0], attrs=(attrs623 if attrs623 is not None else []), value_arity=abstraction_with_arity622[1]) + return _t1229 def parse_constraint(self) -> logic_pb2.Constraint: self.consume_literal("(") self.consume_literal("functional_dependency") - _t1222 = self.parse_relation_id() - relation_id620 = _t1222 - _t1223 = self.parse_abstraction() - abstraction621 = _t1223 - _t1224 = self.parse_functional_dependency_keys() - functional_dependency_keys622 = _t1224 - _t1225 = self.parse_functional_dependency_values() - functional_dependency_values623 = _t1225 - self.consume_literal(")") - _t1226 = logic_pb2.FunctionalDependency(guard=abstraction621, keys=functional_dependency_keys622, values=functional_dependency_values623) - _t1227 = logic_pb2.Constraint(name=relation_id620, functional_dependency=_t1226) - return _t1227 + _t1230 = self.parse_relation_id() + relation_id624 = _t1230 + _t1231 = self.parse_abstraction() + abstraction625 = _t1231 + _t1232 = self.parse_functional_dependency_keys() + functional_dependency_keys626 = _t1232 + _t1233 = self.parse_functional_dependency_values() + functional_dependency_values627 = _t1233 + self.consume_literal(")") + _t1234 = logic_pb2.FunctionalDependency(guard=abstraction625, keys=functional_dependency_keys626, values=functional_dependency_values627) + _t1235 = logic_pb2.Constraint(name=relation_id624, functional_dependency=_t1234) + return _t1235 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs624 = [] - cond625 = self.match_lookahead_terminal("SYMBOL", 0) - while cond625: - _t1228 = self.parse_var() - item626 = _t1228 - xs624.append(item626) - cond625 = self.match_lookahead_terminal("SYMBOL", 0) - vars627 = xs624 - self.consume_literal(")") - return vars627 - - def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: - self.consume_literal("(") - self.consume_literal("values") xs628 = [] cond629 = self.match_lookahead_terminal("SYMBOL", 0) while cond629: - _t1229 = self.parse_var() - item630 = _t1229 + _t1236 = self.parse_var() + item630 = _t1236 xs628.append(item630) cond629 = self.match_lookahead_terminal("SYMBOL", 0) vars631 = xs628 self.consume_literal(")") return vars631 + def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: + self.consume_literal("(") + self.consume_literal("values") + xs632 = [] + cond633 = self.match_lookahead_terminal("SYMBOL", 0) + while cond633: + _t1237 = self.parse_var() + item634 = _t1237 + xs632.append(item634) + cond633 = self.match_lookahead_terminal("SYMBOL", 0) + vars635 = xs632 + self.consume_literal(")") + return vars635 + def parse_data(self) -> logic_pb2.Data: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("edb", 1): - _t1231 = 0 + _t1239 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1232 = 2 + _t1240 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1233 = 1 + _t1241 = 1 else: - _t1233 = -1 - _t1232 = _t1233 - _t1231 = _t1232 - _t1230 = _t1231 - else: - _t1230 = -1 - prediction632 = _t1230 - if prediction632 == 2: - _t1235 = self.parse_csv_data() - csv_data635 = _t1235 - _t1236 = logic_pb2.Data(csv_data=csv_data635) - _t1234 = _t1236 - else: - if prediction632 == 1: - _t1238 = self.parse_betree_relation() - betree_relation634 = _t1238 - _t1239 = logic_pb2.Data(betree_relation=betree_relation634) - _t1237 = _t1239 + _t1241 = -1 + _t1240 = _t1241 + _t1239 = _t1240 + _t1238 = _t1239 + else: + _t1238 = -1 + prediction636 = _t1238 + if prediction636 == 2: + _t1243 = self.parse_csv_data() + csv_data639 = _t1243 + _t1244 = logic_pb2.Data(csv_data=csv_data639) + _t1242 = _t1244 + else: + if prediction636 == 1: + _t1246 = self.parse_betree_relation() + betree_relation638 = _t1246 + _t1247 = logic_pb2.Data(betree_relation=betree_relation638) + _t1245 = _t1247 else: - if prediction632 == 0: - _t1241 = self.parse_edb() - edb633 = _t1241 - _t1242 = logic_pb2.Data(edb=edb633) - _t1240 = _t1242 + if prediction636 == 0: + _t1249 = self.parse_edb() + edb637 = _t1249 + _t1250 = logic_pb2.Data(edb=edb637) + _t1248 = _t1250 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1237 = _t1240 - _t1234 = _t1237 - return _t1234 + _t1245 = _t1248 + _t1242 = _t1245 + return _t1242 def parse_edb(self) -> logic_pb2.EDB: self.consume_literal("(") self.consume_literal("edb") - _t1243 = self.parse_relation_id() - relation_id636 = _t1243 - _t1244 = self.parse_edb_path() - edb_path637 = _t1244 - _t1245 = self.parse_edb_types() - edb_types638 = _t1245 - self.consume_literal(")") - _t1246 = logic_pb2.EDB(target_id=relation_id636, path=edb_path637, types=edb_types638) - return _t1246 + _t1251 = self.parse_relation_id() + relation_id640 = _t1251 + _t1252 = self.parse_edb_path() + edb_path641 = _t1252 + _t1253 = self.parse_edb_types() + edb_types642 = _t1253 + self.consume_literal(")") + _t1254 = logic_pb2.EDB(target_id=relation_id640, path=edb_path641, types=edb_types642) + return _t1254 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs639 = [] - cond640 = self.match_lookahead_terminal("STRING", 0) - while cond640: - item641 = self.consume_terminal("STRING") - xs639.append(item641) - cond640 = self.match_lookahead_terminal("STRING", 0) - strings642 = xs639 + xs643 = [] + cond644 = self.match_lookahead_terminal("STRING", 0) + while cond644: + item645 = self.consume_terminal("STRING") + xs643.append(item645) + cond644 = self.match_lookahead_terminal("STRING", 0) + strings646 = xs643 self.consume_literal("]") - return strings642 + return strings646 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs643 = [] - cond644 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond644: - _t1247 = self.parse_type() - item645 = _t1247 - xs643.append(item645) - cond644 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types646 = xs643 + xs647 = [] + cond648 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond648: + _t1255 = self.parse_type() + item649 = _t1255 + xs647.append(item649) + cond648 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types650 = xs647 self.consume_literal("]") - return types646 + return types650 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: self.consume_literal("(") self.consume_literal("betree_relation") - _t1248 = self.parse_relation_id() - relation_id647 = _t1248 - _t1249 = self.parse_betree_info() - betree_info648 = _t1249 + _t1256 = self.parse_relation_id() + relation_id651 = _t1256 + _t1257 = self.parse_betree_info() + betree_info652 = _t1257 self.consume_literal(")") - _t1250 = logic_pb2.BeTreeRelation(name=relation_id647, relation_info=betree_info648) - return _t1250 + _t1258 = logic_pb2.BeTreeRelation(name=relation_id651, relation_info=betree_info652) + return _t1258 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: self.consume_literal("(") self.consume_literal("betree_info") - _t1251 = self.parse_betree_info_key_types() - betree_info_key_types649 = _t1251 - _t1252 = self.parse_betree_info_value_types() - betree_info_value_types650 = _t1252 - _t1253 = self.parse_config_dict() - config_dict651 = _t1253 - self.consume_literal(")") - _t1254 = self.construct_betree_info(betree_info_key_types649, betree_info_value_types650, config_dict651) - return _t1254 + _t1259 = self.parse_betree_info_key_types() + betree_info_key_types653 = _t1259 + _t1260 = self.parse_betree_info_value_types() + betree_info_value_types654 = _t1260 + _t1261 = self.parse_config_dict() + config_dict655 = _t1261 + self.consume_literal(")") + _t1262 = self.construct_betree_info(betree_info_key_types653, betree_info_value_types654, config_dict655) + return _t1262 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs652 = [] - cond653 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond653: - _t1255 = self.parse_type() - item654 = _t1255 - xs652.append(item654) - cond653 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types655 = xs652 - self.consume_literal(")") - return types655 - - def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: - self.consume_literal("(") - self.consume_literal("value_types") xs656 = [] cond657 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) while cond657: - _t1256 = self.parse_type() - item658 = _t1256 + _t1263 = self.parse_type() + item658 = _t1263 xs656.append(item658) cond657 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) types659 = xs656 self.consume_literal(")") return types659 + def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: + self.consume_literal("(") + self.consume_literal("value_types") + xs660 = [] + cond661 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond661: + _t1264 = self.parse_type() + item662 = _t1264 + xs660.append(item662) + cond661 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types663 = xs660 + self.consume_literal(")") + return types663 + def parse_csv_data(self) -> logic_pb2.CSVData: self.consume_literal("(") self.consume_literal("csv_data") - _t1257 = self.parse_csvlocator() - csvlocator660 = _t1257 - _t1258 = self.parse_csv_config() - csv_config661 = _t1258 - _t1259 = self.parse_gnf_columns() - gnf_columns662 = _t1259 - _t1260 = self.parse_csv_asof() - csv_asof663 = _t1260 - self.consume_literal(")") - _t1261 = logic_pb2.CSVData(locator=csvlocator660, config=csv_config661, columns=gnf_columns662, asof=csv_asof663) - return _t1261 + _t1265 = self.parse_csvlocator() + csvlocator664 = _t1265 + _t1266 = self.parse_csv_config() + csv_config665 = _t1266 + _t1267 = self.parse_gnf_columns() + gnf_columns666 = _t1267 + _t1268 = self.parse_csv_asof() + csv_asof667 = _t1268 + self.consume_literal(")") + _t1269 = logic_pb2.CSVData(locator=csvlocator664, config=csv_config665, columns=gnf_columns666, asof=csv_asof667) + return _t1269 def parse_csvlocator(self) -> logic_pb2.CSVLocator: self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1263 = self.parse_csv_locator_paths() - _t1262 = _t1263 + _t1271 = self.parse_csv_locator_paths() + _t1270 = _t1271 else: - _t1262 = None - csv_locator_paths664 = _t1262 + _t1270 = None + csv_locator_paths668 = _t1270 if self.match_lookahead_literal("(", 0): - _t1265 = self.parse_csv_locator_inline_data() - _t1264 = _t1265 + _t1273 = self.parse_csv_locator_inline_data() + _t1272 = _t1273 else: - _t1264 = None - csv_locator_inline_data665 = _t1264 + _t1272 = None + csv_locator_inline_data669 = _t1272 self.consume_literal(")") - _t1266 = logic_pb2.CSVLocator(paths=(csv_locator_paths664 if csv_locator_paths664 is not None else []), inline_data=(csv_locator_inline_data665 if csv_locator_inline_data665 is not None else "").encode()) - return _t1266 + _t1274 = logic_pb2.CSVLocator(paths=(csv_locator_paths668 if csv_locator_paths668 is not None else []), inline_data=(csv_locator_inline_data669 if csv_locator_inline_data669 is not None else "").encode()) + return _t1274 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs666 = [] - cond667 = self.match_lookahead_terminal("STRING", 0) - while cond667: - item668 = self.consume_terminal("STRING") - xs666.append(item668) - cond667 = self.match_lookahead_terminal("STRING", 0) - strings669 = xs666 + xs670 = [] + cond671 = self.match_lookahead_terminal("STRING", 0) + while cond671: + item672 = self.consume_terminal("STRING") + xs670.append(item672) + cond671 = self.match_lookahead_terminal("STRING", 0) + strings673 = xs670 self.consume_literal(")") - return strings669 + return strings673 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - string670 = self.consume_terminal("STRING") + string674 = self.consume_terminal("STRING") self.consume_literal(")") - return string670 + return string674 def parse_csv_config(self) -> logic_pb2.CSVConfig: self.consume_literal("(") self.consume_literal("csv_config") - _t1267 = self.parse_config_dict() - config_dict671 = _t1267 + _t1275 = self.parse_config_dict() + config_dict675 = _t1275 self.consume_literal(")") - _t1268 = self.construct_csv_config(config_dict671) - return _t1268 + _t1276 = self.construct_csv_config(config_dict675) + return _t1276 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs672 = [] - cond673 = self.match_lookahead_literal("(", 0) - while cond673: - _t1269 = self.parse_gnf_column() - item674 = _t1269 - xs672.append(item674) - cond673 = self.match_lookahead_literal("(", 0) - gnf_columns675 = xs672 + xs676 = [] + cond677 = self.match_lookahead_literal("(", 0) + while cond677: + _t1277 = self.parse_gnf_column() + item678 = _t1277 + xs676.append(item678) + cond677 = self.match_lookahead_literal("(", 0) + gnf_columns679 = xs676 self.consume_literal(")") - return gnf_columns675 + return gnf_columns679 def parse_gnf_column(self) -> logic_pb2.GNFColumn: self.consume_literal("(") self.consume_literal("column") - _t1270 = self.parse_gnf_column_path() - gnf_column_path676 = _t1270 + _t1278 = self.parse_gnf_column_path() + gnf_column_path680 = _t1278 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t1272 = self.parse_relation_id() - _t1271 = _t1272 + _t1280 = self.parse_relation_id() + _t1279 = _t1280 else: - _t1271 = None - relation_id677 = _t1271 + _t1279 = None + relation_id681 = _t1279 self.consume_literal("[") - xs678 = [] - cond679 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - while cond679: - _t1273 = self.parse_type() - item680 = _t1273 - xs678.append(item680) - cond679 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) - types681 = xs678 + xs682 = [] + cond683 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + while cond683: + _t1281 = self.parse_type() + item684 = _t1281 + xs682.append(item684) + cond683 = ((((((((((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("INT", 0)) or self.match_lookahead_literal("INT128", 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("UNKNOWN", 0)) + types685 = xs682 self.consume_literal("]") self.consume_literal(")") - _t1274 = logic_pb2.GNFColumn(column_path=gnf_column_path676, target_id=relation_id677, types=types681) - return _t1274 + _t1282 = logic_pb2.GNFColumn(column_path=gnf_column_path680, target_id=relation_id681, types=types685) + return _t1282 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t1275 = 1 + _t1283 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1276 = 0 + _t1284 = 0 else: - _t1276 = -1 - _t1275 = _t1276 - prediction682 = _t1275 - if prediction682 == 1: + _t1284 = -1 + _t1283 = _t1284 + prediction686 = _t1283 + if prediction686 == 1: self.consume_literal("[") - xs684 = [] - cond685 = self.match_lookahead_terminal("STRING", 0) - while cond685: - item686 = self.consume_terminal("STRING") - xs684.append(item686) - cond685 = self.match_lookahead_terminal("STRING", 0) - strings687 = xs684 + xs688 = [] + cond689 = self.match_lookahead_terminal("STRING", 0) + while cond689: + item690 = self.consume_terminal("STRING") + xs688.append(item690) + cond689 = self.match_lookahead_terminal("STRING", 0) + strings691 = xs688 self.consume_literal("]") - _t1277 = strings687 + _t1285 = strings691 else: - if prediction682 == 0: - string683 = self.consume_terminal("STRING") - _t1278 = [string683] + if prediction686 == 0: + string687 = self.consume_terminal("STRING") + _t1286 = [string687] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1277 = _t1278 - return _t1277 + _t1285 = _t1286 + return _t1285 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string688 = self.consume_terminal("STRING") + string692 = self.consume_terminal("STRING") self.consume_literal(")") - return string688 + return string692 def parse_undefine(self) -> transactions_pb2.Undefine: self.consume_literal("(") self.consume_literal("undefine") - _t1279 = self.parse_fragment_id() - fragment_id689 = _t1279 + _t1287 = self.parse_fragment_id() + fragment_id693 = _t1287 self.consume_literal(")") - _t1280 = transactions_pb2.Undefine(fragment_id=fragment_id689) - return _t1280 + _t1288 = transactions_pb2.Undefine(fragment_id=fragment_id693) + return _t1288 def parse_context(self) -> transactions_pb2.Context: self.consume_literal("(") self.consume_literal("context") - xs690 = [] - cond691 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond691: - _t1281 = self.parse_relation_id() - item692 = _t1281 - xs690.append(item692) - cond691 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids693 = xs690 - self.consume_literal(")") - _t1282 = transactions_pb2.Context(relations=relation_ids693) - return _t1282 + xs694 = [] + cond695 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond695: + _t1289 = self.parse_relation_id() + item696 = _t1289 + xs694.append(item696) + cond695 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids697 = xs694 + self.consume_literal(")") + _t1290 = transactions_pb2.Context(relations=relation_ids697) + return _t1290 def parse_snapshot(self) -> transactions_pb2.Snapshot: self.consume_literal("(") self.consume_literal("snapshot") - _t1283 = self.parse_edb_path() - edb_path694 = _t1283 - _t1284 = self.parse_relation_id() - relation_id695 = _t1284 - self.consume_literal(")") - _t1285 = transactions_pb2.Snapshot(destination_path=edb_path694, source_relation=relation_id695) - return _t1285 + xs698 = [] + cond699 = self.match_lookahead_literal("[", 0) + while cond699: + _t1291 = self.parse_snapshot_mapping() + item700 = _t1291 + xs698.append(item700) + cond699 = self.match_lookahead_literal("[", 0) + snapshot_mappings701 = xs698 + self.consume_literal(")") + _t1292 = transactions_pb2.Snapshot(mappings=snapshot_mappings701) + return _t1292 + + def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: + _t1293 = self.parse_edb_path() + edb_path702 = _t1293 + _t1294 = self.parse_relation_id() + relation_id703 = _t1294 + _t1295 = transactions_pb2.SnapshotMapping(destination_path=edb_path702, source_relation=relation_id703) + return _t1295 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs696 = [] - cond697 = self.match_lookahead_literal("(", 0) - while cond697: - _t1286 = self.parse_read() - item698 = _t1286 - xs696.append(item698) - cond697 = self.match_lookahead_literal("(", 0) - reads699 = xs696 + xs704 = [] + cond705 = self.match_lookahead_literal("(", 0) + while cond705: + _t1296 = self.parse_read() + item706 = _t1296 + xs704.append(item706) + cond705 = self.match_lookahead_literal("(", 0) + reads707 = xs704 self.consume_literal(")") - return reads699 + return reads707 def parse_read(self) -> transactions_pb2.Read: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t1288 = 2 + _t1298 = 2 else: if self.match_lookahead_literal("output", 1): - _t1289 = 1 + _t1299 = 1 else: if self.match_lookahead_literal("export", 1): - _t1290 = 4 + _t1300 = 4 else: if self.match_lookahead_literal("demand", 1): - _t1291 = 0 + _t1301 = 0 else: if self.match_lookahead_literal("abort", 1): - _t1292 = 3 + _t1302 = 3 else: - _t1292 = -1 - _t1291 = _t1292 - _t1290 = _t1291 - _t1289 = _t1290 - _t1288 = _t1289 - _t1287 = _t1288 - else: - _t1287 = -1 - prediction700 = _t1287 - if prediction700 == 4: - _t1294 = self.parse_export() - export705 = _t1294 - _t1295 = transactions_pb2.Read(export=export705) - _t1293 = _t1295 - else: - if prediction700 == 3: - _t1297 = self.parse_abort() - abort704 = _t1297 - _t1298 = transactions_pb2.Read(abort=abort704) - _t1296 = _t1298 + _t1302 = -1 + _t1301 = _t1302 + _t1300 = _t1301 + _t1299 = _t1300 + _t1298 = _t1299 + _t1297 = _t1298 + else: + _t1297 = -1 + prediction708 = _t1297 + if prediction708 == 4: + _t1304 = self.parse_export() + export713 = _t1304 + _t1305 = transactions_pb2.Read(export=export713) + _t1303 = _t1305 + else: + if prediction708 == 3: + _t1307 = self.parse_abort() + abort712 = _t1307 + _t1308 = transactions_pb2.Read(abort=abort712) + _t1306 = _t1308 else: - if prediction700 == 2: - _t1300 = self.parse_what_if() - what_if703 = _t1300 - _t1301 = transactions_pb2.Read(what_if=what_if703) - _t1299 = _t1301 + if prediction708 == 2: + _t1310 = self.parse_what_if() + what_if711 = _t1310 + _t1311 = transactions_pb2.Read(what_if=what_if711) + _t1309 = _t1311 else: - if prediction700 == 1: - _t1303 = self.parse_output() - output702 = _t1303 - _t1304 = transactions_pb2.Read(output=output702) - _t1302 = _t1304 + if prediction708 == 1: + _t1313 = self.parse_output() + output710 = _t1313 + _t1314 = transactions_pb2.Read(output=output710) + _t1312 = _t1314 else: - if prediction700 == 0: - _t1306 = self.parse_demand() - demand701 = _t1306 - _t1307 = transactions_pb2.Read(demand=demand701) - _t1305 = _t1307 + if prediction708 == 0: + _t1316 = self.parse_demand() + demand709 = _t1316 + _t1317 = transactions_pb2.Read(demand=demand709) + _t1315 = _t1317 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1302 = _t1305 - _t1299 = _t1302 - _t1296 = _t1299 - _t1293 = _t1296 - return _t1293 + _t1312 = _t1315 + _t1309 = _t1312 + _t1306 = _t1309 + _t1303 = _t1306 + return _t1303 def parse_demand(self) -> transactions_pb2.Demand: self.consume_literal("(") self.consume_literal("demand") - _t1308 = self.parse_relation_id() - relation_id706 = _t1308 + _t1318 = self.parse_relation_id() + relation_id714 = _t1318 self.consume_literal(")") - _t1309 = transactions_pb2.Demand(relation_id=relation_id706) - return _t1309 + _t1319 = transactions_pb2.Demand(relation_id=relation_id714) + return _t1319 def parse_output(self) -> transactions_pb2.Output: self.consume_literal("(") self.consume_literal("output") - _t1310 = self.parse_name() - name707 = _t1310 - _t1311 = self.parse_relation_id() - relation_id708 = _t1311 + _t1320 = self.parse_name() + name715 = _t1320 + _t1321 = self.parse_relation_id() + relation_id716 = _t1321 self.consume_literal(")") - _t1312 = transactions_pb2.Output(name=name707, relation_id=relation_id708) - return _t1312 + _t1322 = transactions_pb2.Output(name=name715, relation_id=relation_id716) + return _t1322 def parse_what_if(self) -> transactions_pb2.WhatIf: self.consume_literal("(") self.consume_literal("what_if") - _t1313 = self.parse_name() - name709 = _t1313 - _t1314 = self.parse_epoch() - epoch710 = _t1314 + _t1323 = self.parse_name() + name717 = _t1323 + _t1324 = self.parse_epoch() + epoch718 = _t1324 self.consume_literal(")") - _t1315 = transactions_pb2.WhatIf(branch=name709, epoch=epoch710) - return _t1315 + _t1325 = transactions_pb2.WhatIf(branch=name717, epoch=epoch718) + return _t1325 def parse_abort(self) -> transactions_pb2.Abort: self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t1317 = self.parse_name() - _t1316 = _t1317 + _t1327 = self.parse_name() + _t1326 = _t1327 else: - _t1316 = None - name711 = _t1316 - _t1318 = self.parse_relation_id() - relation_id712 = _t1318 + _t1326 = None + name719 = _t1326 + _t1328 = self.parse_relation_id() + relation_id720 = _t1328 self.consume_literal(")") - _t1319 = transactions_pb2.Abort(name=(name711 if name711 is not None else "abort"), relation_id=relation_id712) - return _t1319 + _t1329 = transactions_pb2.Abort(name=(name719 if name719 is not None else "abort"), relation_id=relation_id720) + return _t1329 def parse_export(self) -> transactions_pb2.Export: self.consume_literal("(") self.consume_literal("export") - _t1320 = self.parse_export_csv_config() - export_csv_config713 = _t1320 + _t1330 = self.parse_export_csv_config() + export_csv_config721 = _t1330 self.consume_literal(")") - _t1321 = transactions_pb2.Export(csv_config=export_csv_config713) - return _t1321 + _t1331 = transactions_pb2.Export(csv_config=export_csv_config721) + return _t1331 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: self.consume_literal("(") self.consume_literal("export_csv_config") - _t1322 = self.parse_export_csv_path() - export_csv_path714 = _t1322 - _t1323 = self.parse_export_csv_columns() - export_csv_columns715 = _t1323 - _t1324 = self.parse_config_dict() - config_dict716 = _t1324 - self.consume_literal(")") - _t1325 = self.export_csv_config(export_csv_path714, export_csv_columns715, config_dict716) - return _t1325 + _t1332 = self.parse_export_csv_path() + export_csv_path722 = _t1332 + _t1333 = self.parse_export_csv_columns() + export_csv_columns723 = _t1333 + _t1334 = self.parse_config_dict() + config_dict724 = _t1334 + self.consume_literal(")") + _t1335 = self.export_csv_config(export_csv_path722, export_csv_columns723, config_dict724) + return _t1335 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string717 = self.consume_terminal("STRING") + string725 = self.consume_terminal("STRING") self.consume_literal(")") - return string717 + return string725 def parse_export_csv_columns(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs718 = [] - cond719 = self.match_lookahead_literal("(", 0) - while cond719: - _t1326 = self.parse_export_csv_column() - item720 = _t1326 - xs718.append(item720) - cond719 = self.match_lookahead_literal("(", 0) - export_csv_columns721 = xs718 + xs726 = [] + cond727 = self.match_lookahead_literal("(", 0) + while cond727: + _t1336 = self.parse_export_csv_column() + item728 = _t1336 + xs726.append(item728) + cond727 = self.match_lookahead_literal("(", 0) + export_csv_columns729 = xs726 self.consume_literal(")") - return export_csv_columns721 + return export_csv_columns729 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: self.consume_literal("(") self.consume_literal("column") - string722 = self.consume_terminal("STRING") - _t1327 = self.parse_relation_id() - relation_id723 = _t1327 + string730 = self.consume_terminal("STRING") + _t1337 = self.parse_relation_id() + relation_id731 = _t1337 self.consume_literal(")") - _t1328 = transactions_pb2.ExportCSVColumn(column_name=string722, column_data=relation_id723) - return _t1328 + _t1338 = transactions_pb2.ExportCSVColumn(column_name=string730, column_data=relation_id731) + return _t1338 def parse(input_str: str) -> Any: diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index 1a00f0c1..7256e648 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -193,131 +193,131 @@ def write_debug_info(self) -> None: # --- Helper functions --- def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1677 = logic_pb2.Value(int_value=int(v)) - return _t1677 + _t1689 = logic_pb2.Value(int_value=int(v)) + return _t1689 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1678 = logic_pb2.Value(int_value=v) - return _t1678 + _t1690 = logic_pb2.Value(int_value=v) + return _t1690 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1679 = logic_pb2.Value(float_value=v) - return _t1679 + _t1691 = logic_pb2.Value(float_value=v) + return _t1691 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1680 = logic_pb2.Value(string_value=v) - return _t1680 + _t1692 = logic_pb2.Value(string_value=v) + return _t1692 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1681 = logic_pb2.Value(boolean_value=v) - return _t1681 + _t1693 = logic_pb2.Value(boolean_value=v) + return _t1693 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1682 = logic_pb2.Value(uint128_value=v) - return _t1682 + _t1694 = logic_pb2.Value(uint128_value=v) + return _t1694 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: - _t1683 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1683,)) + _t1695 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1695,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1684 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1684,)) + _t1696 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1696,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1685 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1685,)) - _t1686 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1686,)) + _t1697 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1697,)) + _t1698 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1698,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1687 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1687,)) - _t1688 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1688,)) + _t1699 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1699,)) + _t1700 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1700,)) if msg.new_line != "": - _t1689 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1689,)) - _t1690 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1690,)) - _t1691 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1691,)) - _t1692 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1692,)) + _t1701 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1701,)) + _t1702 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1702,)) + _t1703 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1703,)) + _t1704 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1704,)) if msg.comment != "": - _t1693 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1693,)) + _t1705 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1705,)) for missing_string in msg.missing_strings: - _t1694 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1694,)) - _t1695 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1695,)) - _t1696 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1696,)) - _t1697 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1697,)) + _t1706 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1706,)) + _t1707 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1707,)) + _t1708 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1708,)) + _t1709 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1709,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1698 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1698,)) - _t1699 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1699,)) - _t1700 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1700,)) - _t1701 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1701,)) + _t1710 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1710,)) + _t1711 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1711,)) + _t1712 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1712,)) + _t1713 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1713,)) 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 - _t1702 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1702,)) + _t1714 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1714,)) 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 - _t1703 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1703,)) - _t1704 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1704,)) - _t1705 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1705,)) + _t1715 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1715,)) + _t1716 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1716,)) + _t1717 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1717,)) 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 - _t1706 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1706,)) + _t1718 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1718,)) if msg.compression is not None: assert msg.compression is not None - _t1707 = self._make_value_string(msg.compression) - result.append(("compression", _t1707,)) + _t1719 = self._make_value_string(msg.compression) + result.append(("compression", _t1719,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1708 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1708,)) + _t1720 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1720,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1709 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1709,)) + _t1721 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1721,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1710 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1710,)) + _t1722 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1722,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1711 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1711,)) + _t1723 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1723,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1712 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1712,)) + _t1724 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1724,)) return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -330,7 +330,7 @@ def deconstruct_relation_id_uint128(self, msg: logic_pb2.RelationId) -> Optional if name is None: return self.relation_id_to_uint128(msg) else: - _t1713 = None + _t1725 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -345,1688 +345,1659 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat646 = self._try_flat(msg, self.pretty_transaction) - if flat646 is not None: - assert flat646 is not None - self.write(flat646) + flat651 = self._try_flat(msg, self.pretty_transaction) + if flat651 is not None: + assert flat651 is not None + self.write(flat651) return None else: - def _t1274(_dollar_dollar): + def _t1284(_dollar_dollar): if _dollar_dollar.HasField("configure"): - _t1275 = _dollar_dollar.configure + _t1285 = _dollar_dollar.configure else: - _t1275 = None + _t1285 = None if _dollar_dollar.HasField("sync"): - _t1276 = _dollar_dollar.sync + _t1286 = _dollar_dollar.sync else: - _t1276 = None - return (_t1275, _t1276, _dollar_dollar.epochs,) - _t1277 = _t1274(msg) - fields637 = _t1277 - assert fields637 is not None - unwrapped_fields638 = fields637 + _t1286 = None + return (_t1285, _t1286, _dollar_dollar.epochs,) + _t1287 = _t1284(msg) + fields642 = _t1287 + assert fields642 is not None + unwrapped_fields643 = fields642 self.write("(") self.write("transaction") self.indent_sexp() - field639 = unwrapped_fields638[0] - if field639 is not None: + field644 = unwrapped_fields643[0] + if field644 is not None: self.newline() - assert field639 is not None - opt_val640 = field639 - self.pretty_configure(opt_val640) - field641 = unwrapped_fields638[1] - if field641 is not None: + assert field644 is not None + opt_val645 = field644 + self.pretty_configure(opt_val645) + field646 = unwrapped_fields643[1] + if field646 is not None: self.newline() - assert field641 is not None - opt_val642 = field641 - self.pretty_sync(opt_val642) - field643 = unwrapped_fields638[2] - if not len(field643) == 0: + assert field646 is not None + opt_val647 = field646 + self.pretty_sync(opt_val647) + field648 = unwrapped_fields643[2] + if not len(field648) == 0: self.newline() - for i645, elem644 in enumerate(field643): - if (i645 > 0): + for i650, elem649 in enumerate(field648): + if (i650 > 0): self.newline() - self.pretty_epoch(elem644) + self.pretty_epoch(elem649) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat649 = self._try_flat(msg, self.pretty_configure) - if flat649 is not None: - assert flat649 is not None - self.write(flat649) + flat654 = self._try_flat(msg, self.pretty_configure) + if flat654 is not None: + assert flat654 is not None + self.write(flat654) return None else: - def _t1278(_dollar_dollar): - _t1279 = self.deconstruct_configure(_dollar_dollar) - return _t1279 - _t1280 = _t1278(msg) - fields647 = _t1280 - assert fields647 is not None - unwrapped_fields648 = fields647 + def _t1288(_dollar_dollar): + _t1289 = self.deconstruct_configure(_dollar_dollar) + return _t1289 + _t1290 = _t1288(msg) + fields652 = _t1290 + assert fields652 is not None + unwrapped_fields653 = fields652 self.write("(") self.write("configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields648) + self.pretty_config_dict(unwrapped_fields653) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat653 = self._try_flat(msg, self.pretty_config_dict) - if flat653 is not None: - assert flat653 is not None - self.write(flat653) + flat658 = self._try_flat(msg, self.pretty_config_dict) + if flat658 is not None: + assert flat658 is not None + self.write(flat658) return None else: - fields650 = msg + fields655 = msg self.write("{") self.indent() - if not len(fields650) == 0: + if not len(fields655) == 0: self.newline() - for i652, elem651 in enumerate(fields650): - if (i652 > 0): + for i657, elem656 in enumerate(fields655): + if (i657 > 0): self.newline() - self.pretty_config_key_value(elem651) + self.pretty_config_key_value(elem656) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat658 = self._try_flat(msg, self.pretty_config_key_value) - if flat658 is not None: - assert flat658 is not None - self.write(flat658) + flat663 = self._try_flat(msg, self.pretty_config_key_value) + if flat663 is not None: + assert flat663 is not None + self.write(flat663) return None else: - def _t1281(_dollar_dollar): + def _t1291(_dollar_dollar): return (_dollar_dollar[0], _dollar_dollar[1],) - _t1282 = _t1281(msg) - fields654 = _t1282 - assert fields654 is not None - unwrapped_fields655 = fields654 + _t1292 = _t1291(msg) + fields659 = _t1292 + assert fields659 is not None + unwrapped_fields660 = fields659 self.write(":") - field656 = unwrapped_fields655[0] - self.write(field656) + field661 = unwrapped_fields660[0] + self.write(field661) self.write(" ") - field657 = unwrapped_fields655[1] - self.pretty_value(field657) + field662 = unwrapped_fields660[1] + self.pretty_value(field662) def pretty_value(self, msg: logic_pb2.Value): - flat678 = self._try_flat(msg, self.pretty_value) - if flat678 is not None: - assert flat678 is not None - self.write(flat678) + flat683 = self._try_flat(msg, self.pretty_value) + if flat683 is not None: + assert flat683 is not None + self.write(flat683) return None else: - def _t1283(_dollar_dollar): + def _t1293(_dollar_dollar): if _dollar_dollar.HasField("date_value"): - _t1284 = _dollar_dollar.date_value + _t1294 = _dollar_dollar.date_value else: - _t1284 = None - return _t1284 - _t1285 = _t1283(msg) - deconstruct_result676 = _t1285 - if deconstruct_result676 is not None: - assert deconstruct_result676 is not None - unwrapped677 = deconstruct_result676 - self.pretty_date(unwrapped677) + _t1294 = None + return _t1294 + _t1295 = _t1293(msg) + deconstruct_result681 = _t1295 + if deconstruct_result681 is not None: + assert deconstruct_result681 is not None + unwrapped682 = deconstruct_result681 + self.pretty_date(unwrapped682) else: - def _t1286(_dollar_dollar): + def _t1296(_dollar_dollar): if _dollar_dollar.HasField("datetime_value"): - _t1287 = _dollar_dollar.datetime_value + _t1297 = _dollar_dollar.datetime_value else: - _t1287 = None - return _t1287 - _t1288 = _t1286(msg) - deconstruct_result674 = _t1288 - if deconstruct_result674 is not None: - assert deconstruct_result674 is not None - unwrapped675 = deconstruct_result674 - self.pretty_datetime(unwrapped675) + _t1297 = None + return _t1297 + _t1298 = _t1296(msg) + deconstruct_result679 = _t1298 + if deconstruct_result679 is not None: + assert deconstruct_result679 is not None + unwrapped680 = deconstruct_result679 + self.pretty_datetime(unwrapped680) else: - def _t1289(_dollar_dollar): + def _t1299(_dollar_dollar): if _dollar_dollar.HasField("string_value"): - _t1290 = _dollar_dollar.string_value + _t1300 = _dollar_dollar.string_value else: - _t1290 = None - return _t1290 - _t1291 = _t1289(msg) - deconstruct_result672 = _t1291 - if deconstruct_result672 is not None: - assert deconstruct_result672 is not None - unwrapped673 = deconstruct_result672 - self.write(self.format_string_value(unwrapped673)) + _t1300 = None + return _t1300 + _t1301 = _t1299(msg) + deconstruct_result677 = _t1301 + if deconstruct_result677 is not None: + assert deconstruct_result677 is not None + unwrapped678 = deconstruct_result677 + self.write(self.format_string_value(unwrapped678)) else: - def _t1292(_dollar_dollar): + def _t1302(_dollar_dollar): if _dollar_dollar.HasField("int_value"): - _t1293 = _dollar_dollar.int_value + _t1303 = _dollar_dollar.int_value else: - _t1293 = None - return _t1293 - _t1294 = _t1292(msg) - deconstruct_result670 = _t1294 - if deconstruct_result670 is not None: - assert deconstruct_result670 is not None - unwrapped671 = deconstruct_result670 - self.write(str(unwrapped671)) + _t1303 = None + return _t1303 + _t1304 = _t1302(msg) + deconstruct_result675 = _t1304 + if deconstruct_result675 is not None: + assert deconstruct_result675 is not None + unwrapped676 = deconstruct_result675 + self.write(str(unwrapped676)) else: - def _t1295(_dollar_dollar): + def _t1305(_dollar_dollar): if _dollar_dollar.HasField("float_value"): - _t1296 = _dollar_dollar.float_value + _t1306 = _dollar_dollar.float_value else: - _t1296 = None - return _t1296 - _t1297 = _t1295(msg) - deconstruct_result668 = _t1297 - if deconstruct_result668 is not None: - assert deconstruct_result668 is not None - unwrapped669 = deconstruct_result668 - self.write(str(unwrapped669)) + _t1306 = None + return _t1306 + _t1307 = _t1305(msg) + deconstruct_result673 = _t1307 + if deconstruct_result673 is not None: + assert deconstruct_result673 is not None + unwrapped674 = deconstruct_result673 + self.write(str(unwrapped674)) else: - def _t1298(_dollar_dollar): + def _t1308(_dollar_dollar): if _dollar_dollar.HasField("uint128_value"): - _t1299 = _dollar_dollar.uint128_value + _t1309 = _dollar_dollar.uint128_value else: - _t1299 = None - return _t1299 - _t1300 = _t1298(msg) - deconstruct_result666 = _t1300 - if deconstruct_result666 is not None: - assert deconstruct_result666 is not None - unwrapped667 = deconstruct_result666 - self.write(self.format_uint128(unwrapped667)) + _t1309 = None + return _t1309 + _t1310 = _t1308(msg) + deconstruct_result671 = _t1310 + if deconstruct_result671 is not None: + assert deconstruct_result671 is not None + unwrapped672 = deconstruct_result671 + self.write(self.format_uint128(unwrapped672)) else: - def _t1301(_dollar_dollar): + def _t1311(_dollar_dollar): if _dollar_dollar.HasField("int128_value"): - _t1302 = _dollar_dollar.int128_value + _t1312 = _dollar_dollar.int128_value else: - _t1302 = None - return _t1302 - _t1303 = _t1301(msg) - deconstruct_result664 = _t1303 - if deconstruct_result664 is not None: - assert deconstruct_result664 is not None - unwrapped665 = deconstruct_result664 - self.write(self.format_int128(unwrapped665)) + _t1312 = None + return _t1312 + _t1313 = _t1311(msg) + deconstruct_result669 = _t1313 + if deconstruct_result669 is not None: + assert deconstruct_result669 is not None + unwrapped670 = deconstruct_result669 + self.write(self.format_int128(unwrapped670)) else: - def _t1304(_dollar_dollar): + def _t1314(_dollar_dollar): if _dollar_dollar.HasField("decimal_value"): - _t1305 = _dollar_dollar.decimal_value + _t1315 = _dollar_dollar.decimal_value else: - _t1305 = None - return _t1305 - _t1306 = _t1304(msg) - deconstruct_result662 = _t1306 - if deconstruct_result662 is not None: - assert deconstruct_result662 is not None - unwrapped663 = deconstruct_result662 - self.write(self.format_decimal(unwrapped663)) + _t1315 = None + return _t1315 + _t1316 = _t1314(msg) + deconstruct_result667 = _t1316 + if deconstruct_result667 is not None: + assert deconstruct_result667 is not None + unwrapped668 = deconstruct_result667 + self.write(self.format_decimal(unwrapped668)) else: - def _t1307(_dollar_dollar): + def _t1317(_dollar_dollar): if _dollar_dollar.HasField("boolean_value"): - _t1308 = _dollar_dollar.boolean_value + _t1318 = _dollar_dollar.boolean_value else: - _t1308 = None - return _t1308 - _t1309 = _t1307(msg) - deconstruct_result660 = _t1309 - if deconstruct_result660 is not None: - assert deconstruct_result660 is not None - unwrapped661 = deconstruct_result660 - self.pretty_boolean_value(unwrapped661) + _t1318 = None + return _t1318 + _t1319 = _t1317(msg) + deconstruct_result665 = _t1319 + if deconstruct_result665 is not None: + assert deconstruct_result665 is not None + unwrapped666 = deconstruct_result665 + self.pretty_boolean_value(unwrapped666) else: - fields659 = msg + fields664 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat684 = self._try_flat(msg, self.pretty_date) - if flat684 is not None: - assert flat684 is not None - self.write(flat684) + flat689 = self._try_flat(msg, self.pretty_date) + if flat689 is not None: + assert flat689 is not None + self.write(flat689) return None else: - def _t1310(_dollar_dollar): + def _t1320(_dollar_dollar): return (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - _t1311 = _t1310(msg) - fields679 = _t1311 - assert fields679 is not None - unwrapped_fields680 = fields679 + _t1321 = _t1320(msg) + fields684 = _t1321 + assert fields684 is not None + unwrapped_fields685 = fields684 self.write("(") self.write("date") self.indent_sexp() self.newline() - field681 = unwrapped_fields680[0] - self.write(str(field681)) + field686 = unwrapped_fields685[0] + self.write(str(field686)) self.newline() - field682 = unwrapped_fields680[1] - self.write(str(field682)) + field687 = unwrapped_fields685[1] + self.write(str(field687)) self.newline() - field683 = unwrapped_fields680[2] - self.write(str(field683)) + field688 = unwrapped_fields685[2] + self.write(str(field688)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat695 = self._try_flat(msg, self.pretty_datetime) - if flat695 is not None: - assert flat695 is not None - self.write(flat695) + flat700 = self._try_flat(msg, self.pretty_datetime) + if flat700 is not None: + assert flat700 is not None + self.write(flat700) return None else: - def _t1312(_dollar_dollar): + def _t1322(_dollar_dollar): return (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),) - _t1313 = _t1312(msg) - fields685 = _t1313 - assert fields685 is not None - unwrapped_fields686 = fields685 + _t1323 = _t1322(msg) + fields690 = _t1323 + assert fields690 is not None + unwrapped_fields691 = fields690 self.write("(") self.write("datetime") self.indent_sexp() self.newline() - field687 = unwrapped_fields686[0] - self.write(str(field687)) + field692 = unwrapped_fields691[0] + self.write(str(field692)) self.newline() - field688 = unwrapped_fields686[1] - self.write(str(field688)) + field693 = unwrapped_fields691[1] + self.write(str(field693)) self.newline() - field689 = unwrapped_fields686[2] - self.write(str(field689)) + field694 = unwrapped_fields691[2] + self.write(str(field694)) self.newline() - field690 = unwrapped_fields686[3] - self.write(str(field690)) + field695 = unwrapped_fields691[3] + self.write(str(field695)) self.newline() - field691 = unwrapped_fields686[4] - self.write(str(field691)) + field696 = unwrapped_fields691[4] + self.write(str(field696)) self.newline() - field692 = unwrapped_fields686[5] - self.write(str(field692)) - field693 = unwrapped_fields686[6] - if field693 is not None: + field697 = unwrapped_fields691[5] + self.write(str(field697)) + field698 = unwrapped_fields691[6] + if field698 is not None: self.newline() - assert field693 is not None - opt_val694 = field693 - self.write(str(opt_val694)) + assert field698 is not None + opt_val699 = field698 + self.write(str(opt_val699)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): - def _t1314(_dollar_dollar): + def _t1324(_dollar_dollar): if _dollar_dollar: - _t1315 = () + _t1325 = () else: - _t1315 = None - return _t1315 - _t1316 = _t1314(msg) - deconstruct_result698 = _t1316 - if deconstruct_result698 is not None: - assert deconstruct_result698 is not None - unwrapped699 = deconstruct_result698 + _t1325 = None + return _t1325 + _t1326 = _t1324(msg) + deconstruct_result703 = _t1326 + if deconstruct_result703 is not None: + assert deconstruct_result703 is not None + unwrapped704 = deconstruct_result703 self.write("true") else: - def _t1317(_dollar_dollar): + def _t1327(_dollar_dollar): if not _dollar_dollar: - _t1318 = () + _t1328 = () else: - _t1318 = None - return _t1318 - _t1319 = _t1317(msg) - deconstruct_result696 = _t1319 - if deconstruct_result696 is not None: - assert deconstruct_result696 is not None - unwrapped697 = deconstruct_result696 + _t1328 = None + return _t1328 + _t1329 = _t1327(msg) + deconstruct_result701 = _t1329 + if deconstruct_result701 is not None: + assert deconstruct_result701 is not None + unwrapped702 = deconstruct_result701 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat704 = self._try_flat(msg, self.pretty_sync) - if flat704 is not None: - assert flat704 is not None - self.write(flat704) + flat709 = self._try_flat(msg, self.pretty_sync) + if flat709 is not None: + assert flat709 is not None + self.write(flat709) return None else: - def _t1320(_dollar_dollar): + def _t1330(_dollar_dollar): return _dollar_dollar.fragments - _t1321 = _t1320(msg) - fields700 = _t1321 - assert fields700 is not None - unwrapped_fields701 = fields700 + _t1331 = _t1330(msg) + fields705 = _t1331 + assert fields705 is not None + unwrapped_fields706 = fields705 self.write("(") self.write("sync") self.indent_sexp() - if not len(unwrapped_fields701) == 0: + if not len(unwrapped_fields706) == 0: self.newline() - for i703, elem702 in enumerate(unwrapped_fields701): - if (i703 > 0): + for i708, elem707 in enumerate(unwrapped_fields706): + if (i708 > 0): self.newline() - self.pretty_fragment_id(elem702) + self.pretty_fragment_id(elem707) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat707 = self._try_flat(msg, self.pretty_fragment_id) - if flat707 is not None: - assert flat707 is not None - self.write(flat707) + flat712 = self._try_flat(msg, self.pretty_fragment_id) + if flat712 is not None: + assert flat712 is not None + self.write(flat712) return None else: - def _t1322(_dollar_dollar): + def _t1332(_dollar_dollar): return self.fragment_id_to_string(_dollar_dollar) - _t1323 = _t1322(msg) - fields705 = _t1323 - assert fields705 is not None - unwrapped_fields706 = fields705 + _t1333 = _t1332(msg) + fields710 = _t1333 + assert fields710 is not None + unwrapped_fields711 = fields710 self.write(":") - self.write(unwrapped_fields706) + self.write(unwrapped_fields711) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat714 = self._try_flat(msg, self.pretty_epoch) - if flat714 is not None: - assert flat714 is not None - self.write(flat714) + flat719 = self._try_flat(msg, self.pretty_epoch) + if flat719 is not None: + assert flat719 is not None + self.write(flat719) return None else: - def _t1324(_dollar_dollar): + def _t1334(_dollar_dollar): if not len(_dollar_dollar.writes) == 0: - _t1325 = _dollar_dollar.writes + _t1335 = _dollar_dollar.writes else: - _t1325 = None + _t1335 = None if not len(_dollar_dollar.reads) == 0: - _t1326 = _dollar_dollar.reads + _t1336 = _dollar_dollar.reads else: - _t1326 = None - return (_t1325, _t1326,) - _t1327 = _t1324(msg) - fields708 = _t1327 - assert fields708 is not None - unwrapped_fields709 = fields708 + _t1336 = None + return (_t1335, _t1336,) + _t1337 = _t1334(msg) + fields713 = _t1337 + assert fields713 is not None + unwrapped_fields714 = fields713 self.write("(") self.write("epoch") self.indent_sexp() - field710 = unwrapped_fields709[0] - if field710 is not None: + field715 = unwrapped_fields714[0] + if field715 is not None: self.newline() - assert field710 is not None - opt_val711 = field710 - self.pretty_epoch_writes(opt_val711) - field712 = unwrapped_fields709[1] - if field712 is not None: + assert field715 is not None + opt_val716 = field715 + self.pretty_epoch_writes(opt_val716) + field717 = unwrapped_fields714[1] + if field717 is not None: self.newline() - assert field712 is not None - opt_val713 = field712 - self.pretty_epoch_reads(opt_val713) + assert field717 is not None + opt_val718 = field717 + self.pretty_epoch_reads(opt_val718) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat718 = self._try_flat(msg, self.pretty_epoch_writes) - if flat718 is not None: - assert flat718 is not None - self.write(flat718) + flat723 = self._try_flat(msg, self.pretty_epoch_writes) + if flat723 is not None: + assert flat723 is not None + self.write(flat723) return None else: - fields715 = msg + fields720 = msg self.write("(") self.write("writes") self.indent_sexp() - if not len(fields715) == 0: + if not len(fields720) == 0: self.newline() - for i717, elem716 in enumerate(fields715): - if (i717 > 0): + for i722, elem721 in enumerate(fields720): + if (i722 > 0): self.newline() - self.pretty_write(elem716) + self.pretty_write(elem721) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat727 = self._try_flat(msg, self.pretty_write) - if flat727 is not None: - assert flat727 is not None - self.write(flat727) + flat732 = self._try_flat(msg, self.pretty_write) + if flat732 is not None: + assert flat732 is not None + self.write(flat732) return None else: - def _t1328(_dollar_dollar): + def _t1338(_dollar_dollar): if _dollar_dollar.HasField("define"): - _t1329 = _dollar_dollar.define + _t1339 = _dollar_dollar.define else: - _t1329 = None - return _t1329 - _t1330 = _t1328(msg) - deconstruct_result725 = _t1330 - if deconstruct_result725 is not None: - assert deconstruct_result725 is not None - unwrapped726 = deconstruct_result725 - self.pretty_define(unwrapped726) + _t1339 = None + return _t1339 + _t1340 = _t1338(msg) + deconstruct_result730 = _t1340 + if deconstruct_result730 is not None: + assert deconstruct_result730 is not None + unwrapped731 = deconstruct_result730 + self.pretty_define(unwrapped731) else: - def _t1331(_dollar_dollar): + def _t1341(_dollar_dollar): if _dollar_dollar.HasField("undefine"): - _t1332 = _dollar_dollar.undefine + _t1342 = _dollar_dollar.undefine else: - _t1332 = None - return _t1332 - _t1333 = _t1331(msg) - deconstruct_result723 = _t1333 - if deconstruct_result723 is not None: - assert deconstruct_result723 is not None - unwrapped724 = deconstruct_result723 - self.pretty_undefine(unwrapped724) + _t1342 = None + return _t1342 + _t1343 = _t1341(msg) + deconstruct_result728 = _t1343 + if deconstruct_result728 is not None: + assert deconstruct_result728 is not None + unwrapped729 = deconstruct_result728 + self.pretty_undefine(unwrapped729) else: - def _t1334(_dollar_dollar): + def _t1344(_dollar_dollar): if _dollar_dollar.HasField("context"): - _t1335 = _dollar_dollar.context + _t1345 = _dollar_dollar.context else: - _t1335 = None - return _t1335 - _t1336 = _t1334(msg) - deconstruct_result721 = _t1336 - if deconstruct_result721 is not None: - assert deconstruct_result721 is not None - unwrapped722 = deconstruct_result721 - self.pretty_context(unwrapped722) + _t1345 = None + return _t1345 + _t1346 = _t1344(msg) + deconstruct_result726 = _t1346 + if deconstruct_result726 is not None: + assert deconstruct_result726 is not None + unwrapped727 = deconstruct_result726 + self.pretty_context(unwrapped727) else: - def _t1337(_dollar_dollar): + def _t1347(_dollar_dollar): if _dollar_dollar.HasField("snapshot"): - _t1338 = _dollar_dollar.snapshot + _t1348 = _dollar_dollar.snapshot else: - _t1338 = None - return _t1338 - _t1339 = _t1337(msg) - deconstruct_result719 = _t1339 - if deconstruct_result719 is not None: - assert deconstruct_result719 is not None - unwrapped720 = deconstruct_result719 - self.pretty_snapshot(unwrapped720) + _t1348 = None + return _t1348 + _t1349 = _t1347(msg) + deconstruct_result724 = _t1349 + if deconstruct_result724 is not None: + assert deconstruct_result724 is not None + unwrapped725 = deconstruct_result724 + self.pretty_snapshot(unwrapped725) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat730 = self._try_flat(msg, self.pretty_define) - if flat730 is not None: - assert flat730 is not None - self.write(flat730) + flat735 = self._try_flat(msg, self.pretty_define) + if flat735 is not None: + assert flat735 is not None + self.write(flat735) return None else: - def _t1340(_dollar_dollar): + def _t1350(_dollar_dollar): return _dollar_dollar.fragment - _t1341 = _t1340(msg) - fields728 = _t1341 - assert fields728 is not None - unwrapped_fields729 = fields728 + _t1351 = _t1350(msg) + fields733 = _t1351 + assert fields733 is not None + unwrapped_fields734 = fields733 self.write("(") self.write("define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields729) + self.pretty_fragment(unwrapped_fields734) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat737 = self._try_flat(msg, self.pretty_fragment) - if flat737 is not None: - assert flat737 is not None - self.write(flat737) + flat742 = self._try_flat(msg, self.pretty_fragment) + if flat742 is not None: + assert flat742 is not None + self.write(flat742) return None else: - def _t1342(_dollar_dollar): + def _t1352(_dollar_dollar): self.start_pretty_fragment(_dollar_dollar) return (_dollar_dollar.id, _dollar_dollar.declarations,) - _t1343 = _t1342(msg) - fields731 = _t1343 - assert fields731 is not None - unwrapped_fields732 = fields731 + _t1353 = _t1352(msg) + fields736 = _t1353 + assert fields736 is not None + unwrapped_fields737 = fields736 self.write("(") self.write("fragment") self.indent_sexp() self.newline() - field733 = unwrapped_fields732[0] - self.pretty_new_fragment_id(field733) - field734 = unwrapped_fields732[1] - if not len(field734) == 0: + field738 = unwrapped_fields737[0] + self.pretty_new_fragment_id(field738) + field739 = unwrapped_fields737[1] + if not len(field739) == 0: self.newline() - for i736, elem735 in enumerate(field734): - if (i736 > 0): + for i741, elem740 in enumerate(field739): + if (i741 > 0): self.newline() - self.pretty_declaration(elem735) + self.pretty_declaration(elem740) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat739 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat739 is not None: - assert flat739 is not None - self.write(flat739) + flat744 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat744 is not None: + assert flat744 is not None + self.write(flat744) return None else: - fields738 = msg - self.pretty_fragment_id(fields738) + fields743 = msg + self.pretty_fragment_id(fields743) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat748 = self._try_flat(msg, self.pretty_declaration) - if flat748 is not None: - assert flat748 is not None - self.write(flat748) + flat753 = self._try_flat(msg, self.pretty_declaration) + if flat753 is not None: + assert flat753 is not None + self.write(flat753) return None else: - def _t1344(_dollar_dollar): + def _t1354(_dollar_dollar): if _dollar_dollar.HasField("def"): - _t1345 = getattr(_dollar_dollar, 'def') + _t1355 = getattr(_dollar_dollar, 'def') else: - _t1345 = None - return _t1345 - _t1346 = _t1344(msg) - deconstruct_result746 = _t1346 - if deconstruct_result746 is not None: - assert deconstruct_result746 is not None - unwrapped747 = deconstruct_result746 - self.pretty_def(unwrapped747) + _t1355 = None + return _t1355 + _t1356 = _t1354(msg) + deconstruct_result751 = _t1356 + if deconstruct_result751 is not None: + assert deconstruct_result751 is not None + unwrapped752 = deconstruct_result751 + self.pretty_def(unwrapped752) else: - def _t1347(_dollar_dollar): + def _t1357(_dollar_dollar): if _dollar_dollar.HasField("algorithm"): - _t1348 = _dollar_dollar.algorithm + _t1358 = _dollar_dollar.algorithm else: - _t1348 = None - return _t1348 - _t1349 = _t1347(msg) - deconstruct_result744 = _t1349 - if deconstruct_result744 is not None: - assert deconstruct_result744 is not None - unwrapped745 = deconstruct_result744 - self.pretty_algorithm(unwrapped745) + _t1358 = None + return _t1358 + _t1359 = _t1357(msg) + deconstruct_result749 = _t1359 + if deconstruct_result749 is not None: + assert deconstruct_result749 is not None + unwrapped750 = deconstruct_result749 + self.pretty_algorithm(unwrapped750) else: - def _t1350(_dollar_dollar): + def _t1360(_dollar_dollar): if _dollar_dollar.HasField("constraint"): - _t1351 = _dollar_dollar.constraint + _t1361 = _dollar_dollar.constraint else: - _t1351 = None - return _t1351 - _t1352 = _t1350(msg) - deconstruct_result742 = _t1352 - if deconstruct_result742 is not None: - assert deconstruct_result742 is not None - unwrapped743 = deconstruct_result742 - self.pretty_constraint(unwrapped743) + _t1361 = None + return _t1361 + _t1362 = _t1360(msg) + deconstruct_result747 = _t1362 + if deconstruct_result747 is not None: + assert deconstruct_result747 is not None + unwrapped748 = deconstruct_result747 + self.pretty_constraint(unwrapped748) else: - def _t1353(_dollar_dollar): + def _t1363(_dollar_dollar): if _dollar_dollar.HasField("data"): - _t1354 = _dollar_dollar.data + _t1364 = _dollar_dollar.data else: - _t1354 = None - return _t1354 - _t1355 = _t1353(msg) - deconstruct_result740 = _t1355 - if deconstruct_result740 is not None: - assert deconstruct_result740 is not None - unwrapped741 = deconstruct_result740 - self.pretty_data(unwrapped741) + _t1364 = None + return _t1364 + _t1365 = _t1363(msg) + deconstruct_result745 = _t1365 + if deconstruct_result745 is not None: + assert deconstruct_result745 is not None + unwrapped746 = deconstruct_result745 + self.pretty_data(unwrapped746) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat755 = self._try_flat(msg, self.pretty_def) - if flat755 is not None: - assert flat755 is not None - self.write(flat755) + flat760 = self._try_flat(msg, self.pretty_def) + if flat760 is not None: + assert flat760 is not None + self.write(flat760) return None else: - def _t1356(_dollar_dollar): + def _t1366(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1357 = _dollar_dollar.attrs + _t1367 = _dollar_dollar.attrs else: - _t1357 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1357,) - _t1358 = _t1356(msg) - fields749 = _t1358 - assert fields749 is not None - unwrapped_fields750 = fields749 + _t1367 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1367,) + _t1368 = _t1366(msg) + fields754 = _t1368 + assert fields754 is not None + unwrapped_fields755 = fields754 self.write("(") self.write("def") self.indent_sexp() self.newline() - field751 = unwrapped_fields750[0] - self.pretty_relation_id(field751) + field756 = unwrapped_fields755[0] + self.pretty_relation_id(field756) self.newline() - field752 = unwrapped_fields750[1] - self.pretty_abstraction(field752) - field753 = unwrapped_fields750[2] - if field753 is not None: + field757 = unwrapped_fields755[1] + self.pretty_abstraction(field757) + field758 = unwrapped_fields755[2] + if field758 is not None: self.newline() - assert field753 is not None - opt_val754 = field753 - self.pretty_attrs(opt_val754) + assert field758 is not None + opt_val759 = field758 + self.pretty_attrs(opt_val759) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat760 = self._try_flat(msg, self.pretty_relation_id) - if flat760 is not None: - assert flat760 is not None - self.write(flat760) + flat765 = self._try_flat(msg, self.pretty_relation_id) + if flat765 is not None: + assert flat765 is not None + self.write(flat765) return None else: - def _t1359(_dollar_dollar): + def _t1369(_dollar_dollar): if self.relation_id_to_string(_dollar_dollar) is not None: - _t1361 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1360 = _t1361 + _t1371 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1370 = _t1371 else: - _t1360 = None - return _t1360 - _t1362 = _t1359(msg) - deconstruct_result758 = _t1362 - if deconstruct_result758 is not None: - assert deconstruct_result758 is not None - unwrapped759 = deconstruct_result758 + _t1370 = None + return _t1370 + _t1372 = _t1369(msg) + deconstruct_result763 = _t1372 + if deconstruct_result763 is not None: + assert deconstruct_result763 is not None + unwrapped764 = deconstruct_result763 self.write(":") - self.write(unwrapped759) + self.write(unwrapped764) else: - def _t1363(_dollar_dollar): - _t1364 = self.deconstruct_relation_id_uint128(_dollar_dollar) - return _t1364 - _t1365 = _t1363(msg) - deconstruct_result756 = _t1365 - if deconstruct_result756 is not None: - assert deconstruct_result756 is not None - unwrapped757 = deconstruct_result756 - self.write(self.format_uint128(unwrapped757)) + def _t1373(_dollar_dollar): + _t1374 = self.deconstruct_relation_id_uint128(_dollar_dollar) + return _t1374 + _t1375 = _t1373(msg) + deconstruct_result761 = _t1375 + if deconstruct_result761 is not None: + assert deconstruct_result761 is not None + unwrapped762 = deconstruct_result761 + self.write(self.format_uint128(unwrapped762)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat765 = self._try_flat(msg, self.pretty_abstraction) - if flat765 is not None: - assert flat765 is not None - self.write(flat765) + flat770 = self._try_flat(msg, self.pretty_abstraction) + if flat770 is not None: + assert flat770 is not None + self.write(flat770) return None else: - def _t1366(_dollar_dollar): - _t1367 = self.deconstruct_bindings(_dollar_dollar) - return (_t1367, _dollar_dollar.value,) - _t1368 = _t1366(msg) - fields761 = _t1368 - assert fields761 is not None - unwrapped_fields762 = fields761 + def _t1376(_dollar_dollar): + _t1377 = self.deconstruct_bindings(_dollar_dollar) + return (_t1377, _dollar_dollar.value,) + _t1378 = _t1376(msg) + fields766 = _t1378 + assert fields766 is not None + unwrapped_fields767 = fields766 self.write("(") self.indent() - field763 = unwrapped_fields762[0] - self.pretty_bindings(field763) + field768 = unwrapped_fields767[0] + self.pretty_bindings(field768) self.newline() - field764 = unwrapped_fields762[1] - self.pretty_formula(field764) + field769 = unwrapped_fields767[1] + self.pretty_formula(field769) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat773 = self._try_flat(msg, self.pretty_bindings) - if flat773 is not None: - assert flat773 is not None - self.write(flat773) + flat778 = self._try_flat(msg, self.pretty_bindings) + if flat778 is not None: + assert flat778 is not None + self.write(flat778) return None else: - def _t1369(_dollar_dollar): + def _t1379(_dollar_dollar): if not len(_dollar_dollar[1]) == 0: - _t1370 = _dollar_dollar[1] + _t1380 = _dollar_dollar[1] else: - _t1370 = None - return (_dollar_dollar[0], _t1370,) - _t1371 = _t1369(msg) - fields766 = _t1371 - assert fields766 is not None - unwrapped_fields767 = fields766 + _t1380 = None + return (_dollar_dollar[0], _t1380,) + _t1381 = _t1379(msg) + fields771 = _t1381 + assert fields771 is not None + unwrapped_fields772 = fields771 self.write("[") self.indent() - field768 = unwrapped_fields767[0] - for i770, elem769 in enumerate(field768): - if (i770 > 0): + field773 = unwrapped_fields772[0] + for i775, elem774 in enumerate(field773): + if (i775 > 0): self.newline() - self.pretty_binding(elem769) - field771 = unwrapped_fields767[1] - if field771 is not None: + self.pretty_binding(elem774) + field776 = unwrapped_fields772[1] + if field776 is not None: self.newline() - assert field771 is not None - opt_val772 = field771 - self.pretty_value_bindings(opt_val772) + assert field776 is not None + opt_val777 = field776 + self.pretty_value_bindings(opt_val777) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat778 = self._try_flat(msg, self.pretty_binding) - if flat778 is not None: - assert flat778 is not None - self.write(flat778) + flat783 = self._try_flat(msg, self.pretty_binding) + if flat783 is not None: + assert flat783 is not None + self.write(flat783) return None else: - def _t1372(_dollar_dollar): + def _t1382(_dollar_dollar): return (_dollar_dollar.var.name, _dollar_dollar.type,) - _t1373 = _t1372(msg) - fields774 = _t1373 - assert fields774 is not None - unwrapped_fields775 = fields774 - field776 = unwrapped_fields775[0] - self.write(field776) + _t1383 = _t1382(msg) + fields779 = _t1383 + assert fields779 is not None + unwrapped_fields780 = fields779 + field781 = unwrapped_fields780[0] + self.write(field781) self.write("::") - field777 = unwrapped_fields775[1] - self.pretty_type(field777) + field782 = unwrapped_fields780[1] + self.pretty_type(field782) def pretty_type(self, msg: logic_pb2.Type): - flat801 = self._try_flat(msg, self.pretty_type) - if flat801 is not None: - assert flat801 is not None - self.write(flat801) + flat806 = self._try_flat(msg, self.pretty_type) + if flat806 is not None: + assert flat806 is not None + self.write(flat806) return None else: - def _t1374(_dollar_dollar): + def _t1384(_dollar_dollar): if _dollar_dollar.HasField("unspecified_type"): - _t1375 = _dollar_dollar.unspecified_type + _t1385 = _dollar_dollar.unspecified_type else: - _t1375 = None - return _t1375 - _t1376 = _t1374(msg) - deconstruct_result799 = _t1376 - if deconstruct_result799 is not None: - assert deconstruct_result799 is not None - unwrapped800 = deconstruct_result799 - self.pretty_unspecified_type(unwrapped800) + _t1385 = None + return _t1385 + _t1386 = _t1384(msg) + deconstruct_result804 = _t1386 + if deconstruct_result804 is not None: + assert deconstruct_result804 is not None + unwrapped805 = deconstruct_result804 + self.pretty_unspecified_type(unwrapped805) else: - def _t1377(_dollar_dollar): + def _t1387(_dollar_dollar): if _dollar_dollar.HasField("string_type"): - _t1378 = _dollar_dollar.string_type + _t1388 = _dollar_dollar.string_type else: - _t1378 = None - return _t1378 - _t1379 = _t1377(msg) - deconstruct_result797 = _t1379 - if deconstruct_result797 is not None: - assert deconstruct_result797 is not None - unwrapped798 = deconstruct_result797 - self.pretty_string_type(unwrapped798) + _t1388 = None + return _t1388 + _t1389 = _t1387(msg) + deconstruct_result802 = _t1389 + if deconstruct_result802 is not None: + assert deconstruct_result802 is not None + unwrapped803 = deconstruct_result802 + self.pretty_string_type(unwrapped803) else: - def _t1380(_dollar_dollar): + def _t1390(_dollar_dollar): if _dollar_dollar.HasField("int_type"): - _t1381 = _dollar_dollar.int_type + _t1391 = _dollar_dollar.int_type else: - _t1381 = None - return _t1381 - _t1382 = _t1380(msg) - deconstruct_result795 = _t1382 - if deconstruct_result795 is not None: - assert deconstruct_result795 is not None - unwrapped796 = deconstruct_result795 - self.pretty_int_type(unwrapped796) + _t1391 = None + return _t1391 + _t1392 = _t1390(msg) + deconstruct_result800 = _t1392 + if deconstruct_result800 is not None: + assert deconstruct_result800 is not None + unwrapped801 = deconstruct_result800 + self.pretty_int_type(unwrapped801) else: - def _t1383(_dollar_dollar): + def _t1393(_dollar_dollar): if _dollar_dollar.HasField("float_type"): - _t1384 = _dollar_dollar.float_type + _t1394 = _dollar_dollar.float_type else: - _t1384 = None - return _t1384 - _t1385 = _t1383(msg) - deconstruct_result793 = _t1385 - if deconstruct_result793 is not None: - assert deconstruct_result793 is not None - unwrapped794 = deconstruct_result793 - self.pretty_float_type(unwrapped794) + _t1394 = None + return _t1394 + _t1395 = _t1393(msg) + deconstruct_result798 = _t1395 + if deconstruct_result798 is not None: + assert deconstruct_result798 is not None + unwrapped799 = deconstruct_result798 + self.pretty_float_type(unwrapped799) else: - def _t1386(_dollar_dollar): + def _t1396(_dollar_dollar): if _dollar_dollar.HasField("uint128_type"): - _t1387 = _dollar_dollar.uint128_type + _t1397 = _dollar_dollar.uint128_type else: - _t1387 = None - return _t1387 - _t1388 = _t1386(msg) - deconstruct_result791 = _t1388 - if deconstruct_result791 is not None: - assert deconstruct_result791 is not None - unwrapped792 = deconstruct_result791 - self.pretty_uint128_type(unwrapped792) + _t1397 = None + return _t1397 + _t1398 = _t1396(msg) + deconstruct_result796 = _t1398 + if deconstruct_result796 is not None: + assert deconstruct_result796 is not None + unwrapped797 = deconstruct_result796 + self.pretty_uint128_type(unwrapped797) else: - def _t1389(_dollar_dollar): + def _t1399(_dollar_dollar): if _dollar_dollar.HasField("int128_type"): - _t1390 = _dollar_dollar.int128_type + _t1400 = _dollar_dollar.int128_type else: - _t1390 = None - return _t1390 - _t1391 = _t1389(msg) - deconstruct_result789 = _t1391 - if deconstruct_result789 is not None: - assert deconstruct_result789 is not None - unwrapped790 = deconstruct_result789 - self.pretty_int128_type(unwrapped790) + _t1400 = None + return _t1400 + _t1401 = _t1399(msg) + deconstruct_result794 = _t1401 + if deconstruct_result794 is not None: + assert deconstruct_result794 is not None + unwrapped795 = deconstruct_result794 + self.pretty_int128_type(unwrapped795) else: - def _t1392(_dollar_dollar): + def _t1402(_dollar_dollar): if _dollar_dollar.HasField("date_type"): - _t1393 = _dollar_dollar.date_type + _t1403 = _dollar_dollar.date_type else: - _t1393 = None - return _t1393 - _t1394 = _t1392(msg) - deconstruct_result787 = _t1394 - if deconstruct_result787 is not None: - assert deconstruct_result787 is not None - unwrapped788 = deconstruct_result787 - self.pretty_date_type(unwrapped788) + _t1403 = None + return _t1403 + _t1404 = _t1402(msg) + deconstruct_result792 = _t1404 + if deconstruct_result792 is not None: + assert deconstruct_result792 is not None + unwrapped793 = deconstruct_result792 + self.pretty_date_type(unwrapped793) else: - def _t1395(_dollar_dollar): + def _t1405(_dollar_dollar): if _dollar_dollar.HasField("datetime_type"): - _t1396 = _dollar_dollar.datetime_type + _t1406 = _dollar_dollar.datetime_type else: - _t1396 = None - return _t1396 - _t1397 = _t1395(msg) - deconstruct_result785 = _t1397 - if deconstruct_result785 is not None: - assert deconstruct_result785 is not None - unwrapped786 = deconstruct_result785 - self.pretty_datetime_type(unwrapped786) + _t1406 = None + return _t1406 + _t1407 = _t1405(msg) + deconstruct_result790 = _t1407 + if deconstruct_result790 is not None: + assert deconstruct_result790 is not None + unwrapped791 = deconstruct_result790 + self.pretty_datetime_type(unwrapped791) else: - def _t1398(_dollar_dollar): + def _t1408(_dollar_dollar): if _dollar_dollar.HasField("missing_type"): - _t1399 = _dollar_dollar.missing_type + _t1409 = _dollar_dollar.missing_type else: - _t1399 = None - return _t1399 - _t1400 = _t1398(msg) - deconstruct_result783 = _t1400 - if deconstruct_result783 is not None: - assert deconstruct_result783 is not None - unwrapped784 = deconstruct_result783 - self.pretty_missing_type(unwrapped784) + _t1409 = None + return _t1409 + _t1410 = _t1408(msg) + deconstruct_result788 = _t1410 + if deconstruct_result788 is not None: + assert deconstruct_result788 is not None + unwrapped789 = deconstruct_result788 + self.pretty_missing_type(unwrapped789) else: - def _t1401(_dollar_dollar): + def _t1411(_dollar_dollar): if _dollar_dollar.HasField("decimal_type"): - _t1402 = _dollar_dollar.decimal_type + _t1412 = _dollar_dollar.decimal_type else: - _t1402 = None - return _t1402 - _t1403 = _t1401(msg) - deconstruct_result781 = _t1403 - if deconstruct_result781 is not None: - assert deconstruct_result781 is not None - unwrapped782 = deconstruct_result781 - self.pretty_decimal_type(unwrapped782) + _t1412 = None + return _t1412 + _t1413 = _t1411(msg) + deconstruct_result786 = _t1413 + if deconstruct_result786 is not None: + assert deconstruct_result786 is not None + unwrapped787 = deconstruct_result786 + self.pretty_decimal_type(unwrapped787) else: - def _t1404(_dollar_dollar): + def _t1414(_dollar_dollar): if _dollar_dollar.HasField("boolean_type"): - _t1405 = _dollar_dollar.boolean_type + _t1415 = _dollar_dollar.boolean_type else: - _t1405 = None - return _t1405 - _t1406 = _t1404(msg) - deconstruct_result779 = _t1406 - if deconstruct_result779 is not None: - assert deconstruct_result779 is not None - unwrapped780 = deconstruct_result779 - self.pretty_boolean_type(unwrapped780) + _t1415 = None + return _t1415 + _t1416 = _t1414(msg) + deconstruct_result784 = _t1416 + if deconstruct_result784 is not None: + assert deconstruct_result784 is not None + unwrapped785 = deconstruct_result784 + self.pretty_boolean_type(unwrapped785) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields802 = msg + fields807 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields803 = msg + fields808 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields804 = msg + fields809 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields805 = msg + fields810 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields806 = msg + fields811 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields807 = msg + fields812 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields808 = msg + fields813 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields809 = msg + fields814 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields810 = msg + fields815 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat815 = self._try_flat(msg, self.pretty_decimal_type) - if flat815 is not None: - assert flat815 is not None - self.write(flat815) + flat820 = self._try_flat(msg, self.pretty_decimal_type) + if flat820 is not None: + assert flat820 is not None + self.write(flat820) return None else: - def _t1407(_dollar_dollar): + def _t1417(_dollar_dollar): return (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - _t1408 = _t1407(msg) - fields811 = _t1408 - assert fields811 is not None - unwrapped_fields812 = fields811 + _t1418 = _t1417(msg) + fields816 = _t1418 + assert fields816 is not None + unwrapped_fields817 = fields816 self.write("(") self.write("DECIMAL") self.indent_sexp() self.newline() - field813 = unwrapped_fields812[0] - self.write(str(field813)) + field818 = unwrapped_fields817[0] + self.write(str(field818)) self.newline() - field814 = unwrapped_fields812[1] - self.write(str(field814)) + field819 = unwrapped_fields817[1] + self.write(str(field819)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields816 = msg + fields821 = msg self.write("BOOLEAN") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat820 = self._try_flat(msg, self.pretty_value_bindings) - if flat820 is not None: - assert flat820 is not None - self.write(flat820) + flat825 = self._try_flat(msg, self.pretty_value_bindings) + if flat825 is not None: + assert flat825 is not None + self.write(flat825) return None else: - fields817 = msg + fields822 = msg self.write("|") - if not len(fields817) == 0: + if not len(fields822) == 0: self.write(" ") - for i819, elem818 in enumerate(fields817): - if (i819 > 0): + for i824, elem823 in enumerate(fields822): + if (i824 > 0): self.newline() - self.pretty_binding(elem818) + self.pretty_binding(elem823) def pretty_formula(self, msg: logic_pb2.Formula): - flat847 = self._try_flat(msg, self.pretty_formula) - if flat847 is not None: - assert flat847 is not None - self.write(flat847) + flat852 = self._try_flat(msg, self.pretty_formula) + if flat852 is not None: + assert flat852 is not None + self.write(flat852) return None else: - def _t1409(_dollar_dollar): + def _t1419(_dollar_dollar): if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1410 = _dollar_dollar.conjunction + _t1420 = _dollar_dollar.conjunction else: - _t1410 = None - return _t1410 - _t1411 = _t1409(msg) - deconstruct_result845 = _t1411 - if deconstruct_result845 is not None: - assert deconstruct_result845 is not None - unwrapped846 = deconstruct_result845 - self.pretty_true(unwrapped846) + _t1420 = None + return _t1420 + _t1421 = _t1419(msg) + deconstruct_result850 = _t1421 + if deconstruct_result850 is not None: + assert deconstruct_result850 is not None + unwrapped851 = deconstruct_result850 + self.pretty_true(unwrapped851) else: - def _t1412(_dollar_dollar): + def _t1422(_dollar_dollar): if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1413 = _dollar_dollar.disjunction + _t1423 = _dollar_dollar.disjunction else: - _t1413 = None - return _t1413 - _t1414 = _t1412(msg) - deconstruct_result843 = _t1414 - if deconstruct_result843 is not None: - assert deconstruct_result843 is not None - unwrapped844 = deconstruct_result843 - self.pretty_false(unwrapped844) + _t1423 = None + return _t1423 + _t1424 = _t1422(msg) + deconstruct_result848 = _t1424 + if deconstruct_result848 is not None: + assert deconstruct_result848 is not None + unwrapped849 = deconstruct_result848 + self.pretty_false(unwrapped849) else: - def _t1415(_dollar_dollar): + def _t1425(_dollar_dollar): if _dollar_dollar.HasField("exists"): - _t1416 = _dollar_dollar.exists + _t1426 = _dollar_dollar.exists else: - _t1416 = None - return _t1416 - _t1417 = _t1415(msg) - deconstruct_result841 = _t1417 - if deconstruct_result841 is not None: - assert deconstruct_result841 is not None - unwrapped842 = deconstruct_result841 - self.pretty_exists(unwrapped842) + _t1426 = None + return _t1426 + _t1427 = _t1425(msg) + deconstruct_result846 = _t1427 + if deconstruct_result846 is not None: + assert deconstruct_result846 is not None + unwrapped847 = deconstruct_result846 + self.pretty_exists(unwrapped847) else: - def _t1418(_dollar_dollar): + def _t1428(_dollar_dollar): if _dollar_dollar.HasField("reduce"): - _t1419 = _dollar_dollar.reduce + _t1429 = _dollar_dollar.reduce else: - _t1419 = None - return _t1419 - _t1420 = _t1418(msg) - deconstruct_result839 = _t1420 - if deconstruct_result839 is not None: - assert deconstruct_result839 is not None - unwrapped840 = deconstruct_result839 - self.pretty_reduce(unwrapped840) + _t1429 = None + return _t1429 + _t1430 = _t1428(msg) + deconstruct_result844 = _t1430 + if deconstruct_result844 is not None: + assert deconstruct_result844 is not None + unwrapped845 = deconstruct_result844 + self.pretty_reduce(unwrapped845) else: - def _t1421(_dollar_dollar): + def _t1431(_dollar_dollar): if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1422 = _dollar_dollar.conjunction + _t1432 = _dollar_dollar.conjunction else: - _t1422 = None - return _t1422 - _t1423 = _t1421(msg) - deconstruct_result837 = _t1423 - if deconstruct_result837 is not None: - assert deconstruct_result837 is not None - unwrapped838 = deconstruct_result837 - self.pretty_conjunction(unwrapped838) + _t1432 = None + return _t1432 + _t1433 = _t1431(msg) + deconstruct_result842 = _t1433 + if deconstruct_result842 is not None: + assert deconstruct_result842 is not None + unwrapped843 = deconstruct_result842 + self.pretty_conjunction(unwrapped843) else: - def _t1424(_dollar_dollar): + def _t1434(_dollar_dollar): if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1425 = _dollar_dollar.disjunction + _t1435 = _dollar_dollar.disjunction else: - _t1425 = None - return _t1425 - _t1426 = _t1424(msg) - deconstruct_result835 = _t1426 - if deconstruct_result835 is not None: - assert deconstruct_result835 is not None - unwrapped836 = deconstruct_result835 - self.pretty_disjunction(unwrapped836) + _t1435 = None + return _t1435 + _t1436 = _t1434(msg) + deconstruct_result840 = _t1436 + if deconstruct_result840 is not None: + assert deconstruct_result840 is not None + unwrapped841 = deconstruct_result840 + self.pretty_disjunction(unwrapped841) else: - def _t1427(_dollar_dollar): + def _t1437(_dollar_dollar): if _dollar_dollar.HasField("not"): - _t1428 = getattr(_dollar_dollar, 'not') + _t1438 = getattr(_dollar_dollar, 'not') else: - _t1428 = None - return _t1428 - _t1429 = _t1427(msg) - deconstruct_result833 = _t1429 - if deconstruct_result833 is not None: - assert deconstruct_result833 is not None - unwrapped834 = deconstruct_result833 - self.pretty_not(unwrapped834) + _t1438 = None + return _t1438 + _t1439 = _t1437(msg) + deconstruct_result838 = _t1439 + if deconstruct_result838 is not None: + assert deconstruct_result838 is not None + unwrapped839 = deconstruct_result838 + self.pretty_not(unwrapped839) else: - def _t1430(_dollar_dollar): + def _t1440(_dollar_dollar): if _dollar_dollar.HasField("ffi"): - _t1431 = _dollar_dollar.ffi + _t1441 = _dollar_dollar.ffi else: - _t1431 = None - return _t1431 - _t1432 = _t1430(msg) - deconstruct_result831 = _t1432 - if deconstruct_result831 is not None: - assert deconstruct_result831 is not None - unwrapped832 = deconstruct_result831 - self.pretty_ffi(unwrapped832) + _t1441 = None + return _t1441 + _t1442 = _t1440(msg) + deconstruct_result836 = _t1442 + if deconstruct_result836 is not None: + assert deconstruct_result836 is not None + unwrapped837 = deconstruct_result836 + self.pretty_ffi(unwrapped837) else: - def _t1433(_dollar_dollar): + def _t1443(_dollar_dollar): if _dollar_dollar.HasField("atom"): - _t1434 = _dollar_dollar.atom + _t1444 = _dollar_dollar.atom else: - _t1434 = None - return _t1434 - _t1435 = _t1433(msg) - deconstruct_result829 = _t1435 - if deconstruct_result829 is not None: - assert deconstruct_result829 is not None - unwrapped830 = deconstruct_result829 - self.pretty_atom(unwrapped830) + _t1444 = None + return _t1444 + _t1445 = _t1443(msg) + deconstruct_result834 = _t1445 + if deconstruct_result834 is not None: + assert deconstruct_result834 is not None + unwrapped835 = deconstruct_result834 + self.pretty_atom(unwrapped835) else: - def _t1436(_dollar_dollar): + def _t1446(_dollar_dollar): if _dollar_dollar.HasField("pragma"): - _t1437 = _dollar_dollar.pragma + _t1447 = _dollar_dollar.pragma else: - _t1437 = None - return _t1437 - _t1438 = _t1436(msg) - deconstruct_result827 = _t1438 - if deconstruct_result827 is not None: - assert deconstruct_result827 is not None - unwrapped828 = deconstruct_result827 - self.pretty_pragma(unwrapped828) + _t1447 = None + return _t1447 + _t1448 = _t1446(msg) + deconstruct_result832 = _t1448 + if deconstruct_result832 is not None: + assert deconstruct_result832 is not None + unwrapped833 = deconstruct_result832 + self.pretty_pragma(unwrapped833) else: - def _t1439(_dollar_dollar): + def _t1449(_dollar_dollar): if _dollar_dollar.HasField("primitive"): - _t1440 = _dollar_dollar.primitive + _t1450 = _dollar_dollar.primitive else: - _t1440 = None - return _t1440 - _t1441 = _t1439(msg) - deconstruct_result825 = _t1441 - if deconstruct_result825 is not None: - assert deconstruct_result825 is not None - unwrapped826 = deconstruct_result825 - self.pretty_primitive(unwrapped826) + _t1450 = None + return _t1450 + _t1451 = _t1449(msg) + deconstruct_result830 = _t1451 + if deconstruct_result830 is not None: + assert deconstruct_result830 is not None + unwrapped831 = deconstruct_result830 + self.pretty_primitive(unwrapped831) else: - def _t1442(_dollar_dollar): + def _t1452(_dollar_dollar): if _dollar_dollar.HasField("rel_atom"): - _t1443 = _dollar_dollar.rel_atom + _t1453 = _dollar_dollar.rel_atom else: - _t1443 = None - return _t1443 - _t1444 = _t1442(msg) - deconstruct_result823 = _t1444 - if deconstruct_result823 is not None: - assert deconstruct_result823 is not None - unwrapped824 = deconstruct_result823 - self.pretty_rel_atom(unwrapped824) + _t1453 = None + return _t1453 + _t1454 = _t1452(msg) + deconstruct_result828 = _t1454 + if deconstruct_result828 is not None: + assert deconstruct_result828 is not None + unwrapped829 = deconstruct_result828 + self.pretty_rel_atom(unwrapped829) else: - def _t1445(_dollar_dollar): + def _t1455(_dollar_dollar): if _dollar_dollar.HasField("cast"): - _t1446 = _dollar_dollar.cast + _t1456 = _dollar_dollar.cast else: - _t1446 = None - return _t1446 - _t1447 = _t1445(msg) - deconstruct_result821 = _t1447 - if deconstruct_result821 is not None: - assert deconstruct_result821 is not None - unwrapped822 = deconstruct_result821 - self.pretty_cast(unwrapped822) + _t1456 = None + return _t1456 + _t1457 = _t1455(msg) + deconstruct_result826 = _t1457 + if deconstruct_result826 is not None: + assert deconstruct_result826 is not None + unwrapped827 = deconstruct_result826 + self.pretty_cast(unwrapped827) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields848 = msg + fields853 = msg self.write("(") self.write("true") self.write(")") def pretty_false(self, msg: logic_pb2.Disjunction): - fields849 = msg + fields854 = msg self.write("(") self.write("false") self.write(")") def pretty_exists(self, msg: logic_pb2.Exists): - flat854 = self._try_flat(msg, self.pretty_exists) - if flat854 is not None: - assert flat854 is not None - self.write(flat854) + flat859 = self._try_flat(msg, self.pretty_exists) + if flat859 is not None: + assert flat859 is not None + self.write(flat859) return None else: - def _t1448(_dollar_dollar): - _t1449 = self.deconstruct_bindings(_dollar_dollar.body) - return (_t1449, _dollar_dollar.body.value,) - _t1450 = _t1448(msg) - fields850 = _t1450 - assert fields850 is not None - unwrapped_fields851 = fields850 + def _t1458(_dollar_dollar): + _t1459 = self.deconstruct_bindings(_dollar_dollar.body) + return (_t1459, _dollar_dollar.body.value,) + _t1460 = _t1458(msg) + fields855 = _t1460 + assert fields855 is not None + unwrapped_fields856 = fields855 self.write("(") self.write("exists") self.indent_sexp() self.newline() - field852 = unwrapped_fields851[0] - self.pretty_bindings(field852) + field857 = unwrapped_fields856[0] + self.pretty_bindings(field857) self.newline() - field853 = unwrapped_fields851[1] - self.pretty_formula(field853) + field858 = unwrapped_fields856[1] + self.pretty_formula(field858) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat860 = self._try_flat(msg, self.pretty_reduce) - if flat860 is not None: - assert flat860 is not None - self.write(flat860) + flat865 = self._try_flat(msg, self.pretty_reduce) + if flat865 is not None: + assert flat865 is not None + self.write(flat865) return None else: - def _t1451(_dollar_dollar): + def _t1461(_dollar_dollar): return (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - _t1452 = _t1451(msg) - fields855 = _t1452 - assert fields855 is not None - unwrapped_fields856 = fields855 + _t1462 = _t1461(msg) + fields860 = _t1462 + assert fields860 is not None + unwrapped_fields861 = fields860 self.write("(") self.write("reduce") self.indent_sexp() self.newline() - field857 = unwrapped_fields856[0] - self.pretty_abstraction(field857) + field862 = unwrapped_fields861[0] + self.pretty_abstraction(field862) self.newline() - field858 = unwrapped_fields856[1] - self.pretty_abstraction(field858) + field863 = unwrapped_fields861[1] + self.pretty_abstraction(field863) self.newline() - field859 = unwrapped_fields856[2] - self.pretty_terms(field859) + field864 = unwrapped_fields861[2] + self.pretty_terms(field864) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat864 = self._try_flat(msg, self.pretty_terms) - if flat864 is not None: - assert flat864 is not None - self.write(flat864) + flat869 = self._try_flat(msg, self.pretty_terms) + if flat869 is not None: + assert flat869 is not None + self.write(flat869) return None else: - fields861 = msg + fields866 = msg self.write("(") self.write("terms") self.indent_sexp() - if not len(fields861) == 0: + if not len(fields866) == 0: self.newline() - for i863, elem862 in enumerate(fields861): - if (i863 > 0): + for i868, elem867 in enumerate(fields866): + if (i868 > 0): self.newline() - self.pretty_term(elem862) + self.pretty_term(elem867) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat869 = self._try_flat(msg, self.pretty_term) - if flat869 is not None: - assert flat869 is not None - self.write(flat869) + flat874 = self._try_flat(msg, self.pretty_term) + if flat874 is not None: + assert flat874 is not None + self.write(flat874) return None else: - def _t1453(_dollar_dollar): + def _t1463(_dollar_dollar): if _dollar_dollar.HasField("var"): - _t1454 = _dollar_dollar.var + _t1464 = _dollar_dollar.var else: - _t1454 = None - return _t1454 - _t1455 = _t1453(msg) - deconstruct_result867 = _t1455 - if deconstruct_result867 is not None: - assert deconstruct_result867 is not None - unwrapped868 = deconstruct_result867 - self.pretty_var(unwrapped868) + _t1464 = None + return _t1464 + _t1465 = _t1463(msg) + deconstruct_result872 = _t1465 + if deconstruct_result872 is not None: + assert deconstruct_result872 is not None + unwrapped873 = deconstruct_result872 + self.pretty_var(unwrapped873) else: - def _t1456(_dollar_dollar): + def _t1466(_dollar_dollar): if _dollar_dollar.HasField("constant"): - _t1457 = _dollar_dollar.constant + _t1467 = _dollar_dollar.constant else: - _t1457 = None - return _t1457 - _t1458 = _t1456(msg) - deconstruct_result865 = _t1458 - if deconstruct_result865 is not None: - assert deconstruct_result865 is not None - unwrapped866 = deconstruct_result865 - self.pretty_constant(unwrapped866) + _t1467 = None + return _t1467 + _t1468 = _t1466(msg) + deconstruct_result870 = _t1468 + if deconstruct_result870 is not None: + assert deconstruct_result870 is not None + unwrapped871 = deconstruct_result870 + self.pretty_constant(unwrapped871) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat872 = self._try_flat(msg, self.pretty_var) - if flat872 is not None: - assert flat872 is not None - self.write(flat872) + flat877 = self._try_flat(msg, self.pretty_var) + if flat877 is not None: + assert flat877 is not None + self.write(flat877) return None else: - def _t1459(_dollar_dollar): + def _t1469(_dollar_dollar): return _dollar_dollar.name - _t1460 = _t1459(msg) - fields870 = _t1460 - assert fields870 is not None - unwrapped_fields871 = fields870 - self.write(unwrapped_fields871) + _t1470 = _t1469(msg) + fields875 = _t1470 + assert fields875 is not None + unwrapped_fields876 = fields875 + self.write(unwrapped_fields876) def pretty_constant(self, msg: logic_pb2.Value): - flat874 = self._try_flat(msg, self.pretty_constant) - if flat874 is not None: - assert flat874 is not None - self.write(flat874) + flat879 = self._try_flat(msg, self.pretty_constant) + if flat879 is not None: + assert flat879 is not None + self.write(flat879) return None else: - fields873 = msg - self.pretty_value(fields873) + fields878 = msg + self.pretty_value(fields878) def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat879 = self._try_flat(msg, self.pretty_conjunction) - if flat879 is not None: - assert flat879 is not None - self.write(flat879) + flat884 = self._try_flat(msg, self.pretty_conjunction) + if flat884 is not None: + assert flat884 is not None + self.write(flat884) return None else: - def _t1461(_dollar_dollar): + def _t1471(_dollar_dollar): return _dollar_dollar.args - _t1462 = _t1461(msg) - fields875 = _t1462 - assert fields875 is not None - unwrapped_fields876 = fields875 + _t1472 = _t1471(msg) + fields880 = _t1472 + assert fields880 is not None + unwrapped_fields881 = fields880 self.write("(") self.write("and") self.indent_sexp() - if not len(unwrapped_fields876) == 0: + if not len(unwrapped_fields881) == 0: self.newline() - for i878, elem877 in enumerate(unwrapped_fields876): - if (i878 > 0): + for i883, elem882 in enumerate(unwrapped_fields881): + if (i883 > 0): self.newline() - self.pretty_formula(elem877) + self.pretty_formula(elem882) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat884 = self._try_flat(msg, self.pretty_disjunction) - if flat884 is not None: - assert flat884 is not None - self.write(flat884) + flat889 = self._try_flat(msg, self.pretty_disjunction) + if flat889 is not None: + assert flat889 is not None + self.write(flat889) return None else: - def _t1463(_dollar_dollar): + def _t1473(_dollar_dollar): return _dollar_dollar.args - _t1464 = _t1463(msg) - fields880 = _t1464 - assert fields880 is not None - unwrapped_fields881 = fields880 + _t1474 = _t1473(msg) + fields885 = _t1474 + assert fields885 is not None + unwrapped_fields886 = fields885 self.write("(") self.write("or") self.indent_sexp() - if not len(unwrapped_fields881) == 0: + if not len(unwrapped_fields886) == 0: self.newline() - for i883, elem882 in enumerate(unwrapped_fields881): - if (i883 > 0): + for i888, elem887 in enumerate(unwrapped_fields886): + if (i888 > 0): self.newline() - self.pretty_formula(elem882) + self.pretty_formula(elem887) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat887 = self._try_flat(msg, self.pretty_not) - if flat887 is not None: - assert flat887 is not None - self.write(flat887) + flat892 = self._try_flat(msg, self.pretty_not) + if flat892 is not None: + assert flat892 is not None + self.write(flat892) return None else: - def _t1465(_dollar_dollar): + def _t1475(_dollar_dollar): return _dollar_dollar.arg - _t1466 = _t1465(msg) - fields885 = _t1466 - assert fields885 is not None - unwrapped_fields886 = fields885 + _t1476 = _t1475(msg) + fields890 = _t1476 + assert fields890 is not None + unwrapped_fields891 = fields890 self.write("(") self.write("not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields886) + self.pretty_formula(unwrapped_fields891) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat893 = self._try_flat(msg, self.pretty_ffi) - if flat893 is not None: - assert flat893 is not None - self.write(flat893) + flat898 = self._try_flat(msg, self.pretty_ffi) + if flat898 is not None: + assert flat898 is not None + self.write(flat898) return None else: - def _t1467(_dollar_dollar): + def _t1477(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - _t1468 = _t1467(msg) - fields888 = _t1468 - assert fields888 is not None - unwrapped_fields889 = fields888 + _t1478 = _t1477(msg) + fields893 = _t1478 + assert fields893 is not None + unwrapped_fields894 = fields893 self.write("(") self.write("ffi") self.indent_sexp() self.newline() - field890 = unwrapped_fields889[0] - self.pretty_name(field890) + field895 = unwrapped_fields894[0] + self.pretty_name(field895) self.newline() - field891 = unwrapped_fields889[1] - self.pretty_ffi_args(field891) + field896 = unwrapped_fields894[1] + self.pretty_ffi_args(field896) self.newline() - field892 = unwrapped_fields889[2] - self.pretty_terms(field892) + field897 = unwrapped_fields894[2] + self.pretty_terms(field897) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat895 = self._try_flat(msg, self.pretty_name) - if flat895 is not None: - assert flat895 is not None - self.write(flat895) + flat900 = self._try_flat(msg, self.pretty_name) + if flat900 is not None: + assert flat900 is not None + self.write(flat900) return None else: - fields894 = msg + fields899 = msg self.write(":") - self.write(fields894) + self.write(fields899) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat899 = self._try_flat(msg, self.pretty_ffi_args) - if flat899 is not None: - assert flat899 is not None - self.write(flat899) + flat904 = self._try_flat(msg, self.pretty_ffi_args) + if flat904 is not None: + assert flat904 is not None + self.write(flat904) return None else: - fields896 = msg + fields901 = msg self.write("(") self.write("args") self.indent_sexp() - if not len(fields896) == 0: + if not len(fields901) == 0: self.newline() - for i898, elem897 in enumerate(fields896): - if (i898 > 0): + for i903, elem902 in enumerate(fields901): + if (i903 > 0): self.newline() - self.pretty_abstraction(elem897) + self.pretty_abstraction(elem902) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat906 = self._try_flat(msg, self.pretty_atom) - if flat906 is not None: - assert flat906 is not None - self.write(flat906) + flat911 = self._try_flat(msg, self.pretty_atom) + if flat911 is not None: + assert flat911 is not None + self.write(flat911) return None else: - def _t1469(_dollar_dollar): + def _t1479(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1470 = _t1469(msg) - fields900 = _t1470 - assert fields900 is not None - unwrapped_fields901 = fields900 + _t1480 = _t1479(msg) + fields905 = _t1480 + assert fields905 is not None + unwrapped_fields906 = fields905 self.write("(") self.write("atom") self.indent_sexp() self.newline() - field902 = unwrapped_fields901[0] - self.pretty_relation_id(field902) - field903 = unwrapped_fields901[1] - if not len(field903) == 0: + field907 = unwrapped_fields906[0] + self.pretty_relation_id(field907) + field908 = unwrapped_fields906[1] + if not len(field908) == 0: self.newline() - for i905, elem904 in enumerate(field903): - if (i905 > 0): + for i910, elem909 in enumerate(field908): + if (i910 > 0): self.newline() - self.pretty_term(elem904) + self.pretty_term(elem909) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat913 = self._try_flat(msg, self.pretty_pragma) - if flat913 is not None: - assert flat913 is not None - self.write(flat913) + flat918 = self._try_flat(msg, self.pretty_pragma) + if flat918 is not None: + assert flat918 is not None + self.write(flat918) return None else: - def _t1471(_dollar_dollar): + def _t1481(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1472 = _t1471(msg) - fields907 = _t1472 - assert fields907 is not None - unwrapped_fields908 = fields907 + _t1482 = _t1481(msg) + fields912 = _t1482 + assert fields912 is not None + unwrapped_fields913 = fields912 self.write("(") self.write("pragma") self.indent_sexp() self.newline() - field909 = unwrapped_fields908[0] - self.pretty_name(field909) - field910 = unwrapped_fields908[1] - if not len(field910) == 0: + field914 = unwrapped_fields913[0] + self.pretty_name(field914) + field915 = unwrapped_fields913[1] + if not len(field915) == 0: self.newline() - for i912, elem911 in enumerate(field910): - if (i912 > 0): + for i917, elem916 in enumerate(field915): + if (i917 > 0): self.newline() - self.pretty_term(elem911) + self.pretty_term(elem916) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat929 = self._try_flat(msg, self.pretty_primitive) - if flat929 is not None: - assert flat929 is not None - self.write(flat929) + flat934 = self._try_flat(msg, self.pretty_primitive) + if flat934 is not None: + assert flat934 is not None + self.write(flat934) return None else: - def _t1473(_dollar_dollar): + def _t1483(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_eq": - _t1474 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1484 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1474 = None - return _t1474 - _t1475 = _t1473(msg) - guard_result928 = _t1475 - if guard_result928 is not None: + _t1484 = None + return _t1484 + _t1485 = _t1483(msg) + guard_result933 = _t1485 + if guard_result933 is not None: self.pretty_eq(msg) else: - def _t1476(_dollar_dollar): + def _t1486(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1477 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1487 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1477 = None - return _t1477 - _t1478 = _t1476(msg) - guard_result927 = _t1478 - if guard_result927 is not None: + _t1487 = None + return _t1487 + _t1488 = _t1486(msg) + guard_result932 = _t1488 + if guard_result932 is not None: self.pretty_lt(msg) else: - def _t1479(_dollar_dollar): + def _t1489(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1480 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1490 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1480 = None - return _t1480 - _t1481 = _t1479(msg) - guard_result926 = _t1481 - if guard_result926 is not None: + _t1490 = None + return _t1490 + _t1491 = _t1489(msg) + guard_result931 = _t1491 + if guard_result931 is not None: self.pretty_lt_eq(msg) else: - def _t1482(_dollar_dollar): + def _t1492(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1483 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1493 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1483 = None - return _t1483 - _t1484 = _t1482(msg) - guard_result925 = _t1484 - if guard_result925 is not None: + _t1493 = None + return _t1493 + _t1494 = _t1492(msg) + guard_result930 = _t1494 + if guard_result930 is not None: self.pretty_gt(msg) else: - def _t1485(_dollar_dollar): + def _t1495(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1486 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1496 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1486 = None - return _t1486 - _t1487 = _t1485(msg) - guard_result924 = _t1487 - if guard_result924 is not None: + _t1496 = None + return _t1496 + _t1497 = _t1495(msg) + guard_result929 = _t1497 + if guard_result929 is not None: self.pretty_gt_eq(msg) else: - def _t1488(_dollar_dollar): + def _t1498(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1489 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1499 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1489 = None - return _t1489 - _t1490 = _t1488(msg) - guard_result923 = _t1490 - if guard_result923 is not None: + _t1499 = None + return _t1499 + _t1500 = _t1498(msg) + guard_result928 = _t1500 + if guard_result928 is not None: self.pretty_add(msg) else: - def _t1491(_dollar_dollar): + def _t1501(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1492 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1502 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1492 = None - return _t1492 - _t1493 = _t1491(msg) - guard_result922 = _t1493 - if guard_result922 is not None: + _t1502 = None + return _t1502 + _t1503 = _t1501(msg) + guard_result927 = _t1503 + if guard_result927 is not None: self.pretty_minus(msg) else: - def _t1494(_dollar_dollar): + def _t1504(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1495 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1505 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1495 = None - return _t1495 - _t1496 = _t1494(msg) - guard_result921 = _t1496 - if guard_result921 is not None: + _t1505 = None + return _t1505 + _t1506 = _t1504(msg) + guard_result926 = _t1506 + if guard_result926 is not None: self.pretty_multiply(msg) else: - def _t1497(_dollar_dollar): + def _t1507(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1498 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1508 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1498 = None - return _t1498 - _t1499 = _t1497(msg) - guard_result920 = _t1499 - if guard_result920 is not None: + _t1508 = None + return _t1508 + _t1509 = _t1507(msg) + guard_result925 = _t1509 + if guard_result925 is not None: self.pretty_divide(msg) else: - def _t1500(_dollar_dollar): + def _t1510(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1501 = _t1500(msg) - fields914 = _t1501 - assert fields914 is not None - unwrapped_fields915 = fields914 + _t1511 = _t1510(msg) + fields919 = _t1511 + assert fields919 is not None + unwrapped_fields920 = fields919 self.write("(") self.write("primitive") self.indent_sexp() self.newline() - field916 = unwrapped_fields915[0] - self.pretty_name(field916) - field917 = unwrapped_fields915[1] - if not len(field917) == 0: + field921 = unwrapped_fields920[0] + self.pretty_name(field921) + field922 = unwrapped_fields920[1] + if not len(field922) == 0: self.newline() - for i919, elem918 in enumerate(field917): - if (i919 > 0): + for i924, elem923 in enumerate(field922): + if (i924 > 0): self.newline() - self.pretty_rel_term(elem918) + self.pretty_rel_term(elem923) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat934 = self._try_flat(msg, self.pretty_eq) - if flat934 is not None: - assert flat934 is not None - self.write(flat934) - return None - else: - def _t1502(_dollar_dollar): - if _dollar_dollar.name == "rel_primitive_eq": - _t1503 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1503 = None - return _t1503 - _t1504 = _t1502(msg) - fields930 = _t1504 - assert fields930 is not None - unwrapped_fields931 = fields930 - self.write("(") - self.write("=") - self.indent_sexp() - self.newline() - field932 = unwrapped_fields931[0] - self.pretty_term(field932) - self.newline() - field933 = unwrapped_fields931[1] - self.pretty_term(field933) - self.dedent() - self.write(")") - - def pretty_lt(self, msg: logic_pb2.Primitive): - flat939 = self._try_flat(msg, self.pretty_lt) + flat939 = self._try_flat(msg, self.pretty_eq) if flat939 is not None: assert flat939 is not None self.write(flat939) return None else: - def _t1505(_dollar_dollar): - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1506 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + def _t1512(_dollar_dollar): + if _dollar_dollar.name == "rel_primitive_eq": + _t1513 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1506 = None - return _t1506 - _t1507 = _t1505(msg) - fields935 = _t1507 + _t1513 = None + return _t1513 + _t1514 = _t1512(msg) + fields935 = _t1514 assert fields935 is not None unwrapped_fields936 = fields935 self.write("(") - self.write("<") + self.write("=") self.indent_sexp() self.newline() field937 = unwrapped_fields936[0] @@ -2037,25 +2008,25 @@ def _t1505(_dollar_dollar): self.dedent() self.write(")") - def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat944 = self._try_flat(msg, self.pretty_lt_eq) + def pretty_lt(self, msg: logic_pb2.Primitive): + flat944 = self._try_flat(msg, self.pretty_lt) if flat944 is not None: assert flat944 is not None self.write(flat944) return None else: - def _t1508(_dollar_dollar): - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1509 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + def _t1515(_dollar_dollar): + if _dollar_dollar.name == "rel_primitive_lt_monotype": + _t1516 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1509 = None - return _t1509 - _t1510 = _t1508(msg) - fields940 = _t1510 + _t1516 = None + return _t1516 + _t1517 = _t1515(msg) + fields940 = _t1517 assert fields940 is not None unwrapped_fields941 = fields940 self.write("(") - self.write("<=") + self.write("<") self.indent_sexp() self.newline() field942 = unwrapped_fields941[0] @@ -2066,25 +2037,25 @@ def _t1508(_dollar_dollar): self.dedent() self.write(")") - def pretty_gt(self, msg: logic_pb2.Primitive): - flat949 = self._try_flat(msg, self.pretty_gt) + def pretty_lt_eq(self, msg: logic_pb2.Primitive): + flat949 = self._try_flat(msg, self.pretty_lt_eq) if flat949 is not None: assert flat949 is not None self.write(flat949) return None else: - def _t1511(_dollar_dollar): - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1512 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + def _t1518(_dollar_dollar): + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": + _t1519 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1512 = None - return _t1512 - _t1513 = _t1511(msg) - fields945 = _t1513 + _t1519 = None + return _t1519 + _t1520 = _t1518(msg) + fields945 = _t1520 assert fields945 is not None unwrapped_fields946 = fields945 self.write("(") - self.write(">") + self.write("<=") self.indent_sexp() self.newline() field947 = unwrapped_fields946[0] @@ -2095,25 +2066,25 @@ def _t1511(_dollar_dollar): self.dedent() self.write(")") - def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat954 = self._try_flat(msg, self.pretty_gt_eq) + def pretty_gt(self, msg: logic_pb2.Primitive): + flat954 = self._try_flat(msg, self.pretty_gt) if flat954 is not None: assert flat954 is not None self.write(flat954) return None else: - def _t1514(_dollar_dollar): - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1515 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + def _t1521(_dollar_dollar): + if _dollar_dollar.name == "rel_primitive_gt_monotype": + _t1522 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1515 = None - return _t1515 - _t1516 = _t1514(msg) - fields950 = _t1516 + _t1522 = None + return _t1522 + _t1523 = _t1521(msg) + fields950 = _t1523 assert fields950 is not None unwrapped_fields951 = fields950 self.write("(") - self.write(">=") + self.write(">") self.indent_sexp() self.newline() field952 = unwrapped_fields951[0] @@ -2124,25 +2095,25 @@ def _t1514(_dollar_dollar): self.dedent() self.write(")") - def pretty_add(self, msg: logic_pb2.Primitive): - flat960 = self._try_flat(msg, self.pretty_add) - if flat960 is not None: - assert flat960 is not None - self.write(flat960) + def pretty_gt_eq(self, msg: logic_pb2.Primitive): + flat959 = self._try_flat(msg, self.pretty_gt_eq) + if flat959 is not None: + assert flat959 is not None + self.write(flat959) return None else: - def _t1517(_dollar_dollar): - if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1518 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + def _t1524(_dollar_dollar): + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": + _t1525 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1518 = None - return _t1518 - _t1519 = _t1517(msg) - fields955 = _t1519 + _t1525 = None + return _t1525 + _t1526 = _t1524(msg) + fields955 = _t1526 assert fields955 is not None unwrapped_fields956 = fields955 self.write("(") - self.write("+") + self.write(">=") self.indent_sexp() self.newline() field957 = unwrapped_fields956[0] @@ -2150,1697 +2121,1745 @@ def _t1517(_dollar_dollar): self.newline() field958 = unwrapped_fields956[1] self.pretty_term(field958) + self.dedent() + self.write(")") + + def pretty_add(self, msg: logic_pb2.Primitive): + flat965 = self._try_flat(msg, self.pretty_add) + if flat965 is not None: + assert flat965 is not None + self.write(flat965) + return None + else: + def _t1527(_dollar_dollar): + if _dollar_dollar.name == "rel_primitive_add_monotype": + _t1528 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + else: + _t1528 = None + return _t1528 + _t1529 = _t1527(msg) + fields960 = _t1529 + assert fields960 is not None + unwrapped_fields961 = fields960 + self.write("(") + self.write("+") + self.indent_sexp() + self.newline() + field962 = unwrapped_fields961[0] + self.pretty_term(field962) self.newline() - field959 = unwrapped_fields956[2] - self.pretty_term(field959) + field963 = unwrapped_fields961[1] + self.pretty_term(field963) + self.newline() + field964 = unwrapped_fields961[2] + self.pretty_term(field964) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat966 = self._try_flat(msg, self.pretty_minus) - if flat966 is not None: - assert flat966 is not None - self.write(flat966) + flat971 = self._try_flat(msg, self.pretty_minus) + if flat971 is not None: + assert flat971 is not None + self.write(flat971) return None else: - def _t1520(_dollar_dollar): + def _t1530(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1521 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1531 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1521 = None - return _t1521 - _t1522 = _t1520(msg) - fields961 = _t1522 - assert fields961 is not None - unwrapped_fields962 = fields961 + _t1531 = None + return _t1531 + _t1532 = _t1530(msg) + fields966 = _t1532 + assert fields966 is not None + unwrapped_fields967 = fields966 self.write("(") self.write("-") self.indent_sexp() self.newline() - field963 = unwrapped_fields962[0] - self.pretty_term(field963) + field968 = unwrapped_fields967[0] + self.pretty_term(field968) self.newline() - field964 = unwrapped_fields962[1] - self.pretty_term(field964) + field969 = unwrapped_fields967[1] + self.pretty_term(field969) self.newline() - field965 = unwrapped_fields962[2] - self.pretty_term(field965) + field970 = unwrapped_fields967[2] + self.pretty_term(field970) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat972 = self._try_flat(msg, self.pretty_multiply) - if flat972 is not None: - assert flat972 is not None - self.write(flat972) + flat977 = self._try_flat(msg, self.pretty_multiply) + if flat977 is not None: + assert flat977 is not None + self.write(flat977) return None else: - def _t1523(_dollar_dollar): + def _t1533(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1524 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1534 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1524 = None - return _t1524 - _t1525 = _t1523(msg) - fields967 = _t1525 - assert fields967 is not None - unwrapped_fields968 = fields967 + _t1534 = None + return _t1534 + _t1535 = _t1533(msg) + fields972 = _t1535 + assert fields972 is not None + unwrapped_fields973 = fields972 self.write("(") self.write("*") self.indent_sexp() self.newline() - field969 = unwrapped_fields968[0] - self.pretty_term(field969) + field974 = unwrapped_fields973[0] + self.pretty_term(field974) self.newline() - field970 = unwrapped_fields968[1] - self.pretty_term(field970) + field975 = unwrapped_fields973[1] + self.pretty_term(field975) self.newline() - field971 = unwrapped_fields968[2] - self.pretty_term(field971) + field976 = unwrapped_fields973[2] + self.pretty_term(field976) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat978 = self._try_flat(msg, self.pretty_divide) - if flat978 is not None: - assert flat978 is not None - self.write(flat978) + flat983 = self._try_flat(msg, self.pretty_divide) + if flat983 is not None: + assert flat983 is not None + self.write(flat983) return None else: - def _t1526(_dollar_dollar): + def _t1536(_dollar_dollar): if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1527 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1537 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1527 = None - return _t1527 - _t1528 = _t1526(msg) - fields973 = _t1528 - assert fields973 is not None - unwrapped_fields974 = fields973 + _t1537 = None + return _t1537 + _t1538 = _t1536(msg) + fields978 = _t1538 + assert fields978 is not None + unwrapped_fields979 = fields978 self.write("(") self.write("/") self.indent_sexp() self.newline() - field975 = unwrapped_fields974[0] - self.pretty_term(field975) + field980 = unwrapped_fields979[0] + self.pretty_term(field980) self.newline() - field976 = unwrapped_fields974[1] - self.pretty_term(field976) + field981 = unwrapped_fields979[1] + self.pretty_term(field981) self.newline() - field977 = unwrapped_fields974[2] - self.pretty_term(field977) + field982 = unwrapped_fields979[2] + self.pretty_term(field982) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat983 = self._try_flat(msg, self.pretty_rel_term) - if flat983 is not None: - assert flat983 is not None - self.write(flat983) + flat988 = self._try_flat(msg, self.pretty_rel_term) + if flat988 is not None: + assert flat988 is not None + self.write(flat988) return None else: - def _t1529(_dollar_dollar): + def _t1539(_dollar_dollar): if _dollar_dollar.HasField("specialized_value"): - _t1530 = _dollar_dollar.specialized_value + _t1540 = _dollar_dollar.specialized_value else: - _t1530 = None - return _t1530 - _t1531 = _t1529(msg) - deconstruct_result981 = _t1531 - if deconstruct_result981 is not None: - assert deconstruct_result981 is not None - unwrapped982 = deconstruct_result981 - self.pretty_specialized_value(unwrapped982) + _t1540 = None + return _t1540 + _t1541 = _t1539(msg) + deconstruct_result986 = _t1541 + if deconstruct_result986 is not None: + assert deconstruct_result986 is not None + unwrapped987 = deconstruct_result986 + self.pretty_specialized_value(unwrapped987) else: - def _t1532(_dollar_dollar): + def _t1542(_dollar_dollar): if _dollar_dollar.HasField("term"): - _t1533 = _dollar_dollar.term + _t1543 = _dollar_dollar.term else: - _t1533 = None - return _t1533 - _t1534 = _t1532(msg) - deconstruct_result979 = _t1534 - if deconstruct_result979 is not None: - assert deconstruct_result979 is not None - unwrapped980 = deconstruct_result979 - self.pretty_term(unwrapped980) + _t1543 = None + return _t1543 + _t1544 = _t1542(msg) + deconstruct_result984 = _t1544 + if deconstruct_result984 is not None: + assert deconstruct_result984 is not None + unwrapped985 = deconstruct_result984 + self.pretty_term(unwrapped985) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat985 = self._try_flat(msg, self.pretty_specialized_value) - if flat985 is not None: - assert flat985 is not None - self.write(flat985) + flat990 = self._try_flat(msg, self.pretty_specialized_value) + if flat990 is not None: + assert flat990 is not None + self.write(flat990) return None else: - fields984 = msg + fields989 = msg self.write("#") - self.pretty_value(fields984) + self.pretty_value(fields989) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat992 = self._try_flat(msg, self.pretty_rel_atom) - if flat992 is not None: - assert flat992 is not None - self.write(flat992) + flat997 = self._try_flat(msg, self.pretty_rel_atom) + if flat997 is not None: + assert flat997 is not None + self.write(flat997) return None else: - def _t1535(_dollar_dollar): + def _t1545(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.terms,) - _t1536 = _t1535(msg) - fields986 = _t1536 - assert fields986 is not None - unwrapped_fields987 = fields986 + _t1546 = _t1545(msg) + fields991 = _t1546 + assert fields991 is not None + unwrapped_fields992 = fields991 self.write("(") self.write("relatom") self.indent_sexp() self.newline() - field988 = unwrapped_fields987[0] - self.pretty_name(field988) - field989 = unwrapped_fields987[1] - if not len(field989) == 0: + field993 = unwrapped_fields992[0] + self.pretty_name(field993) + field994 = unwrapped_fields992[1] + if not len(field994) == 0: self.newline() - for i991, elem990 in enumerate(field989): - if (i991 > 0): + for i996, elem995 in enumerate(field994): + if (i996 > 0): self.newline() - self.pretty_rel_term(elem990) + self.pretty_rel_term(elem995) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat997 = self._try_flat(msg, self.pretty_cast) - if flat997 is not None: - assert flat997 is not None - self.write(flat997) + flat1002 = self._try_flat(msg, self.pretty_cast) + if flat1002 is not None: + assert flat1002 is not None + self.write(flat1002) return None else: - def _t1537(_dollar_dollar): + def _t1547(_dollar_dollar): return (_dollar_dollar.input, _dollar_dollar.result,) - _t1538 = _t1537(msg) - fields993 = _t1538 - assert fields993 is not None - unwrapped_fields994 = fields993 + _t1548 = _t1547(msg) + fields998 = _t1548 + assert fields998 is not None + unwrapped_fields999 = fields998 self.write("(") self.write("cast") self.indent_sexp() self.newline() - field995 = unwrapped_fields994[0] - self.pretty_term(field995) + field1000 = unwrapped_fields999[0] + self.pretty_term(field1000) self.newline() - field996 = unwrapped_fields994[1] - self.pretty_term(field996) + field1001 = unwrapped_fields999[1] + self.pretty_term(field1001) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1001 = self._try_flat(msg, self.pretty_attrs) - if flat1001 is not None: - assert flat1001 is not None - self.write(flat1001) + flat1006 = self._try_flat(msg, self.pretty_attrs) + if flat1006 is not None: + assert flat1006 is not None + self.write(flat1006) return None else: - fields998 = msg + fields1003 = msg self.write("(") self.write("attrs") self.indent_sexp() - if not len(fields998) == 0: + if not len(fields1003) == 0: self.newline() - for i1000, elem999 in enumerate(fields998): - if (i1000 > 0): + for i1005, elem1004 in enumerate(fields1003): + if (i1005 > 0): self.newline() - self.pretty_attribute(elem999) + self.pretty_attribute(elem1004) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1008 = self._try_flat(msg, self.pretty_attribute) - if flat1008 is not None: - assert flat1008 is not None - self.write(flat1008) + flat1013 = self._try_flat(msg, self.pretty_attribute) + if flat1013 is not None: + assert flat1013 is not None + self.write(flat1013) return None else: - def _t1539(_dollar_dollar): + def _t1549(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.args,) - _t1540 = _t1539(msg) - fields1002 = _t1540 - assert fields1002 is not None - unwrapped_fields1003 = fields1002 + _t1550 = _t1549(msg) + fields1007 = _t1550 + assert fields1007 is not None + unwrapped_fields1008 = fields1007 self.write("(") self.write("attribute") self.indent_sexp() self.newline() - field1004 = unwrapped_fields1003[0] - self.pretty_name(field1004) - field1005 = unwrapped_fields1003[1] - if not len(field1005) == 0: + field1009 = unwrapped_fields1008[0] + self.pretty_name(field1009) + field1010 = unwrapped_fields1008[1] + if not len(field1010) == 0: self.newline() - for i1007, elem1006 in enumerate(field1005): - if (i1007 > 0): + for i1012, elem1011 in enumerate(field1010): + if (i1012 > 0): self.newline() - self.pretty_value(elem1006) + self.pretty_value(elem1011) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1015 = self._try_flat(msg, self.pretty_algorithm) - if flat1015 is not None: - assert flat1015 is not None - self.write(flat1015) + flat1020 = self._try_flat(msg, self.pretty_algorithm) + if flat1020 is not None: + assert flat1020 is not None + self.write(flat1020) return None else: - def _t1541(_dollar_dollar): + def _t1551(_dollar_dollar): return (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,) - _t1542 = _t1541(msg) - fields1009 = _t1542 - assert fields1009 is not None - unwrapped_fields1010 = fields1009 + _t1552 = _t1551(msg) + fields1014 = _t1552 + assert fields1014 is not None + unwrapped_fields1015 = fields1014 self.write("(") self.write("algorithm") self.indent_sexp() - field1011 = unwrapped_fields1010[0] - if not len(field1011) == 0: + field1016 = unwrapped_fields1015[0] + if not len(field1016) == 0: self.newline() - for i1013, elem1012 in enumerate(field1011): - if (i1013 > 0): + for i1018, elem1017 in enumerate(field1016): + if (i1018 > 0): self.newline() - self.pretty_relation_id(elem1012) + self.pretty_relation_id(elem1017) self.newline() - field1014 = unwrapped_fields1010[1] - self.pretty_script(field1014) + field1019 = unwrapped_fields1015[1] + self.pretty_script(field1019) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1020 = self._try_flat(msg, self.pretty_script) - if flat1020 is not None: - assert flat1020 is not None - self.write(flat1020) + flat1025 = self._try_flat(msg, self.pretty_script) + if flat1025 is not None: + assert flat1025 is not None + self.write(flat1025) return None else: - def _t1543(_dollar_dollar): + def _t1553(_dollar_dollar): return _dollar_dollar.constructs - _t1544 = _t1543(msg) - fields1016 = _t1544 - assert fields1016 is not None - unwrapped_fields1017 = fields1016 + _t1554 = _t1553(msg) + fields1021 = _t1554 + assert fields1021 is not None + unwrapped_fields1022 = fields1021 self.write("(") self.write("script") self.indent_sexp() - if not len(unwrapped_fields1017) == 0: + if not len(unwrapped_fields1022) == 0: self.newline() - for i1019, elem1018 in enumerate(unwrapped_fields1017): - if (i1019 > 0): + for i1024, elem1023 in enumerate(unwrapped_fields1022): + if (i1024 > 0): self.newline() - self.pretty_construct(elem1018) + self.pretty_construct(elem1023) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1025 = self._try_flat(msg, self.pretty_construct) - if flat1025 is not None: - assert flat1025 is not None - self.write(flat1025) + flat1030 = self._try_flat(msg, self.pretty_construct) + if flat1030 is not None: + assert flat1030 is not None + self.write(flat1030) return None else: - def _t1545(_dollar_dollar): + def _t1555(_dollar_dollar): if _dollar_dollar.HasField("loop"): - _t1546 = _dollar_dollar.loop + _t1556 = _dollar_dollar.loop else: - _t1546 = None - return _t1546 - _t1547 = _t1545(msg) - deconstruct_result1023 = _t1547 - if deconstruct_result1023 is not None: - assert deconstruct_result1023 is not None - unwrapped1024 = deconstruct_result1023 - self.pretty_loop(unwrapped1024) + _t1556 = None + return _t1556 + _t1557 = _t1555(msg) + deconstruct_result1028 = _t1557 + if deconstruct_result1028 is not None: + assert deconstruct_result1028 is not None + unwrapped1029 = deconstruct_result1028 + self.pretty_loop(unwrapped1029) else: - def _t1548(_dollar_dollar): + def _t1558(_dollar_dollar): if _dollar_dollar.HasField("instruction"): - _t1549 = _dollar_dollar.instruction + _t1559 = _dollar_dollar.instruction else: - _t1549 = None - return _t1549 - _t1550 = _t1548(msg) - deconstruct_result1021 = _t1550 - if deconstruct_result1021 is not None: - assert deconstruct_result1021 is not None - unwrapped1022 = deconstruct_result1021 - self.pretty_instruction(unwrapped1022) + _t1559 = None + return _t1559 + _t1560 = _t1558(msg) + deconstruct_result1026 = _t1560 + if deconstruct_result1026 is not None: + assert deconstruct_result1026 is not None + unwrapped1027 = deconstruct_result1026 + self.pretty_instruction(unwrapped1027) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1030 = self._try_flat(msg, self.pretty_loop) - if flat1030 is not None: - assert flat1030 is not None - self.write(flat1030) + flat1035 = self._try_flat(msg, self.pretty_loop) + if flat1035 is not None: + assert flat1035 is not None + self.write(flat1035) return None else: - def _t1551(_dollar_dollar): + def _t1561(_dollar_dollar): return (_dollar_dollar.init, _dollar_dollar.body,) - _t1552 = _t1551(msg) - fields1026 = _t1552 - assert fields1026 is not None - unwrapped_fields1027 = fields1026 + _t1562 = _t1561(msg) + fields1031 = _t1562 + assert fields1031 is not None + unwrapped_fields1032 = fields1031 self.write("(") self.write("loop") self.indent_sexp() self.newline() - field1028 = unwrapped_fields1027[0] - self.pretty_init(field1028) + field1033 = unwrapped_fields1032[0] + self.pretty_init(field1033) self.newline() - field1029 = unwrapped_fields1027[1] - self.pretty_script(field1029) + field1034 = unwrapped_fields1032[1] + self.pretty_script(field1034) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1034 = self._try_flat(msg, self.pretty_init) - if flat1034 is not None: - assert flat1034 is not None - self.write(flat1034) + flat1039 = self._try_flat(msg, self.pretty_init) + if flat1039 is not None: + assert flat1039 is not None + self.write(flat1039) return None else: - fields1031 = msg + fields1036 = msg self.write("(") self.write("init") self.indent_sexp() - if not len(fields1031) == 0: + if not len(fields1036) == 0: self.newline() - for i1033, elem1032 in enumerate(fields1031): - if (i1033 > 0): + for i1038, elem1037 in enumerate(fields1036): + if (i1038 > 0): self.newline() - self.pretty_instruction(elem1032) + self.pretty_instruction(elem1037) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1045 = self._try_flat(msg, self.pretty_instruction) - if flat1045 is not None: - assert flat1045 is not None - self.write(flat1045) + flat1050 = self._try_flat(msg, self.pretty_instruction) + if flat1050 is not None: + assert flat1050 is not None + self.write(flat1050) return None else: - def _t1553(_dollar_dollar): + def _t1563(_dollar_dollar): if _dollar_dollar.HasField("assign"): - _t1554 = _dollar_dollar.assign + _t1564 = _dollar_dollar.assign else: - _t1554 = None - return _t1554 - _t1555 = _t1553(msg) - deconstruct_result1043 = _t1555 - if deconstruct_result1043 is not None: - assert deconstruct_result1043 is not None - unwrapped1044 = deconstruct_result1043 - self.pretty_assign(unwrapped1044) + _t1564 = None + return _t1564 + _t1565 = _t1563(msg) + deconstruct_result1048 = _t1565 + if deconstruct_result1048 is not None: + assert deconstruct_result1048 is not None + unwrapped1049 = deconstruct_result1048 + self.pretty_assign(unwrapped1049) else: - def _t1556(_dollar_dollar): + def _t1566(_dollar_dollar): if _dollar_dollar.HasField("upsert"): - _t1557 = _dollar_dollar.upsert + _t1567 = _dollar_dollar.upsert else: - _t1557 = None - return _t1557 - _t1558 = _t1556(msg) - deconstruct_result1041 = _t1558 - if deconstruct_result1041 is not None: - assert deconstruct_result1041 is not None - unwrapped1042 = deconstruct_result1041 - self.pretty_upsert(unwrapped1042) + _t1567 = None + return _t1567 + _t1568 = _t1566(msg) + deconstruct_result1046 = _t1568 + if deconstruct_result1046 is not None: + assert deconstruct_result1046 is not None + unwrapped1047 = deconstruct_result1046 + self.pretty_upsert(unwrapped1047) else: - def _t1559(_dollar_dollar): + def _t1569(_dollar_dollar): if _dollar_dollar.HasField("break"): - _t1560 = getattr(_dollar_dollar, 'break') + _t1570 = getattr(_dollar_dollar, 'break') else: - _t1560 = None - return _t1560 - _t1561 = _t1559(msg) - deconstruct_result1039 = _t1561 - if deconstruct_result1039 is not None: - assert deconstruct_result1039 is not None - unwrapped1040 = deconstruct_result1039 - self.pretty_break(unwrapped1040) + _t1570 = None + return _t1570 + _t1571 = _t1569(msg) + deconstruct_result1044 = _t1571 + if deconstruct_result1044 is not None: + assert deconstruct_result1044 is not None + unwrapped1045 = deconstruct_result1044 + self.pretty_break(unwrapped1045) else: - def _t1562(_dollar_dollar): + def _t1572(_dollar_dollar): if _dollar_dollar.HasField("monoid_def"): - _t1563 = _dollar_dollar.monoid_def + _t1573 = _dollar_dollar.monoid_def else: - _t1563 = None - return _t1563 - _t1564 = _t1562(msg) - deconstruct_result1037 = _t1564 - if deconstruct_result1037 is not None: - assert deconstruct_result1037 is not None - unwrapped1038 = deconstruct_result1037 - self.pretty_monoid_def(unwrapped1038) + _t1573 = None + return _t1573 + _t1574 = _t1572(msg) + deconstruct_result1042 = _t1574 + if deconstruct_result1042 is not None: + assert deconstruct_result1042 is not None + unwrapped1043 = deconstruct_result1042 + self.pretty_monoid_def(unwrapped1043) else: - def _t1565(_dollar_dollar): + def _t1575(_dollar_dollar): if _dollar_dollar.HasField("monus_def"): - _t1566 = _dollar_dollar.monus_def + _t1576 = _dollar_dollar.monus_def else: - _t1566 = None - return _t1566 - _t1567 = _t1565(msg) - deconstruct_result1035 = _t1567 - if deconstruct_result1035 is not None: - assert deconstruct_result1035 is not None - unwrapped1036 = deconstruct_result1035 - self.pretty_monus_def(unwrapped1036) + _t1576 = None + return _t1576 + _t1577 = _t1575(msg) + deconstruct_result1040 = _t1577 + if deconstruct_result1040 is not None: + assert deconstruct_result1040 is not None + unwrapped1041 = deconstruct_result1040 + self.pretty_monus_def(unwrapped1041) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1052 = self._try_flat(msg, self.pretty_assign) - if flat1052 is not None: - assert flat1052 is not None - self.write(flat1052) + flat1057 = self._try_flat(msg, self.pretty_assign) + if flat1057 is not None: + assert flat1057 is not None + self.write(flat1057) return None else: - def _t1568(_dollar_dollar): + def _t1578(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1569 = _dollar_dollar.attrs + _t1579 = _dollar_dollar.attrs else: - _t1569 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1569,) - _t1570 = _t1568(msg) - fields1046 = _t1570 - assert fields1046 is not None - unwrapped_fields1047 = fields1046 + _t1579 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1579,) + _t1580 = _t1578(msg) + fields1051 = _t1580 + assert fields1051 is not None + unwrapped_fields1052 = fields1051 self.write("(") self.write("assign") self.indent_sexp() self.newline() - field1048 = unwrapped_fields1047[0] - self.pretty_relation_id(field1048) + field1053 = unwrapped_fields1052[0] + self.pretty_relation_id(field1053) self.newline() - field1049 = unwrapped_fields1047[1] - self.pretty_abstraction(field1049) - field1050 = unwrapped_fields1047[2] - if field1050 is not None: + field1054 = unwrapped_fields1052[1] + self.pretty_abstraction(field1054) + field1055 = unwrapped_fields1052[2] + if field1055 is not None: self.newline() - assert field1050 is not None - opt_val1051 = field1050 - self.pretty_attrs(opt_val1051) + assert field1055 is not None + opt_val1056 = field1055 + self.pretty_attrs(opt_val1056) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1059 = self._try_flat(msg, self.pretty_upsert) - if flat1059 is not None: - assert flat1059 is not None - self.write(flat1059) + flat1064 = self._try_flat(msg, self.pretty_upsert) + if flat1064 is not None: + assert flat1064 is not None + self.write(flat1064) return None else: - def _t1571(_dollar_dollar): + def _t1581(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1572 = _dollar_dollar.attrs + _t1582 = _dollar_dollar.attrs else: - _t1572 = None - return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1572,) - _t1573 = _t1571(msg) - fields1053 = _t1573 - assert fields1053 is not None - unwrapped_fields1054 = fields1053 + _t1582 = None + return (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1582,) + _t1583 = _t1581(msg) + fields1058 = _t1583 + assert fields1058 is not None + unwrapped_fields1059 = fields1058 self.write("(") self.write("upsert") self.indent_sexp() self.newline() - field1055 = unwrapped_fields1054[0] - self.pretty_relation_id(field1055) + field1060 = unwrapped_fields1059[0] + self.pretty_relation_id(field1060) self.newline() - field1056 = unwrapped_fields1054[1] - self.pretty_abstraction_with_arity(field1056) - field1057 = unwrapped_fields1054[2] - if field1057 is not None: + field1061 = unwrapped_fields1059[1] + self.pretty_abstraction_with_arity(field1061) + field1062 = unwrapped_fields1059[2] + if field1062 is not None: self.newline() - assert field1057 is not None - opt_val1058 = field1057 - self.pretty_attrs(opt_val1058) + assert field1062 is not None + opt_val1063 = field1062 + self.pretty_attrs(opt_val1063) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1064 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1064 is not None: - assert flat1064 is not None - self.write(flat1064) + flat1069 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1069 is not None: + assert flat1069 is not None + self.write(flat1069) return None else: - def _t1574(_dollar_dollar): - _t1575 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - return (_t1575, _dollar_dollar[0].value,) - _t1576 = _t1574(msg) - fields1060 = _t1576 - assert fields1060 is not None - unwrapped_fields1061 = fields1060 + def _t1584(_dollar_dollar): + _t1585 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + return (_t1585, _dollar_dollar[0].value,) + _t1586 = _t1584(msg) + fields1065 = _t1586 + assert fields1065 is not None + unwrapped_fields1066 = fields1065 self.write("(") self.indent() - field1062 = unwrapped_fields1061[0] - self.pretty_bindings(field1062) + field1067 = unwrapped_fields1066[0] + self.pretty_bindings(field1067) self.newline() - field1063 = unwrapped_fields1061[1] - self.pretty_formula(field1063) + field1068 = unwrapped_fields1066[1] + self.pretty_formula(field1068) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1071 = self._try_flat(msg, self.pretty_break) - if flat1071 is not None: - assert flat1071 is not None - self.write(flat1071) + flat1076 = self._try_flat(msg, self.pretty_break) + if flat1076 is not None: + assert flat1076 is not None + self.write(flat1076) return None else: - def _t1577(_dollar_dollar): + def _t1587(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1578 = _dollar_dollar.attrs + _t1588 = _dollar_dollar.attrs else: - _t1578 = None - return (_dollar_dollar.name, _dollar_dollar.body, _t1578,) - _t1579 = _t1577(msg) - fields1065 = _t1579 - assert fields1065 is not None - unwrapped_fields1066 = fields1065 + _t1588 = None + return (_dollar_dollar.name, _dollar_dollar.body, _t1588,) + _t1589 = _t1587(msg) + fields1070 = _t1589 + assert fields1070 is not None + unwrapped_fields1071 = fields1070 self.write("(") self.write("break") self.indent_sexp() self.newline() - field1067 = unwrapped_fields1066[0] - self.pretty_relation_id(field1067) + field1072 = unwrapped_fields1071[0] + self.pretty_relation_id(field1072) self.newline() - field1068 = unwrapped_fields1066[1] - self.pretty_abstraction(field1068) - field1069 = unwrapped_fields1066[2] - if field1069 is not None: + field1073 = unwrapped_fields1071[1] + self.pretty_abstraction(field1073) + field1074 = unwrapped_fields1071[2] + if field1074 is not None: self.newline() - assert field1069 is not None - opt_val1070 = field1069 - self.pretty_attrs(opt_val1070) + assert field1074 is not None + opt_val1075 = field1074 + self.pretty_attrs(opt_val1075) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1079 = self._try_flat(msg, self.pretty_monoid_def) - if flat1079 is not None: - assert flat1079 is not None - self.write(flat1079) + flat1084 = self._try_flat(msg, self.pretty_monoid_def) + if flat1084 is not None: + assert flat1084 is not None + self.write(flat1084) return None else: - def _t1580(_dollar_dollar): + def _t1590(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1581 = _dollar_dollar.attrs + _t1591 = _dollar_dollar.attrs else: - _t1581 = None - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1581,) - _t1582 = _t1580(msg) - fields1072 = _t1582 - assert fields1072 is not None - unwrapped_fields1073 = fields1072 + _t1591 = None + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1591,) + _t1592 = _t1590(msg) + fields1077 = _t1592 + assert fields1077 is not None + unwrapped_fields1078 = fields1077 self.write("(") self.write("monoid") self.indent_sexp() self.newline() - field1074 = unwrapped_fields1073[0] - self.pretty_monoid(field1074) + field1079 = unwrapped_fields1078[0] + self.pretty_monoid(field1079) self.newline() - field1075 = unwrapped_fields1073[1] - self.pretty_relation_id(field1075) + field1080 = unwrapped_fields1078[1] + self.pretty_relation_id(field1080) self.newline() - field1076 = unwrapped_fields1073[2] - self.pretty_abstraction_with_arity(field1076) - field1077 = unwrapped_fields1073[3] - if field1077 is not None: + field1081 = unwrapped_fields1078[2] + self.pretty_abstraction_with_arity(field1081) + field1082 = unwrapped_fields1078[3] + if field1082 is not None: self.newline() - assert field1077 is not None - opt_val1078 = field1077 - self.pretty_attrs(opt_val1078) + assert field1082 is not None + opt_val1083 = field1082 + self.pretty_attrs(opt_val1083) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1088 = self._try_flat(msg, self.pretty_monoid) - if flat1088 is not None: - assert flat1088 is not None - self.write(flat1088) + flat1093 = self._try_flat(msg, self.pretty_monoid) + if flat1093 is not None: + assert flat1093 is not None + self.write(flat1093) return None else: - def _t1583(_dollar_dollar): + def _t1593(_dollar_dollar): if _dollar_dollar.HasField("or_monoid"): - _t1584 = _dollar_dollar.or_monoid + _t1594 = _dollar_dollar.or_monoid else: - _t1584 = None - return _t1584 - _t1585 = _t1583(msg) - deconstruct_result1086 = _t1585 - if deconstruct_result1086 is not None: - assert deconstruct_result1086 is not None - unwrapped1087 = deconstruct_result1086 - self.pretty_or_monoid(unwrapped1087) + _t1594 = None + return _t1594 + _t1595 = _t1593(msg) + deconstruct_result1091 = _t1595 + if deconstruct_result1091 is not None: + assert deconstruct_result1091 is not None + unwrapped1092 = deconstruct_result1091 + self.pretty_or_monoid(unwrapped1092) else: - def _t1586(_dollar_dollar): + def _t1596(_dollar_dollar): if _dollar_dollar.HasField("min_monoid"): - _t1587 = _dollar_dollar.min_monoid + _t1597 = _dollar_dollar.min_monoid else: - _t1587 = None - return _t1587 - _t1588 = _t1586(msg) - deconstruct_result1084 = _t1588 - if deconstruct_result1084 is not None: - assert deconstruct_result1084 is not None - unwrapped1085 = deconstruct_result1084 - self.pretty_min_monoid(unwrapped1085) + _t1597 = None + return _t1597 + _t1598 = _t1596(msg) + deconstruct_result1089 = _t1598 + if deconstruct_result1089 is not None: + assert deconstruct_result1089 is not None + unwrapped1090 = deconstruct_result1089 + self.pretty_min_monoid(unwrapped1090) else: - def _t1589(_dollar_dollar): + def _t1599(_dollar_dollar): if _dollar_dollar.HasField("max_monoid"): - _t1590 = _dollar_dollar.max_monoid + _t1600 = _dollar_dollar.max_monoid else: - _t1590 = None - return _t1590 - _t1591 = _t1589(msg) - deconstruct_result1082 = _t1591 - if deconstruct_result1082 is not None: - assert deconstruct_result1082 is not None - unwrapped1083 = deconstruct_result1082 - self.pretty_max_monoid(unwrapped1083) + _t1600 = None + return _t1600 + _t1601 = _t1599(msg) + deconstruct_result1087 = _t1601 + if deconstruct_result1087 is not None: + assert deconstruct_result1087 is not None + unwrapped1088 = deconstruct_result1087 + self.pretty_max_monoid(unwrapped1088) else: - def _t1592(_dollar_dollar): + def _t1602(_dollar_dollar): if _dollar_dollar.HasField("sum_monoid"): - _t1593 = _dollar_dollar.sum_monoid + _t1603 = _dollar_dollar.sum_monoid else: - _t1593 = None - return _t1593 - _t1594 = _t1592(msg) - deconstruct_result1080 = _t1594 - if deconstruct_result1080 is not None: - assert deconstruct_result1080 is not None - unwrapped1081 = deconstruct_result1080 - self.pretty_sum_monoid(unwrapped1081) + _t1603 = None + return _t1603 + _t1604 = _t1602(msg) + deconstruct_result1085 = _t1604 + if deconstruct_result1085 is not None: + assert deconstruct_result1085 is not None + unwrapped1086 = deconstruct_result1085 + self.pretty_sum_monoid(unwrapped1086) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1089 = msg + fields1094 = msg self.write("(") self.write("or") self.write(")") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1092 = self._try_flat(msg, self.pretty_min_monoid) - if flat1092 is not None: - assert flat1092 is not None - self.write(flat1092) + flat1097 = self._try_flat(msg, self.pretty_min_monoid) + if flat1097 is not None: + assert flat1097 is not None + self.write(flat1097) return None else: - def _t1595(_dollar_dollar): + def _t1605(_dollar_dollar): return _dollar_dollar.type - _t1596 = _t1595(msg) - fields1090 = _t1596 - assert fields1090 is not None - unwrapped_fields1091 = fields1090 + _t1606 = _t1605(msg) + fields1095 = _t1606 + assert fields1095 is not None + unwrapped_fields1096 = fields1095 self.write("(") self.write("min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1091) + self.pretty_type(unwrapped_fields1096) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1095 = self._try_flat(msg, self.pretty_max_monoid) - if flat1095 is not None: - assert flat1095 is not None - self.write(flat1095) + flat1100 = self._try_flat(msg, self.pretty_max_monoid) + if flat1100 is not None: + assert flat1100 is not None + self.write(flat1100) return None else: - def _t1597(_dollar_dollar): + def _t1607(_dollar_dollar): return _dollar_dollar.type - _t1598 = _t1597(msg) - fields1093 = _t1598 - assert fields1093 is not None - unwrapped_fields1094 = fields1093 + _t1608 = _t1607(msg) + fields1098 = _t1608 + assert fields1098 is not None + unwrapped_fields1099 = fields1098 self.write("(") self.write("max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1094) + self.pretty_type(unwrapped_fields1099) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1098 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1098 is not None: - assert flat1098 is not None - self.write(flat1098) + flat1103 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1103 is not None: + assert flat1103 is not None + self.write(flat1103) return None else: - def _t1599(_dollar_dollar): + def _t1609(_dollar_dollar): return _dollar_dollar.type - _t1600 = _t1599(msg) - fields1096 = _t1600 - assert fields1096 is not None - unwrapped_fields1097 = fields1096 + _t1610 = _t1609(msg) + fields1101 = _t1610 + assert fields1101 is not None + unwrapped_fields1102 = fields1101 self.write("(") self.write("sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1097) + self.pretty_type(unwrapped_fields1102) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1106 = self._try_flat(msg, self.pretty_monus_def) - if flat1106 is not None: - assert flat1106 is not None - self.write(flat1106) + flat1111 = self._try_flat(msg, self.pretty_monus_def) + if flat1111 is not None: + assert flat1111 is not None + self.write(flat1111) return None else: - def _t1601(_dollar_dollar): + def _t1611(_dollar_dollar): if not len(_dollar_dollar.attrs) == 0: - _t1602 = _dollar_dollar.attrs + _t1612 = _dollar_dollar.attrs else: - _t1602 = None - return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1602,) - _t1603 = _t1601(msg) - fields1099 = _t1603 - assert fields1099 is not None - unwrapped_fields1100 = fields1099 + _t1612 = None + return (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1612,) + _t1613 = _t1611(msg) + fields1104 = _t1613 + assert fields1104 is not None + unwrapped_fields1105 = fields1104 self.write("(") self.write("monus") self.indent_sexp() self.newline() - field1101 = unwrapped_fields1100[0] - self.pretty_monoid(field1101) + field1106 = unwrapped_fields1105[0] + self.pretty_monoid(field1106) self.newline() - field1102 = unwrapped_fields1100[1] - self.pretty_relation_id(field1102) + field1107 = unwrapped_fields1105[1] + self.pretty_relation_id(field1107) self.newline() - field1103 = unwrapped_fields1100[2] - self.pretty_abstraction_with_arity(field1103) - field1104 = unwrapped_fields1100[3] - if field1104 is not None: + field1108 = unwrapped_fields1105[2] + self.pretty_abstraction_with_arity(field1108) + field1109 = unwrapped_fields1105[3] + if field1109 is not None: self.newline() - assert field1104 is not None - opt_val1105 = field1104 - self.pretty_attrs(opt_val1105) + assert field1109 is not None + opt_val1110 = field1109 + self.pretty_attrs(opt_val1110) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1113 = self._try_flat(msg, self.pretty_constraint) - if flat1113 is not None: - assert flat1113 is not None - self.write(flat1113) + flat1118 = self._try_flat(msg, self.pretty_constraint) + if flat1118 is not None: + assert flat1118 is not None + self.write(flat1118) return None else: - def _t1604(_dollar_dollar): + def _t1614(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - _t1605 = _t1604(msg) - fields1107 = _t1605 - assert fields1107 is not None - unwrapped_fields1108 = fields1107 + _t1615 = _t1614(msg) + fields1112 = _t1615 + assert fields1112 is not None + unwrapped_fields1113 = fields1112 self.write("(") self.write("functional_dependency") self.indent_sexp() self.newline() - field1109 = unwrapped_fields1108[0] - self.pretty_relation_id(field1109) + field1114 = unwrapped_fields1113[0] + self.pretty_relation_id(field1114) self.newline() - field1110 = unwrapped_fields1108[1] - self.pretty_abstraction(field1110) + field1115 = unwrapped_fields1113[1] + self.pretty_abstraction(field1115) self.newline() - field1111 = unwrapped_fields1108[2] - self.pretty_functional_dependency_keys(field1111) + field1116 = unwrapped_fields1113[2] + self.pretty_functional_dependency_keys(field1116) self.newline() - field1112 = unwrapped_fields1108[3] - self.pretty_functional_dependency_values(field1112) + field1117 = unwrapped_fields1113[3] + self.pretty_functional_dependency_values(field1117) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1117 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1117 is not None: - assert flat1117 is not None - self.write(flat1117) + flat1122 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1122 is not None: + assert flat1122 is not None + self.write(flat1122) return None else: - fields1114 = msg + fields1119 = msg self.write("(") self.write("keys") self.indent_sexp() - if not len(fields1114) == 0: + if not len(fields1119) == 0: self.newline() - for i1116, elem1115 in enumerate(fields1114): - if (i1116 > 0): + for i1121, elem1120 in enumerate(fields1119): + if (i1121 > 0): self.newline() - self.pretty_var(elem1115) + self.pretty_var(elem1120) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1121 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1121 is not None: - assert flat1121 is not None - self.write(flat1121) + flat1126 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1126 is not None: + assert flat1126 is not None + self.write(flat1126) return None else: - fields1118 = msg + fields1123 = msg self.write("(") self.write("values") self.indent_sexp() - if not len(fields1118) == 0: + if not len(fields1123) == 0: self.newline() - for i1120, elem1119 in enumerate(fields1118): - if (i1120 > 0): + for i1125, elem1124 in enumerate(fields1123): + if (i1125 > 0): self.newline() - self.pretty_var(elem1119) + self.pretty_var(elem1124) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1128 = self._try_flat(msg, self.pretty_data) - if flat1128 is not None: - assert flat1128 is not None - self.write(flat1128) + flat1133 = self._try_flat(msg, self.pretty_data) + if flat1133 is not None: + assert flat1133 is not None + self.write(flat1133) return None else: - def _t1606(_dollar_dollar): + def _t1616(_dollar_dollar): if _dollar_dollar.HasField("edb"): - _t1607 = _dollar_dollar.edb + _t1617 = _dollar_dollar.edb else: - _t1607 = None - return _t1607 - _t1608 = _t1606(msg) - deconstruct_result1126 = _t1608 - if deconstruct_result1126 is not None: - assert deconstruct_result1126 is not None - unwrapped1127 = deconstruct_result1126 - self.pretty_edb(unwrapped1127) + _t1617 = None + return _t1617 + _t1618 = _t1616(msg) + deconstruct_result1131 = _t1618 + if deconstruct_result1131 is not None: + assert deconstruct_result1131 is not None + unwrapped1132 = deconstruct_result1131 + self.pretty_edb(unwrapped1132) else: - def _t1609(_dollar_dollar): + def _t1619(_dollar_dollar): if _dollar_dollar.HasField("betree_relation"): - _t1610 = _dollar_dollar.betree_relation + _t1620 = _dollar_dollar.betree_relation else: - _t1610 = None - return _t1610 - _t1611 = _t1609(msg) - deconstruct_result1124 = _t1611 - if deconstruct_result1124 is not None: - assert deconstruct_result1124 is not None - unwrapped1125 = deconstruct_result1124 - self.pretty_betree_relation(unwrapped1125) + _t1620 = None + return _t1620 + _t1621 = _t1619(msg) + deconstruct_result1129 = _t1621 + if deconstruct_result1129 is not None: + assert deconstruct_result1129 is not None + unwrapped1130 = deconstruct_result1129 + self.pretty_betree_relation(unwrapped1130) else: - def _t1612(_dollar_dollar): + def _t1622(_dollar_dollar): if _dollar_dollar.HasField("csv_data"): - _t1613 = _dollar_dollar.csv_data + _t1623 = _dollar_dollar.csv_data else: - _t1613 = None - return _t1613 - _t1614 = _t1612(msg) - deconstruct_result1122 = _t1614 - if deconstruct_result1122 is not None: - assert deconstruct_result1122 is not None - unwrapped1123 = deconstruct_result1122 - self.pretty_csv_data(unwrapped1123) + _t1623 = None + return _t1623 + _t1624 = _t1622(msg) + deconstruct_result1127 = _t1624 + if deconstruct_result1127 is not None: + assert deconstruct_result1127 is not None + unwrapped1128 = deconstruct_result1127 + self.pretty_csv_data(unwrapped1128) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1134 = self._try_flat(msg, self.pretty_edb) - if flat1134 is not None: - assert flat1134 is not None - self.write(flat1134) + flat1139 = self._try_flat(msg, self.pretty_edb) + if flat1139 is not None: + assert flat1139 is not None + self.write(flat1139) return None else: - def _t1615(_dollar_dollar): + def _t1625(_dollar_dollar): return (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - _t1616 = _t1615(msg) - fields1129 = _t1616 - assert fields1129 is not None - unwrapped_fields1130 = fields1129 + _t1626 = _t1625(msg) + fields1134 = _t1626 + assert fields1134 is not None + unwrapped_fields1135 = fields1134 self.write("(") self.write("edb") self.indent_sexp() self.newline() - field1131 = unwrapped_fields1130[0] - self.pretty_relation_id(field1131) + field1136 = unwrapped_fields1135[0] + self.pretty_relation_id(field1136) self.newline() - field1132 = unwrapped_fields1130[1] - self.pretty_edb_path(field1132) + field1137 = unwrapped_fields1135[1] + self.pretty_edb_path(field1137) self.newline() - field1133 = unwrapped_fields1130[2] - self.pretty_edb_types(field1133) + field1138 = unwrapped_fields1135[2] + self.pretty_edb_types(field1138) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1138 = self._try_flat(msg, self.pretty_edb_path) - if flat1138 is not None: - assert flat1138 is not None - self.write(flat1138) + flat1143 = self._try_flat(msg, self.pretty_edb_path) + if flat1143 is not None: + assert flat1143 is not None + self.write(flat1143) return None else: - fields1135 = msg + fields1140 = msg self.write("[") self.indent() - for i1137, elem1136 in enumerate(fields1135): - if (i1137 > 0): + for i1142, elem1141 in enumerate(fields1140): + if (i1142 > 0): self.newline() - self.write(self.format_string_value(elem1136)) + self.write(self.format_string_value(elem1141)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1142 = self._try_flat(msg, self.pretty_edb_types) - if flat1142 is not None: - assert flat1142 is not None - self.write(flat1142) + flat1147 = self._try_flat(msg, self.pretty_edb_types) + if flat1147 is not None: + assert flat1147 is not None + self.write(flat1147) return None else: - fields1139 = msg + fields1144 = msg self.write("[") self.indent() - for i1141, elem1140 in enumerate(fields1139): - if (i1141 > 0): + for i1146, elem1145 in enumerate(fields1144): + if (i1146 > 0): self.newline() - self.pretty_type(elem1140) + self.pretty_type(elem1145) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1147 = self._try_flat(msg, self.pretty_betree_relation) - if flat1147 is not None: - assert flat1147 is not None - self.write(flat1147) + flat1152 = self._try_flat(msg, self.pretty_betree_relation) + if flat1152 is not None: + assert flat1152 is not None + self.write(flat1152) return None else: - def _t1617(_dollar_dollar): + def _t1627(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.relation_info,) - _t1618 = _t1617(msg) - fields1143 = _t1618 - assert fields1143 is not None - unwrapped_fields1144 = fields1143 + _t1628 = _t1627(msg) + fields1148 = _t1628 + assert fields1148 is not None + unwrapped_fields1149 = fields1148 self.write("(") self.write("betree_relation") self.indent_sexp() self.newline() - field1145 = unwrapped_fields1144[0] - self.pretty_relation_id(field1145) + field1150 = unwrapped_fields1149[0] + self.pretty_relation_id(field1150) self.newline() - field1146 = unwrapped_fields1144[1] - self.pretty_betree_info(field1146) + field1151 = unwrapped_fields1149[1] + self.pretty_betree_info(field1151) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1153 = self._try_flat(msg, self.pretty_betree_info) - if flat1153 is not None: - assert flat1153 is not None - self.write(flat1153) + flat1158 = self._try_flat(msg, self.pretty_betree_info) + if flat1158 is not None: + assert flat1158 is not None + self.write(flat1158) return None else: - def _t1619(_dollar_dollar): - _t1620 = self.deconstruct_betree_info_config(_dollar_dollar) - return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1620,) - _t1621 = _t1619(msg) - fields1148 = _t1621 - assert fields1148 is not None - unwrapped_fields1149 = fields1148 + def _t1629(_dollar_dollar): + _t1630 = self.deconstruct_betree_info_config(_dollar_dollar) + return (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1630,) + _t1631 = _t1629(msg) + fields1153 = _t1631 + assert fields1153 is not None + unwrapped_fields1154 = fields1153 self.write("(") self.write("betree_info") self.indent_sexp() self.newline() - field1150 = unwrapped_fields1149[0] - self.pretty_betree_info_key_types(field1150) + field1155 = unwrapped_fields1154[0] + self.pretty_betree_info_key_types(field1155) self.newline() - field1151 = unwrapped_fields1149[1] - self.pretty_betree_info_value_types(field1151) + field1156 = unwrapped_fields1154[1] + self.pretty_betree_info_value_types(field1156) self.newline() - field1152 = unwrapped_fields1149[2] - self.pretty_config_dict(field1152) + field1157 = unwrapped_fields1154[2] + self.pretty_config_dict(field1157) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1157 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1157 is not None: - assert flat1157 is not None - self.write(flat1157) + flat1162 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1162 is not None: + assert flat1162 is not None + self.write(flat1162) return None else: - fields1154 = msg + fields1159 = msg self.write("(") self.write("key_types") self.indent_sexp() - if not len(fields1154) == 0: + if not len(fields1159) == 0: self.newline() - for i1156, elem1155 in enumerate(fields1154): - if (i1156 > 0): + for i1161, elem1160 in enumerate(fields1159): + if (i1161 > 0): self.newline() - self.pretty_type(elem1155) + self.pretty_type(elem1160) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1161 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1161 is not None: - assert flat1161 is not None - self.write(flat1161) + flat1166 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1166 is not None: + assert flat1166 is not None + self.write(flat1166) return None else: - fields1158 = msg + fields1163 = msg self.write("(") self.write("value_types") self.indent_sexp() - if not len(fields1158) == 0: + if not len(fields1163) == 0: self.newline() - for i1160, elem1159 in enumerate(fields1158): - if (i1160 > 0): + for i1165, elem1164 in enumerate(fields1163): + if (i1165 > 0): self.newline() - self.pretty_type(elem1159) + self.pretty_type(elem1164) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1168 = self._try_flat(msg, self.pretty_csv_data) - if flat1168 is not None: - assert flat1168 is not None - self.write(flat1168) + flat1173 = self._try_flat(msg, self.pretty_csv_data) + if flat1173 is not None: + assert flat1173 is not None + self.write(flat1173) return None else: - def _t1622(_dollar_dollar): + def _t1632(_dollar_dollar): return (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - _t1623 = _t1622(msg) - fields1162 = _t1623 - assert fields1162 is not None - unwrapped_fields1163 = fields1162 + _t1633 = _t1632(msg) + fields1167 = _t1633 + assert fields1167 is not None + unwrapped_fields1168 = fields1167 self.write("(") self.write("csv_data") self.indent_sexp() self.newline() - field1164 = unwrapped_fields1163[0] - self.pretty_csvlocator(field1164) + field1169 = unwrapped_fields1168[0] + self.pretty_csvlocator(field1169) self.newline() - field1165 = unwrapped_fields1163[1] - self.pretty_csv_config(field1165) + field1170 = unwrapped_fields1168[1] + self.pretty_csv_config(field1170) self.newline() - field1166 = unwrapped_fields1163[2] - self.pretty_gnf_columns(field1166) + field1171 = unwrapped_fields1168[2] + self.pretty_gnf_columns(field1171) self.newline() - field1167 = unwrapped_fields1163[3] - self.pretty_csv_asof(field1167) + field1172 = unwrapped_fields1168[3] + self.pretty_csv_asof(field1172) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1175 = self._try_flat(msg, self.pretty_csvlocator) - if flat1175 is not None: - assert flat1175 is not None - self.write(flat1175) + flat1180 = self._try_flat(msg, self.pretty_csvlocator) + if flat1180 is not None: + assert flat1180 is not None + self.write(flat1180) return None else: - def _t1624(_dollar_dollar): + def _t1634(_dollar_dollar): if not len(_dollar_dollar.paths) == 0: - _t1625 = _dollar_dollar.paths + _t1635 = _dollar_dollar.paths else: - _t1625 = None + _t1635 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1626 = _dollar_dollar.inline_data.decode('utf-8') + _t1636 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1626 = None - return (_t1625, _t1626,) - _t1627 = _t1624(msg) - fields1169 = _t1627 - assert fields1169 is not None - unwrapped_fields1170 = fields1169 + _t1636 = None + return (_t1635, _t1636,) + _t1637 = _t1634(msg) + fields1174 = _t1637 + assert fields1174 is not None + unwrapped_fields1175 = fields1174 self.write("(") self.write("csv_locator") self.indent_sexp() - field1171 = unwrapped_fields1170[0] - if field1171 is not None: + field1176 = unwrapped_fields1175[0] + if field1176 is not None: self.newline() - assert field1171 is not None - opt_val1172 = field1171 - self.pretty_csv_locator_paths(opt_val1172) - field1173 = unwrapped_fields1170[1] - if field1173 is not None: + assert field1176 is not None + opt_val1177 = field1176 + self.pretty_csv_locator_paths(opt_val1177) + field1178 = unwrapped_fields1175[1] + if field1178 is not None: self.newline() - assert field1173 is not None - opt_val1174 = field1173 - self.pretty_csv_locator_inline_data(opt_val1174) + assert field1178 is not None + opt_val1179 = field1178 + self.pretty_csv_locator_inline_data(opt_val1179) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1179 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1179 is not None: - assert flat1179 is not None - self.write(flat1179) + flat1184 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1184 is not None: + assert flat1184 is not None + self.write(flat1184) return None else: - fields1176 = msg + fields1181 = msg self.write("(") self.write("paths") self.indent_sexp() - if not len(fields1176) == 0: + if not len(fields1181) == 0: self.newline() - for i1178, elem1177 in enumerate(fields1176): - if (i1178 > 0): + for i1183, elem1182 in enumerate(fields1181): + if (i1183 > 0): self.newline() - self.write(self.format_string_value(elem1177)) + self.write(self.format_string_value(elem1182)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1181 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1181 is not None: - assert flat1181 is not None - self.write(flat1181) + flat1186 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1186 is not None: + assert flat1186 is not None + self.write(flat1186) return None else: - fields1180 = msg + fields1185 = msg self.write("(") self.write("inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1180)) + self.write(self.format_string_value(fields1185)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1184 = self._try_flat(msg, self.pretty_csv_config) - if flat1184 is not None: - assert flat1184 is not None - self.write(flat1184) + flat1189 = self._try_flat(msg, self.pretty_csv_config) + if flat1189 is not None: + assert flat1189 is not None + self.write(flat1189) return None else: - def _t1628(_dollar_dollar): - _t1629 = self.deconstruct_csv_config(_dollar_dollar) - return _t1629 - _t1630 = _t1628(msg) - fields1182 = _t1630 - assert fields1182 is not None - unwrapped_fields1183 = fields1182 + def _t1638(_dollar_dollar): + _t1639 = self.deconstruct_csv_config(_dollar_dollar) + return _t1639 + _t1640 = _t1638(msg) + fields1187 = _t1640 + assert fields1187 is not None + unwrapped_fields1188 = fields1187 self.write("(") self.write("csv_config") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields1183) + self.pretty_config_dict(unwrapped_fields1188) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1188 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1188 is not None: - assert flat1188 is not None - self.write(flat1188) + flat1193 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1193 is not None: + assert flat1193 is not None + self.write(flat1193) return None else: - fields1185 = msg + fields1190 = msg self.write("(") self.write("columns") self.indent_sexp() - if not len(fields1185) == 0: + if not len(fields1190) == 0: self.newline() - for i1187, elem1186 in enumerate(fields1185): - if (i1187 > 0): + for i1192, elem1191 in enumerate(fields1190): + if (i1192 > 0): self.newline() - self.pretty_gnf_column(elem1186) + self.pretty_gnf_column(elem1191) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1197 = self._try_flat(msg, self.pretty_gnf_column) - if flat1197 is not None: - assert flat1197 is not None - self.write(flat1197) + flat1202 = self._try_flat(msg, self.pretty_gnf_column) + if flat1202 is not None: + assert flat1202 is not None + self.write(flat1202) return None else: - def _t1631(_dollar_dollar): + def _t1641(_dollar_dollar): if _dollar_dollar.HasField("target_id"): - _t1632 = _dollar_dollar.target_id + _t1642 = _dollar_dollar.target_id else: - _t1632 = None - return (_dollar_dollar.column_path, _t1632, _dollar_dollar.types,) - _t1633 = _t1631(msg) - fields1189 = _t1633 - assert fields1189 is not None - unwrapped_fields1190 = fields1189 + _t1642 = None + return (_dollar_dollar.column_path, _t1642, _dollar_dollar.types,) + _t1643 = _t1641(msg) + fields1194 = _t1643 + assert fields1194 is not None + unwrapped_fields1195 = fields1194 self.write("(") self.write("column") self.indent_sexp() self.newline() - field1191 = unwrapped_fields1190[0] - self.pretty_gnf_column_path(field1191) - field1192 = unwrapped_fields1190[1] - if field1192 is not None: + field1196 = unwrapped_fields1195[0] + self.pretty_gnf_column_path(field1196) + field1197 = unwrapped_fields1195[1] + if field1197 is not None: self.newline() - assert field1192 is not None - opt_val1193 = field1192 - self.pretty_relation_id(opt_val1193) + assert field1197 is not None + opt_val1198 = field1197 + self.pretty_relation_id(opt_val1198) self.newline() self.write("[") - field1194 = unwrapped_fields1190[2] - for i1196, elem1195 in enumerate(field1194): - if (i1196 > 0): + field1199 = unwrapped_fields1195[2] + for i1201, elem1200 in enumerate(field1199): + if (i1201 > 0): self.newline() - self.pretty_type(elem1195) + self.pretty_type(elem1200) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1204 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1204 is not None: - assert flat1204 is not None - self.write(flat1204) + flat1209 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1209 is not None: + assert flat1209 is not None + self.write(flat1209) return None else: - def _t1634(_dollar_dollar): + def _t1644(_dollar_dollar): if len(_dollar_dollar) == 1: - _t1635 = _dollar_dollar[0] + _t1645 = _dollar_dollar[0] else: - _t1635 = None - return _t1635 - _t1636 = _t1634(msg) - deconstruct_result1202 = _t1636 - if deconstruct_result1202 is not None: - assert deconstruct_result1202 is not None - unwrapped1203 = deconstruct_result1202 - self.write(self.format_string_value(unwrapped1203)) + _t1645 = None + return _t1645 + _t1646 = _t1644(msg) + deconstruct_result1207 = _t1646 + if deconstruct_result1207 is not None: + assert deconstruct_result1207 is not None + unwrapped1208 = deconstruct_result1207 + self.write(self.format_string_value(unwrapped1208)) else: - def _t1637(_dollar_dollar): + def _t1647(_dollar_dollar): if len(_dollar_dollar) != 1: - _t1638 = _dollar_dollar + _t1648 = _dollar_dollar else: - _t1638 = None - return _t1638 - _t1639 = _t1637(msg) - deconstruct_result1198 = _t1639 - if deconstruct_result1198 is not None: - assert deconstruct_result1198 is not None - unwrapped1199 = deconstruct_result1198 + _t1648 = None + return _t1648 + _t1649 = _t1647(msg) + deconstruct_result1203 = _t1649 + if deconstruct_result1203 is not None: + assert deconstruct_result1203 is not None + unwrapped1204 = deconstruct_result1203 self.write("[") self.indent() - for i1201, elem1200 in enumerate(unwrapped1199): - if (i1201 > 0): + for i1206, elem1205 in enumerate(unwrapped1204): + if (i1206 > 0): self.newline() - self.write(self.format_string_value(elem1200)) + self.write(self.format_string_value(elem1205)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_csv_asof(self, msg: str): - flat1206 = self._try_flat(msg, self.pretty_csv_asof) - if flat1206 is not None: - assert flat1206 is not None - self.write(flat1206) + flat1211 = self._try_flat(msg, self.pretty_csv_asof) + if flat1211 is not None: + assert flat1211 is not None + self.write(flat1211) return None else: - fields1205 = msg + fields1210 = msg self.write("(") self.write("asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1205)) + self.write(self.format_string_value(fields1210)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1209 = self._try_flat(msg, self.pretty_undefine) - if flat1209 is not None: - assert flat1209 is not None - self.write(flat1209) + flat1214 = self._try_flat(msg, self.pretty_undefine) + if flat1214 is not None: + assert flat1214 is not None + self.write(flat1214) return None else: - def _t1640(_dollar_dollar): + def _t1650(_dollar_dollar): return _dollar_dollar.fragment_id - _t1641 = _t1640(msg) - fields1207 = _t1641 - assert fields1207 is not None - unwrapped_fields1208 = fields1207 + _t1651 = _t1650(msg) + fields1212 = _t1651 + assert fields1212 is not None + unwrapped_fields1213 = fields1212 self.write("(") self.write("undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1208) + self.pretty_fragment_id(unwrapped_fields1213) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1214 = self._try_flat(msg, self.pretty_context) - if flat1214 is not None: - assert flat1214 is not None - self.write(flat1214) + flat1219 = self._try_flat(msg, self.pretty_context) + if flat1219 is not None: + assert flat1219 is not None + self.write(flat1219) return None else: - def _t1642(_dollar_dollar): + def _t1652(_dollar_dollar): return _dollar_dollar.relations - _t1643 = _t1642(msg) - fields1210 = _t1643 - assert fields1210 is not None - unwrapped_fields1211 = fields1210 + _t1653 = _t1652(msg) + fields1215 = _t1653 + assert fields1215 is not None + unwrapped_fields1216 = fields1215 self.write("(") self.write("context") self.indent_sexp() - if not len(unwrapped_fields1211) == 0: + if not len(unwrapped_fields1216) == 0: self.newline() - for i1213, elem1212 in enumerate(unwrapped_fields1211): - if (i1213 > 0): + for i1218, elem1217 in enumerate(unwrapped_fields1216): + if (i1218 > 0): self.newline() - self.pretty_relation_id(elem1212) + self.pretty_relation_id(elem1217) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1219 = self._try_flat(msg, self.pretty_snapshot) - if flat1219 is not None: - assert flat1219 is not None - self.write(flat1219) + flat1224 = self._try_flat(msg, self.pretty_snapshot) + if flat1224 is not None: + assert flat1224 is not None + self.write(flat1224) return None else: - def _t1644(_dollar_dollar): - return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - _t1645 = _t1644(msg) - fields1215 = _t1645 - assert fields1215 is not None - unwrapped_fields1216 = fields1215 + def _t1654(_dollar_dollar): + return _dollar_dollar.mappings + _t1655 = _t1654(msg) + fields1220 = _t1655 + assert fields1220 is not None + unwrapped_fields1221 = fields1220 self.write("(") self.write("snapshot") self.indent_sexp() - self.newline() - field1217 = unwrapped_fields1216[0] - self.pretty_edb_path(field1217) - self.newline() - field1218 = unwrapped_fields1216[1] - self.pretty_relation_id(field1218) + if not len(unwrapped_fields1221) == 0: + self.newline() + for i1223, elem1222 in enumerate(unwrapped_fields1221): + if (i1223 > 0): + self.newline() + self.pretty_snapshot_mapping(elem1222) self.dedent() self.write(")") + def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): + flat1229 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1229 is not None: + assert flat1229 is not None + self.write(flat1229) + return None + else: + def _t1656(_dollar_dollar): + return (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + _t1657 = _t1656(msg) + fields1225 = _t1657 + assert fields1225 is not None + unwrapped_fields1226 = fields1225 + field1227 = unwrapped_fields1226[0] + self.pretty_edb_path(field1227) + self.write(" ") + field1228 = unwrapped_fields1226[1] + self.pretty_relation_id(field1228) + def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1223 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1223 is not None: - assert flat1223 is not None - self.write(flat1223) + flat1233 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1233 is not None: + assert flat1233 is not None + self.write(flat1233) return None else: - fields1220 = msg + fields1230 = msg self.write("(") self.write("reads") self.indent_sexp() - if not len(fields1220) == 0: + if not len(fields1230) == 0: self.newline() - for i1222, elem1221 in enumerate(fields1220): - if (i1222 > 0): + for i1232, elem1231 in enumerate(fields1230): + if (i1232 > 0): self.newline() - self.pretty_read(elem1221) + self.pretty_read(elem1231) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1234 = self._try_flat(msg, self.pretty_read) - if flat1234 is not None: - assert flat1234 is not None - self.write(flat1234) + flat1244 = self._try_flat(msg, self.pretty_read) + if flat1244 is not None: + assert flat1244 is not None + self.write(flat1244) return None else: - def _t1646(_dollar_dollar): + def _t1658(_dollar_dollar): if _dollar_dollar.HasField("demand"): - _t1647 = _dollar_dollar.demand + _t1659 = _dollar_dollar.demand else: - _t1647 = None - return _t1647 - _t1648 = _t1646(msg) - deconstruct_result1232 = _t1648 - if deconstruct_result1232 is not None: - assert deconstruct_result1232 is not None - unwrapped1233 = deconstruct_result1232 - self.pretty_demand(unwrapped1233) + _t1659 = None + return _t1659 + _t1660 = _t1658(msg) + deconstruct_result1242 = _t1660 + if deconstruct_result1242 is not None: + assert deconstruct_result1242 is not None + unwrapped1243 = deconstruct_result1242 + self.pretty_demand(unwrapped1243) else: - def _t1649(_dollar_dollar): + def _t1661(_dollar_dollar): if _dollar_dollar.HasField("output"): - _t1650 = _dollar_dollar.output + _t1662 = _dollar_dollar.output else: - _t1650 = None - return _t1650 - _t1651 = _t1649(msg) - deconstruct_result1230 = _t1651 - if deconstruct_result1230 is not None: - assert deconstruct_result1230 is not None - unwrapped1231 = deconstruct_result1230 - self.pretty_output(unwrapped1231) + _t1662 = None + return _t1662 + _t1663 = _t1661(msg) + deconstruct_result1240 = _t1663 + if deconstruct_result1240 is not None: + assert deconstruct_result1240 is not None + unwrapped1241 = deconstruct_result1240 + self.pretty_output(unwrapped1241) else: - def _t1652(_dollar_dollar): + def _t1664(_dollar_dollar): if _dollar_dollar.HasField("what_if"): - _t1653 = _dollar_dollar.what_if + _t1665 = _dollar_dollar.what_if else: - _t1653 = None - return _t1653 - _t1654 = _t1652(msg) - deconstruct_result1228 = _t1654 - if deconstruct_result1228 is not None: - assert deconstruct_result1228 is not None - unwrapped1229 = deconstruct_result1228 - self.pretty_what_if(unwrapped1229) + _t1665 = None + return _t1665 + _t1666 = _t1664(msg) + deconstruct_result1238 = _t1666 + if deconstruct_result1238 is not None: + assert deconstruct_result1238 is not None + unwrapped1239 = deconstruct_result1238 + self.pretty_what_if(unwrapped1239) else: - def _t1655(_dollar_dollar): + def _t1667(_dollar_dollar): if _dollar_dollar.HasField("abort"): - _t1656 = _dollar_dollar.abort + _t1668 = _dollar_dollar.abort else: - _t1656 = None - return _t1656 - _t1657 = _t1655(msg) - deconstruct_result1226 = _t1657 - if deconstruct_result1226 is not None: - assert deconstruct_result1226 is not None - unwrapped1227 = deconstruct_result1226 - self.pretty_abort(unwrapped1227) + _t1668 = None + return _t1668 + _t1669 = _t1667(msg) + deconstruct_result1236 = _t1669 + if deconstruct_result1236 is not None: + assert deconstruct_result1236 is not None + unwrapped1237 = deconstruct_result1236 + self.pretty_abort(unwrapped1237) else: - def _t1658(_dollar_dollar): + def _t1670(_dollar_dollar): if _dollar_dollar.HasField("export"): - _t1659 = _dollar_dollar.export + _t1671 = _dollar_dollar.export else: - _t1659 = None - return _t1659 - _t1660 = _t1658(msg) - deconstruct_result1224 = _t1660 - if deconstruct_result1224 is not None: - assert deconstruct_result1224 is not None - unwrapped1225 = deconstruct_result1224 - self.pretty_export(unwrapped1225) + _t1671 = None + return _t1671 + _t1672 = _t1670(msg) + deconstruct_result1234 = _t1672 + if deconstruct_result1234 is not None: + assert deconstruct_result1234 is not None + unwrapped1235 = deconstruct_result1234 + self.pretty_export(unwrapped1235) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1237 = self._try_flat(msg, self.pretty_demand) - if flat1237 is not None: - assert flat1237 is not None - self.write(flat1237) + flat1247 = self._try_flat(msg, self.pretty_demand) + if flat1247 is not None: + assert flat1247 is not None + self.write(flat1247) return None else: - def _t1661(_dollar_dollar): + def _t1673(_dollar_dollar): return _dollar_dollar.relation_id - _t1662 = _t1661(msg) - fields1235 = _t1662 - assert fields1235 is not None - unwrapped_fields1236 = fields1235 + _t1674 = _t1673(msg) + fields1245 = _t1674 + assert fields1245 is not None + unwrapped_fields1246 = fields1245 self.write("(") self.write("demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1236) + self.pretty_relation_id(unwrapped_fields1246) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1242 = self._try_flat(msg, self.pretty_output) - if flat1242 is not None: - assert flat1242 is not None - self.write(flat1242) + flat1252 = self._try_flat(msg, self.pretty_output) + if flat1252 is not None: + assert flat1252 is not None + self.write(flat1252) return None else: - def _t1663(_dollar_dollar): + def _t1675(_dollar_dollar): return (_dollar_dollar.name, _dollar_dollar.relation_id,) - _t1664 = _t1663(msg) - fields1238 = _t1664 - assert fields1238 is not None - unwrapped_fields1239 = fields1238 + _t1676 = _t1675(msg) + fields1248 = _t1676 + assert fields1248 is not None + unwrapped_fields1249 = fields1248 self.write("(") self.write("output") self.indent_sexp() self.newline() - field1240 = unwrapped_fields1239[0] - self.pretty_name(field1240) + field1250 = unwrapped_fields1249[0] + self.pretty_name(field1250) self.newline() - field1241 = unwrapped_fields1239[1] - self.pretty_relation_id(field1241) + field1251 = unwrapped_fields1249[1] + self.pretty_relation_id(field1251) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1247 = self._try_flat(msg, self.pretty_what_if) - if flat1247 is not None: - assert flat1247 is not None - self.write(flat1247) + flat1257 = self._try_flat(msg, self.pretty_what_if) + if flat1257 is not None: + assert flat1257 is not None + self.write(flat1257) return None else: - def _t1665(_dollar_dollar): + def _t1677(_dollar_dollar): return (_dollar_dollar.branch, _dollar_dollar.epoch,) - _t1666 = _t1665(msg) - fields1243 = _t1666 - assert fields1243 is not None - unwrapped_fields1244 = fields1243 + _t1678 = _t1677(msg) + fields1253 = _t1678 + assert fields1253 is not None + unwrapped_fields1254 = fields1253 self.write("(") self.write("what_if") self.indent_sexp() self.newline() - field1245 = unwrapped_fields1244[0] - self.pretty_name(field1245) + field1255 = unwrapped_fields1254[0] + self.pretty_name(field1255) self.newline() - field1246 = unwrapped_fields1244[1] - self.pretty_epoch(field1246) + field1256 = unwrapped_fields1254[1] + self.pretty_epoch(field1256) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1253 = self._try_flat(msg, self.pretty_abort) - if flat1253 is not None: - assert flat1253 is not None - self.write(flat1253) + flat1263 = self._try_flat(msg, self.pretty_abort) + if flat1263 is not None: + assert flat1263 is not None + self.write(flat1263) return None else: - def _t1667(_dollar_dollar): + def _t1679(_dollar_dollar): if _dollar_dollar.name != "abort": - _t1668 = _dollar_dollar.name + _t1680 = _dollar_dollar.name else: - _t1668 = None - return (_t1668, _dollar_dollar.relation_id,) - _t1669 = _t1667(msg) - fields1248 = _t1669 - assert fields1248 is not None - unwrapped_fields1249 = fields1248 + _t1680 = None + return (_t1680, _dollar_dollar.relation_id,) + _t1681 = _t1679(msg) + fields1258 = _t1681 + assert fields1258 is not None + unwrapped_fields1259 = fields1258 self.write("(") self.write("abort") self.indent_sexp() - field1250 = unwrapped_fields1249[0] - if field1250 is not None: + field1260 = unwrapped_fields1259[0] + if field1260 is not None: self.newline() - assert field1250 is not None - opt_val1251 = field1250 - self.pretty_name(opt_val1251) + assert field1260 is not None + opt_val1261 = field1260 + self.pretty_name(opt_val1261) self.newline() - field1252 = unwrapped_fields1249[1] - self.pretty_relation_id(field1252) + field1262 = unwrapped_fields1259[1] + self.pretty_relation_id(field1262) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1256 = self._try_flat(msg, self.pretty_export) - if flat1256 is not None: - assert flat1256 is not None - self.write(flat1256) + flat1266 = self._try_flat(msg, self.pretty_export) + if flat1266 is not None: + assert flat1266 is not None + self.write(flat1266) return None else: - def _t1670(_dollar_dollar): + def _t1682(_dollar_dollar): return _dollar_dollar.csv_config - _t1671 = _t1670(msg) - fields1254 = _t1671 - assert fields1254 is not None - unwrapped_fields1255 = fields1254 + _t1683 = _t1682(msg) + fields1264 = _t1683 + assert fields1264 is not None + unwrapped_fields1265 = fields1264 self.write("(") self.write("export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped_fields1255) + self.pretty_export_csv_config(unwrapped_fields1265) self.dedent() self.write(")") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1262 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1262 is not None: - assert flat1262 is not None - self.write(flat1262) + flat1272 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1272 is not None: + assert flat1272 is not None + self.write(flat1272) return None else: - def _t1672(_dollar_dollar): - _t1673 = self.deconstruct_export_csv_config(_dollar_dollar) - return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1673,) - _t1674 = _t1672(msg) - fields1257 = _t1674 - assert fields1257 is not None - unwrapped_fields1258 = fields1257 + def _t1684(_dollar_dollar): + _t1685 = self.deconstruct_export_csv_config(_dollar_dollar) + return (_dollar_dollar.path, _dollar_dollar.data_columns, _t1685,) + _t1686 = _t1684(msg) + fields1267 = _t1686 + assert fields1267 is not None + unwrapped_fields1268 = fields1267 self.write("(") self.write("export_csv_config") self.indent_sexp() self.newline() - field1259 = unwrapped_fields1258[0] - self.pretty_export_csv_path(field1259) + field1269 = unwrapped_fields1268[0] + self.pretty_export_csv_path(field1269) self.newline() - field1260 = unwrapped_fields1258[1] - self.pretty_export_csv_columns(field1260) + field1270 = unwrapped_fields1268[1] + self.pretty_export_csv_columns(field1270) self.newline() - field1261 = unwrapped_fields1258[2] - self.pretty_config_dict(field1261) + field1271 = unwrapped_fields1268[2] + self.pretty_config_dict(field1271) self.dedent() self.write(")") def pretty_export_csv_path(self, msg: str): - flat1264 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1264 is not None: - assert flat1264 is not None - self.write(flat1264) + flat1274 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1274 is not None: + assert flat1274 is not None + self.write(flat1274) return None else: - fields1263 = msg + fields1273 = msg self.write("(") self.write("path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1263)) + self.write(self.format_string_value(fields1273)) self.dedent() self.write(")") def pretty_export_csv_columns(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1268 = self._try_flat(msg, self.pretty_export_csv_columns) - if flat1268 is not None: - assert flat1268 is not None - self.write(flat1268) + flat1278 = self._try_flat(msg, self.pretty_export_csv_columns) + if flat1278 is not None: + assert flat1278 is not None + self.write(flat1278) return None else: - fields1265 = msg + fields1275 = msg self.write("(") self.write("columns") self.indent_sexp() - if not len(fields1265) == 0: + if not len(fields1275) == 0: self.newline() - for i1267, elem1266 in enumerate(fields1265): - if (i1267 > 0): + for i1277, elem1276 in enumerate(fields1275): + if (i1277 > 0): self.newline() - self.pretty_export_csv_column(elem1266) + self.pretty_export_csv_column(elem1276) self.dedent() self.write(")") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1273 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1273 is not None: - assert flat1273 is not None - self.write(flat1273) + flat1283 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1283 is not None: + assert flat1283 is not None + self.write(flat1283) return None else: - def _t1675(_dollar_dollar): + def _t1687(_dollar_dollar): return (_dollar_dollar.column_name, _dollar_dollar.column_data,) - _t1676 = _t1675(msg) - fields1269 = _t1676 - assert fields1269 is not None - unwrapped_fields1270 = fields1269 + _t1688 = _t1687(msg) + fields1279 = _t1688 + assert fields1279 is not None + unwrapped_fields1280 = fields1279 self.write("(") self.write("column") self.indent_sexp() self.newline() - field1271 = unwrapped_fields1270[0] - self.write(self.format_string_value(field1271)) + field1281 = unwrapped_fields1280[0] + self.write(self.format_string_value(field1281)) self.newline() - field1272 = unwrapped_fields1270[1] - self.pretty_relation_id(field1272) + field1282 = unwrapped_fields1280[1] + self.pretty_relation_id(field1282) self.dedent() self.write(")") @@ -3853,8 +3872,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1714 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1714) + _t1726 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1726) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") @@ -4112,6 +4131,8 @@ def pprint_dispatch(self, msg): self.pretty_context(msg) elif isinstance(msg, transactions_pb2.Snapshot): self.pretty_snapshot(msg) + elif isinstance(msg, transactions_pb2.SnapshotMapping): + self.pretty_snapshot_mapping(msg) elif isinstance(msg, transactions_pb2.Read): self.pretty_read(msg) elif isinstance(msg, transactions_pb2.Demand): diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.py b/sdks/python/src/lqp/proto/v1/transactions_pb2.py index 2da081b7..5d4f5cd3 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.py +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.py @@ -16,7 +16,7 @@ from lqp.proto.v1 import logic_pb2 as relationalai_dot_lqp_dot_v1_dot_logic__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x7f\n\x08Snapshot\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"\xc4\x04\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"`\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x86\x01\n\x0fSnapshotMapping\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"L\n\x08Snapshot\x12@\n\x08mappings\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.SnapshotMappingR\x08mappings\"\xc4\x04\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"`\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -24,8 +24,8 @@ if _descriptor._USE_C_DESCRIPTORS == False: _globals['DESCRIPTOR']._options = None _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1' - _globals['_MAINTENANCELEVEL']._serialized_start=2761 - _globals['_MAINTENANCELEVEL']._serialized_end=2896 + _globals['_MAINTENANCELEVEL']._serialized_start=2847 + _globals['_MAINTENANCELEVEL']._serialized_end=2982 _globals['_TRANSACTION']._serialized_start=134 _globals['_TRANSACTION']._serialized_end=322 _globals['_CONFIGURE']._serialized_start=324 @@ -44,22 +44,24 @@ _globals['_UNDEFINE']._serialized_end=1110 _globals['_CONTEXT']._serialized_start=1112 _globals['_CONTEXT']._serialized_end=1184 - _globals['_SNAPSHOT']._serialized_start=1186 - _globals['_SNAPSHOT']._serialized_end=1313 - _globals['_EXPORTCSVCONFIG']._serialized_start=1316 - _globals['_EXPORTCSVCONFIG']._serialized_end=1896 - _globals['_EXPORTCSVCOLUMN']._serialized_start=1898 - _globals['_EXPORTCSVCOLUMN']._serialized_end=2014 - _globals['_READ']._serialized_start=2017 - _globals['_READ']._serialized_end=2309 - _globals['_DEMAND']._serialized_start=2311 - _globals['_DEMAND']._serialized_end=2385 - _globals['_OUTPUT']._serialized_start=2387 - _globals['_OUTPUT']._serialized_end=2481 - _globals['_EXPORT']._serialized_start=2483 - _globals['_EXPORT']._serialized_end=2579 - _globals['_WHATIF']._serialized_start=2581 - _globals['_WHATIF']._serialized_end=2663 - _globals['_ABORT']._serialized_start=2665 - _globals['_ABORT']._serialized_end=2758 + _globals['_SNAPSHOTMAPPING']._serialized_start=1187 + _globals['_SNAPSHOTMAPPING']._serialized_end=1321 + _globals['_SNAPSHOT']._serialized_start=1323 + _globals['_SNAPSHOT']._serialized_end=1399 + _globals['_EXPORTCSVCONFIG']._serialized_start=1402 + _globals['_EXPORTCSVCONFIG']._serialized_end=1982 + _globals['_EXPORTCSVCOLUMN']._serialized_start=1984 + _globals['_EXPORTCSVCOLUMN']._serialized_end=2100 + _globals['_READ']._serialized_start=2103 + _globals['_READ']._serialized_end=2395 + _globals['_DEMAND']._serialized_start=2397 + _globals['_DEMAND']._serialized_end=2471 + _globals['_OUTPUT']._serialized_start=2473 + _globals['_OUTPUT']._serialized_end=2567 + _globals['_EXPORT']._serialized_start=2569 + _globals['_EXPORT']._serialized_end=2665 + _globals['_WHATIF']._serialized_start=2667 + _globals['_WHATIF']._serialized_end=2749 + _globals['_ABORT']._serialized_start=2751 + _globals['_ABORT']._serialized_end=2844 # @@protoc_insertion_point(module_scope) diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi index 7af683a7..58274043 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi @@ -88,7 +88,7 @@ class Context(_message.Message): relations: _containers.RepeatedCompositeFieldContainer[_logic_pb2.RelationId] def __init__(self, relations: _Optional[_Iterable[_Union[_logic_pb2.RelationId, _Mapping]]] = ...) -> None: ... -class Snapshot(_message.Message): +class SnapshotMapping(_message.Message): __slots__ = ("destination_path", "source_relation") DESTINATION_PATH_FIELD_NUMBER: _ClassVar[int] SOURCE_RELATION_FIELD_NUMBER: _ClassVar[int] @@ -96,6 +96,12 @@ class Snapshot(_message.Message): source_relation: _logic_pb2.RelationId def __init__(self, destination_path: _Optional[_Iterable[str]] = ..., source_relation: _Optional[_Union[_logic_pb2.RelationId, _Mapping]] = ...) -> None: ... +class Snapshot(_message.Message): + __slots__ = ("mappings",) + MAPPINGS_FIELD_NUMBER: _ClassVar[int] + mappings: _containers.RepeatedCompositeFieldContainer[SnapshotMapping] + def __init__(self, mappings: _Optional[_Iterable[_Union[SnapshotMapping, _Mapping]]] = ...) -> None: ... + class ExportCSVConfig(_message.Message): __slots__ = ("path", "data_columns", "partition_size", "compression", "syntax_header_row", "syntax_missing_string", "syntax_delim", "syntax_quotechar", "syntax_escapechar") PATH_FIELD_NUMBER: _ClassVar[int] diff --git a/tests/bin/snapshot.bin b/tests/bin/snapshot.bin index dc1cbf24dd77d0803ad7107f8ad14d442bdbec76..122c14262a7cbefd45827048e1091b0a39cd562a 100644 GIT binary patch delta 70 zcmZ3)xqx%Sb7rgcj9l?rv0TDjY`K;3sVPZ9oSe7M9*j^)JH3iahKnO5u_Q4mu{f2B Y6-ei#0%bREPMhP9v^0uqvNB6O050nnJ^%m! delta 72 zcmZ3$xrlSab7q^3j9j8x!dz^*mGP-5NkW{Qx6dAoP)R$zic3yQhKnO5u_Q4mu{f2B a6-ei#0_8VvPMhP9v^0uKOKY+sOFaNh?iVWn diff --git a/tests/lqp/snapshot.bin b/tests/lqp/snapshot.bin new file mode 100644 index 0000000000000000000000000000000000000000..122c14262a7cbefd45827048e1091b0a39cd562a GIT binary patch literal 1184 zcmb_bU2D@&819Kn+q|1FUZ)#zOpVixl1WaIHrWIjiYUGF3&xz3bWOXkrmagVR=iRW z5ih(Rf*=gU8(~8b#i2Li)cJ8Ocq0riyxBkSv{~8=9C#s|kmv9|&pGeMdEjRP-Vk_A z;3a`>5WI?2^X96)hyBuC*aL!a_d(*v^5XGzjJu7TUC84>X$S^c;Qh#I+;E3>W3piR zR^IY#Z+6ahEfgx2YkM_o*2d(5UABCuS`kl1E{Pl) z)wk24*oJBcYVd`JPdu#gkO028V3jD|gd6OH@9S@;hKnDcq6-4-0&*QWF&4lEau~x) z;srR8Jq*1pom_3faUI{eX6Njym_R;I#IXyxUIMA?=+3kTcB6po_Bp#;uHq|Bdcld$ zIe1L)5pfD~-YMlgr&O^6Sg!;dpfWWSs#9uedPdPR{wm_XAErZRM<$(SmodO8iNJoax#nz90#tjHAiCy7Ml6p>UilO@N_ z^L4*CW=?lmb-yb11LqV_5LQ<pK9@sfrOA=WczQFAsbO2x?3`1U*ec zSSzEP`MmslWAn+WfRc(yeX63S#}vxeMMartt!cbN@HS!7TUjYSoXjsxGl=)T{<`dz z*Ki&jEP)+~;#4qDt25ht6XK+J0{SK}s&0+cf}`2toky7uM{kJ@rVXDEgJBC842xwj zEQ-OuCET$s6U`;HH{MVJdZM%)(BSR^zc vJR^`xU15F>O&qCf5ZVTYEdxg?8HFwLLdU$&HZQv)?8N`g7~@HTT$20&@;*t5 literal 0 HcmV?d00001 diff --git a/tests/lqp/snapshot.lqp b/tests/lqp/snapshot.lqp index 2e73b3ef..455f1a59 100644 --- a/tests/lqp/snapshot.lqp +++ b/tests/lqp/snapshot.lqp @@ -45,9 +45,10 @@ ;; Snapshot the defined relations as EDBs (epoch (writes - (snapshot ["my_edb"] :my_rel) - (snapshot ["database" "table"] :computed) - (snapshot ["schema" "namespace" "relation"] :big_signed)) + (snapshot + ["my_edb"] :my_rel + ["database" "table"] :computed + ["schema" "namespace" "relation"] :big_signed)) ;; Snapshots should match the relations now. (reads (output :snapshot1 :snapshot1) diff --git a/tests/pretty/snapshot.lqp b/tests/pretty/snapshot.lqp index 80483c8e..df31ba73 100644 --- a/tests/pretty/snapshot.lqp +++ b/tests/pretty/snapshot.lqp @@ -41,9 +41,10 @@ (output :snapshot3 :snapshot3))) (epoch (writes - (snapshot ["my_edb"] :my_rel) - (snapshot ["database" "table"] :computed) - (snapshot ["schema" "namespace" "relation"] :big_signed)) + (snapshot + ["my_edb"] :my_rel + ["database" "table"] :computed + ["schema" "namespace" "relation"] :big_signed)) (reads (output :snapshot1 :snapshot1) (output :snapshot2 :snapshot2) diff --git a/tests/pretty_debug/snapshot.lqp b/tests/pretty_debug/snapshot.lqp index cac6684e..8fd02249 100644 --- a/tests/pretty_debug/snapshot.lqp +++ b/tests/pretty_debug/snapshot.lqp @@ -44,9 +44,10 @@ (output :snapshot3 0xc6e65c9a8c481ef1))) (epoch (writes - (snapshot ["my_edb"] 0xaacb662458c1cddb) - (snapshot ["database" "table"] 0x5aa562409c66b3b3) - (snapshot ["schema" "namespace" "relation"] 0xca186c6bd1825179)) + (snapshot + ["my_edb"] 0xaacb662458c1cddb + ["database" "table"] 0x5aa562409c66b3b3 + ["schema" "namespace" "relation"] 0xca186c6bd1825179)) (reads (output :snapshot1 0xcd3b9ab2de079088) (output :snapshot2 0xd1e6d3706be27c8) From a93518ae59a0f881850a2a834f07cc8cbc013a48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nikolas=20G=C3=B6bel?= Date: Wed, 25 Feb 2026 23:20:22 +0100 Subject: [PATCH 8/8] Remove stray binary --- tests/lqp/snapshot.bin | Bin 1184 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 tests/lqp/snapshot.bin diff --git a/tests/lqp/snapshot.bin b/tests/lqp/snapshot.bin deleted file mode 100644 index 122c14262a7cbefd45827048e1091b0a39cd562a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1184 zcmb_bU2D@&819Kn+q|1FUZ)#zOpVixl1WaIHrWIjiYUGF3&xz3bWOXkrmagVR=iRW z5ih(Rf*=gU8(~8b#i2Li)cJ8Ocq0riyxBkSv{~8=9C#s|kmv9|&pGeMdEjRP-Vk_A z;3a`>5WI?2^X96)hyBuC*aL!a_d(*v^5XGzjJu7TUC84>X$S^c;Qh#I+;E3>W3piR zR^IY#Z+6ahEfgx2YkM_o*2d(5UABCuS`kl1E{Pl) z)wk24*oJBcYVd`JPdu#gkO028V3jD|gd6OH@9S@;hKnDcq6-4-0&*QWF&4lEau~x) z;srR8Jq*1pom_3faUI{eX6Njym_R;I#IXyxUIMA?=+3kTcB6po_Bp#;uHq|Bdcld$ zIe1L)5pfD~-YMlgr&O^6Sg!;dpfWWSs#9uedPdPR{wm_XAErZRM<$(SmodO8iNJoax#nz90#tjHAiCy7Ml6p>UilO@N_ z^L4*CW=?lmb-yb11LqV_5LQ<pK9@sfrOA=WczQFAsbO2x?3`1U*ec zSSzEP`MmslWAn+WfRc(yeX63S#}vxeMMartt!cbN@HS!7TUjYSoXjsxGl=)T{<`dz z*Ki&jEP)+~;#4qDt25ht6XK+J0{SK}s&0+cf}`2toky7uM{kJ@rVXDEgJBC842xwj zEQ-OuCET$s6U`;HH{MVJdZM%)(BSR^zc vJR^`xU15F>O&qCf5ZVTYEdxg?8HFwLLdU$&HZQv)?8N`g7~@HTT$20&@;*t5