From 956b828ab25345756fa38cc1fdebcf0658d7ec55 Mon Sep 17 00:00:00 2001 From: Henrik Barthels <25176271+hbarthels@users.noreply.github.com> Date: Sat, 11 Jul 2026 00:18:35 +0200 Subject: [PATCH 1/2] Accept bare int for int32 config fields in parser MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `_extract_value_int32` only accepted a `Value` whose oneof was `int32_value`, so a bare integer literal (parsed as int64 `int_value`, e.g. `-1` rather than `-1i32`) silently fell back to the field default. Concretely `(csv_config {:csv_header_row -1})` yielded `header_row = 1` — the opposite meaning — with no error. Fix `_extract_value_int32` in the grammar to also accept `int_value` via a checked narrowing conversion (Julia `Int32(...)` throws on overflow), and regenerate the Python/Julia/Go parsers. `csv_header_row` is the only config field using this helper. Add regression tests asserting a bare `-1` parses identically to `-1i32`. Co-Authored-By: Claude Opus 4.8 --- meta/src/meta/grammar.y | 2 + sdks/go/src/parser.go | 287 +++++++++--------- .../LogicalQueryProtocol.jl/src/parser.jl | 243 +++++++-------- .../test/parser_tests.jl | 18 ++ sdks/python/src/lqp/gen/parser.py | 286 ++++++++--------- sdks/python/tests/test_parser.py | 21 ++ 6 files changed, 459 insertions(+), 398 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index e59d3a38..35d274ae 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -1458,6 +1458,8 @@ export_iceberg_config def _extract_value_int32(value: Optional[logic.Value], default: int) -> Int32: if value is not None and builtin.has_proto_field(builtin.unwrap_option(value), 'int32_value'): return builtin.unwrap_option(value).int32_value + if value is not None and builtin.has_proto_field(builtin.unwrap_option(value), 'int_value'): + return builtin.int64_to_int32(builtin.unwrap_option(value).int_value) return builtin.int64_to_int32(default) diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index dc0ac259..90a130d8 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -660,201 +660,206 @@ func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { return value.GetInt32Value() } _ = _t2212 + var _t2213 interface{} + if (value != nil && hasProtoField(value, "int_value")) { + return int32(value.GetIntValue()) + } + _ = _t2213 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2213 interface{} + var _t2214 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2213 + _ = _t2214 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2214 interface{} + var _t2215 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2214 + _ = _t2215 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2215 interface{} + var _t2216 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2215 + _ = _t2216 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2216 interface{} + var _t2217 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2216 + _ = _t2217 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2217 interface{} + var _t2218 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2217 + _ = _t2218 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2218 interface{} + var _t2219 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2218 + _ = _t2219 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2219 interface{} + var _t2220 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2219 + _ = _t2220 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2220 interface{} + var _t2221 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2220 + _ = _t2221 return nil } func (p *Parser) construct_non_cdc_relations(targets []*pb.TargetRelation) *pb.TargetRelations { - _t2221 := &pb.PlainTargets{Targets: targets} - _t2222 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2222.Body = &pb.TargetRelations_Plain{Plain: _t2221} - return _t2222 + _t2222 := &pb.PlainTargets{Targets: targets} + _t2223 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2223.Body = &pb.TargetRelations_Plain{Plain: _t2222} + return _t2223 } func (p *Parser) construct_cdc_relations(inserts []*pb.TargetRelation, deletes []*pb.TargetRelation) *pb.TargetRelations { - _t2223 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} - _t2224 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2224.Body = &pb.TargetRelations_Cdc{Cdc: _t2223} - return _t2224 + _t2224 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} + _t2225 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2225.Body = &pb.TargetRelations_Cdc{Cdc: _t2224} + return _t2225 } func (p *Parser) construct_relations(keys []*pb.NamedColumn, body *pb.TargetRelations) *pb.TargetRelations { - var _t2225 interface{} + var _t2226 interface{} if hasProtoField(body, "plain") { - _t2226 := &pb.TargetRelations{Keys: keys} - _t2226.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} - return _t2226 + _t2227 := &pb.TargetRelations{Keys: keys} + _t2227.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} + return _t2227 } - _ = _t2225 - _t2227 := &pb.TargetRelations{Keys: keys} - _t2227.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} - return _t2227 + _ = _t2226 + _t2228 := &pb.TargetRelations{Keys: keys} + _t2228.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} + return _t2228 } func (p *Parser) construct_csv_data(locator *pb.CSVLocator, config *pb.CSVConfig, columns_opt []*pb.GNFColumn, relations_opt *pb.TargetRelations, asof string) *pb.CSVData { - _t2228 := columns_opt + _t2229 := columns_opt if columns_opt == nil { - _t2228 = []*pb.GNFColumn{} + _t2229 = []*pb.GNFColumn{} } - _t2229 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2228, Asof: asof, Relations: relations_opt} - return _t2229 + _t2230 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2229, Asof: asof, Relations: relations_opt} + return _t2230 } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2230 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2230 - _t2231 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2231 - _t2232 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2232 - _t2233 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2233 - _t2234 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2234 - _t2235 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2235 - _t2236 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2236 - _t2237 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2237 - _t2238 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2238 - _t2239 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2239 - _t2240 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2240 - _t2241 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2241 - _t2242 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2242 - _t2243 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} - return _t2243 + _t2231 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2231 + _t2232 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2232 + _t2233 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2233 + _t2234 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2234 + _t2235 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2235 + _t2236 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2236 + _t2237 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2237 + _t2238 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2238 + _t2239 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2239 + _t2240 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2240 + _t2241 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2241 + _t2242 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2242 + _t2243 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2243 + _t2244 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} + return _t2244 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2244 interface{} + var _t2245 interface{} if storage_integration_opt == nil { return nil } - _ = _t2244 + _ = _t2245 config := dictFromList(storage_integration_opt) - _t2245 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2246 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2247 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2248 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2249 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2250 := &pb.StorageIntegration{Provider: _t2245, AzureSasToken: _t2246, S3Region: _t2247, S3AccessKeyId: _t2248, S3SecretAccessKey: _t2249} - return _t2250 + _t2246 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2247 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2248 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2249 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2250 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2251 := &pb.StorageIntegration{Provider: _t2246, AzureSasToken: _t2247, S3Region: _t2248, S3AccessKeyId: _t2249, S3SecretAccessKey: _t2250} + return _t2251 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2251 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2251 - _t2252 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2252 - _t2253 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2253 - _t2254 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2254 - _t2255 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2255 - _t2256 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2256 - _t2257 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2257 - _t2258 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2258 - _t2259 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2259 - _t2260 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2252 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2252 + _t2253 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2253 + _t2254 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2254 + _t2255 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2255 + _t2256 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2256 + _t2257 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2257 + _t2258 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2258 + _t2259 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2259 + _t2260 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2260 + _t2261 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2260.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2261.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2260.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2261.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2260 - _t2261 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2261 + relation_locator := _t2261 + _t2262 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2262 } func (p *Parser) default_configure() *pb.Configure { - _t2262 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2262 - _t2263 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2263 + _t2263 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2263 + _t2264 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2264 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -876,66 +881,66 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2264 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2264 - _t2265 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2265 - _t2266 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2266 + _t2265 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2265 + _t2266 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2266 + _t2267 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2267 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2267 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2267 - _t2268 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2268 - _t2269 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2269 - _t2270 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2270 - _t2271 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2271 - _t2272 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2272 - _t2273 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2273 - _t2274 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)} - return _t2274 + _t2268 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2268 + _t2269 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2269 + _t2270 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2270 + _t2271 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2271 + _t2272 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2272 + _t2273 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2273 + _t2274 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2274 + _t2275 := &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 _t2275 } func (p *Parser) construct_export_csv_config_with_location(location []interface{}, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2275 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} - return _t2275 + _t2276 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} + return _t2276 } func (p *Parser) construct_iceberg_catalog_config(catalog_uri string, scope_opt *string, property_pairs [][]interface{}, auth_property_pairs [][]interface{}) *pb.IcebergCatalogConfig { props := stringMapFromPairs(property_pairs) auth_props := stringMapFromPairs(auth_property_pairs) - _t2276 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2276 + _t2277 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2277 } func (p *Parser) construct_iceberg_data(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, columns []*pb.GNFColumn, from_snapshot_opt *string, to_snapshot_opt *string, returns_delta bool) *pb.IcebergData { - _t2277 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2277 + _t2278 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2278 } func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, table_def *pb.RelationId, table_property_pairs [][]interface{}, config_dict [][]interface{}) *pb.ExportIcebergConfig { - _t2278 := config_dict + _t2279 := config_dict if config_dict == nil { - _t2278 = [][]interface{}{} - } - cfg := dictFromList(_t2278) - _t2279 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2279 - _t2280 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2280 - _t2281 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2281 + _t2279 = [][]interface{}{} + } + cfg := dictFromList(_t2279) + _t2280 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2280 + _t2281 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2281 + _t2282 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2282 table_props := stringMapFromPairs(table_property_pairs) - _t2282 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2282 + _t2283 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2283 } // --- Parse functions --- diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 97bbbe01..c0ba1682 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -374,6 +374,11 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V else _t2199 = nothing end + if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) + return Int32(_get_oneof_field(value, :int_value)) + else + _t2200 = nothing + end return Int32(default) end @@ -381,7 +386,7 @@ function _extract_value_int64(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2200 = nothing + _t2201 = nothing end return default end @@ -390,7 +395,7 @@ function _extract_value_string(parser::ParserState, value::Union{Nothing, Proto. if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return _get_oneof_field(value, :string_value) else - _t2201 = nothing + _t2202 = nothing end return default end @@ -399,7 +404,7 @@ function _extract_value_boolean(parser::ParserState, value::Union{Nothing, Proto if (!isnothing(value) && _has_proto_field(value, Symbol("boolean_value"))) return _get_oneof_field(value, :boolean_value) else - _t2202 = nothing + _t2203 = nothing end return default end @@ -408,7 +413,7 @@ function _extract_value_string_list(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return String[_get_oneof_field(value, :string_value)] else - _t2203 = nothing + _t2204 = nothing end return default end @@ -417,7 +422,7 @@ function _try_extract_value_int64(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2204 = nothing + _t2205 = nothing end return nothing end @@ -426,7 +431,7 @@ function _try_extract_value_float64(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("float_value"))) return _get_oneof_field(value, :float_value) else - _t2205 = nothing + _t2206 = nothing end return nothing end @@ -435,7 +440,7 @@ function _try_extract_value_bytes(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return Vector{UInt8}(_get_oneof_field(value, :string_value)) else - _t2206 = nothing + _t2207 = nothing end return nothing end @@ -444,118 +449,118 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2207 = nothing + _t2208 = nothing end return nothing end function construct_non_cdc_relations(parser::ParserState, targets::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2208 = Proto.PlainTargets(targets=targets) - _t2209 = Proto.TargetRelations(body=OneOf(:plain, _t2208), keys=Proto.NamedColumn[]) - return _t2209 + _t2209 = Proto.PlainTargets(targets=targets) + _t2210 = Proto.TargetRelations(body=OneOf(:plain, _t2209), keys=Proto.NamedColumn[]) + return _t2210 end function construct_cdc_relations(parser::ParserState, inserts::Vector{Proto.TargetRelation}, deletes::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2210 = Proto.CDCTargets(inserts=inserts, deletes=deletes) - _t2211 = Proto.TargetRelations(body=OneOf(:cdc, _t2210), keys=Proto.NamedColumn[]) - return _t2211 + _t2211 = Proto.CDCTargets(inserts=inserts, deletes=deletes) + _t2212 = Proto.TargetRelations(body=OneOf(:cdc, _t2211), keys=Proto.NamedColumn[]) + return _t2212 end function construct_relations(parser::ParserState, keys::Vector{Proto.NamedColumn}, body::Proto.TargetRelations)::Proto.TargetRelations if _has_proto_field(body, Symbol("plain")) - _t2213 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys) - return _t2213 + _t2214 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys) + return _t2214 else - _t2212 = nothing + _t2213 = nothing end - _t2214 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys) - return _t2214 + _t2215 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys) + return _t2215 end function construct_csv_data(parser::ParserState, locator::Proto.CSVLocator, config::Proto.CSVConfig, columns_opt::Union{Nothing, Vector{Proto.GNFColumn}}, relations_opt::Union{Nothing, Proto.TargetRelations}, asof::String)::Proto.CSVData - _t2215 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) - return _t2215 + _t2216 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) + return _t2216 end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}}, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.CSVConfig config = Dict(config_dict) - _t2216 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2216 - _t2217 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2217 - _t2218 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2218 - _t2219 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2219 - _t2220 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2220 - _t2221 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2221 - _t2222 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2222 - _t2223 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2223 - _t2224 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2224 - _t2225 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2225 - _t2226 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2226 - _t2227 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2227 - _t2228 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2228 - _t2229 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2229 + _t2217 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2217 + _t2218 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2218 + _t2219 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2219 + _t2220 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2220 + _t2221 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2221 + _t2222 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2222 + _t2223 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2223 + _t2224 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2224 + _t2225 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2225 + _t2226 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2226 + _t2227 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2227 + _t2228 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2228 + _t2229 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2229 + _t2230 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2230 end function construct_csv_storage_integration(parser::ParserState, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Union{Nothing, Proto.StorageIntegration} if isnothing(storage_integration_opt) return nothing else - _t2230 = nothing + _t2231 = nothing end config = Dict(storage_integration_opt) - _t2231 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2232 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2233 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2234 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2235 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2236 = Proto.StorageIntegration(provider=_t2231, azure_sas_token=_t2232, s3_region=_t2233, s3_access_key_id=_t2234, s3_secret_access_key=_t2235) - return _t2236 + _t2232 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2233 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2234 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2235 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2236 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2237 = Proto.StorageIntegration(provider=_t2232, azure_sas_token=_t2233, s3_region=_t2234, s3_access_key_id=_t2235, s3_secret_access_key=_t2236) + return _t2237 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) - _t2237 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2237 - _t2238 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2238 - _t2239 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2239 - _t2240 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2240 - _t2241 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2241 - _t2242 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2242 - _t2243 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2243 - _t2244 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2244 - _t2245 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2245 - _t2246 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height) - relation_locator = _t2246 - _t2247 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2247 + _t2238 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2238 + _t2239 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2239 + _t2240 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2240 + _t2241 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2241 + _t2242 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2242 + _t2243 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2243 + _t2244 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2244 + _t2245 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2245 + _t2246 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2246 + _t2247 = 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 = _t2247 + _t2248 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2248 end function default_configure(parser::ParserState)::Proto.Configure - _t2248 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2248 - _t2249 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2249 + _t2249 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2249 + _t2250 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2250 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -577,62 +582,62 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2250 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2250 - _t2251 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2251 - _t2252 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2252 + _t2251 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2251 + _t2252 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2252 + _t2253 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2253 end function construct_export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t2253 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2253 - _t2254 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2254 - _t2255 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2255 - _t2256 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2256 - _t2257 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2257 - _t2258 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2258 - _t2259 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2259 - _t2260 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2260 + _t2254 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2254 + _t2255 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2255 + _t2256 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2256 + _t2257 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2257 + _t2258 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2258 + _t2259 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2259 + _t2260 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2260 + _t2261 = 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 _t2261 end function construct_export_csv_config_with_location(parser::ParserState, location::Tuple{String, String}, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2261 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) - return _t2261 + _t2262 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) + return _t2262 end function construct_iceberg_catalog_config(parser::ParserState, catalog_uri::String, scope_opt::Union{Nothing, String}, property_pairs::Vector{Tuple{String, String}}, auth_property_pairs::Vector{Tuple{String, String}})::Proto.IcebergCatalogConfig props = Dict(property_pairs) auth_props = Dict(auth_property_pairs) - _t2262 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2262 + _t2263 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2263 end function construct_iceberg_data(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, columns::Vector{Proto.GNFColumn}, from_snapshot_opt::Union{Nothing, String}, to_snapshot_opt::Union{Nothing, String}, returns_delta::Bool)::Proto.IcebergData - _t2263 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) - return _t2263 + _t2264 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) + return _t2264 end function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, table_def::Proto.RelationId, table_property_pairs::Vector{Tuple{String, String}}, config_dict::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.ExportIcebergConfig cfg = Dict((!isnothing(config_dict) ? config_dict : Tuple{String, Proto.Value}[])) - _t2264 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2264 - _t2265 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2265 - _t2266 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2266 + _t2265 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2265 + _t2266 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2266 + _t2267 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2267 table_props = Dict(table_property_pairs) - _t2267 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2267 + _t2268 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2268 end # --- Parse functions --- diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/parser_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/parser_tests.jl index b53b18d2..68a8e184 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/parser_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/parser_tests.jl @@ -161,6 +161,24 @@ end ) end +@testitem "Parser - int32 config field accepts bare int" setup=[ParserSetup] begin + # A bare integer literal parses to `int_value`, an i32-suffixed one to + # `int32_value`. Both must land in the int32 `header_row` field identically; + # regression against silently falling back to the field default (1). + csv_fragment(header_row) = """ + (fragment :f + (csv_data + (csv_locator (paths "s3://bucket/data.csv")) + (csv_config { :csv_header_row $header_row }) + (columns (column "c" :c [INT])) + (asof "2025-01-01T00:00:00Z"))) + """ + bare = Parser.parse_fragment(csv_fragment("-1")) + suffixed = Parser.parse_fragment(csv_fragment("-1i32")) + @test bare == suffixed + @test bare != Parser.parse_fragment(csv_fragment("1")) +end + @testitem "Parser - SYMBOL lexer regex" setup=[ParserSetup] begin # Hyphen must be a literal character, not part of a range lexer = Lexer("my-relation") diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index f8d74db1..35782651 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -432,9 +432,6 @@ def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> i return value.int32_value else: _t2200 = None - return int(default) - - def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None _t2201 = value.HasField("int_value") @@ -442,201 +439,214 @@ def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> i _t2201 = False if _t2201: assert value is not None - return value.int_value + return int(value.int_value) else: _t2202 = None - return default + return int(default) - def _extract_value_string(self, value: logic_pb2.Value | None, default: str) -> str: + def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2203 = value.HasField("string_value") + _t2203 = value.HasField("int_value") else: _t2203 = False if _t2203: assert value is not None - return value.string_value + return value.int_value else: _t2204 = None return default - def _extract_value_boolean(self, value: logic_pb2.Value | None, default: bool) -> bool: + def _extract_value_string(self, value: logic_pb2.Value | None, default: str) -> str: if value is not None: assert value is not None - _t2205 = value.HasField("boolean_value") + _t2205 = value.HasField("string_value") else: _t2205 = False if _t2205: assert value is not None - return value.boolean_value + return value.string_value else: _t2206 = None return default - def _extract_value_string_list(self, value: logic_pb2.Value | None, default: Sequence[str]) -> Sequence[str]: + def _extract_value_boolean(self, value: logic_pb2.Value | None, default: bool) -> bool: if value is not None: assert value is not None - _t2207 = value.HasField("string_value") + _t2207 = value.HasField("boolean_value") else: _t2207 = False if _t2207: assert value is not None - return [value.string_value] + return value.boolean_value else: _t2208 = None return default - def _try_extract_value_int64(self, value: logic_pb2.Value | None) -> int | None: + def _extract_value_string_list(self, value: logic_pb2.Value | None, default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t2209 = value.HasField("int_value") + _t2209 = value.HasField("string_value") else: _t2209 = False if _t2209: assert value is not None - return value.int_value + return [value.string_value] else: _t2210 = None - return None + return default - def _try_extract_value_float64(self, value: logic_pb2.Value | None) -> float | None: + def _try_extract_value_int64(self, value: logic_pb2.Value | None) -> int | None: if value is not None: assert value is not None - _t2211 = value.HasField("float_value") + _t2211 = value.HasField("int_value") else: _t2211 = False if _t2211: assert value is not None - return value.float_value + return value.int_value else: _t2212 = None return None - def _try_extract_value_bytes(self, value: logic_pb2.Value | None) -> bytes | None: + def _try_extract_value_float64(self, value: logic_pb2.Value | None) -> float | None: if value is not None: assert value is not None - _t2213 = value.HasField("string_value") + _t2213 = value.HasField("float_value") else: _t2213 = False if _t2213: assert value is not None - return value.string_value.encode() + return value.float_value else: _t2214 = None return None - def _try_extract_value_uint128(self, value: logic_pb2.Value | None) -> logic_pb2.UInt128Value | None: + def _try_extract_value_bytes(self, value: logic_pb2.Value | None) -> bytes | None: if value is not None: assert value is not None - _t2215 = value.HasField("uint128_value") + _t2215 = value.HasField("string_value") else: _t2215 = False if _t2215: assert value is not None - return value.uint128_value + return value.string_value.encode() else: _t2216 = None return None + def _try_extract_value_uint128(self, value: logic_pb2.Value | None) -> logic_pb2.UInt128Value | None: + if value is not None: + assert value is not None + _t2217 = value.HasField("uint128_value") + else: + _t2217 = False + if _t2217: + assert value is not None + return value.uint128_value + else: + _t2218 = None + return None + def construct_non_cdc_relations(self, targets: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2217 = logic_pb2.PlainTargets(targets=targets) - _t2218 = logic_pb2.TargetRelations(keys=[], plain=_t2217) - return _t2218 + _t2219 = logic_pb2.PlainTargets(targets=targets) + _t2220 = logic_pb2.TargetRelations(keys=[], plain=_t2219) + return _t2220 def construct_cdc_relations(self, inserts: Sequence[logic_pb2.TargetRelation], deletes: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2219 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) - _t2220 = logic_pb2.TargetRelations(keys=[], cdc=_t2219) - return _t2220 + _t2221 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) + _t2222 = logic_pb2.TargetRelations(keys=[], cdc=_t2221) + return _t2222 def construct_relations(self, keys: Sequence[logic_pb2.NamedColumn], body: logic_pb2.TargetRelations) -> logic_pb2.TargetRelations: if body.HasField("plain"): - _t2222 = logic_pb2.TargetRelations(keys=keys, plain=body.plain) - return _t2222 + _t2224 = logic_pb2.TargetRelations(keys=keys, plain=body.plain) + return _t2224 else: - _t2221 = None - _t2223 = logic_pb2.TargetRelations(keys=keys, cdc=body.cdc) - return _t2223 + _t2223 = None + _t2225 = logic_pb2.TargetRelations(keys=keys, cdc=body.cdc) + return _t2225 def construct_csv_data(self, locator: logic_pb2.CSVLocator, config: logic_pb2.CSVConfig, columns_opt: Sequence[logic_pb2.GNFColumn] | None, relations_opt: logic_pb2.TargetRelations | None, asof: str) -> logic_pb2.CSVData: - _t2224 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) - return _t2224 + _t2226 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) + return _t2226 def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]], storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2225 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2225 - _t2226 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2226 - _t2227 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2227 - _t2228 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2228 - _t2229 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2229 - _t2230 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2230 - _t2231 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2231 - _t2232 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2232 - _t2233 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2233 - _t2234 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2234 - _t2235 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2235 - _t2236 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2236 - _t2237 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2237 - _t2238 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2238 + _t2227 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2227 + _t2228 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2228 + _t2229 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2229 + _t2230 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2230 + _t2231 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2231 + _t2232 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2232 + _t2233 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2233 + _t2234 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2234 + _t2235 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2235 + _t2236 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2236 + _t2237 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2237 + _t2238 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2238 + _t2239 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2239 + _t2240 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2240 def construct_csv_storage_integration(self, storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.StorageIntegration | None: if storage_integration_opt is None: return None else: - _t2239 = None + _t2241 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2240 = self._extract_value_string(config.get("provider"), "") - _t2241 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2242 = self._extract_value_string(config.get("s3_region"), "") - _t2243 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2244 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2245 = logic_pb2.StorageIntegration(provider=_t2240, azure_sas_token=_t2241, s3_region=_t2242, s3_access_key_id=_t2243, s3_secret_access_key=_t2244) - return _t2245 + _t2242 = self._extract_value_string(config.get("provider"), "") + _t2243 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2244 = self._extract_value_string(config.get("s3_region"), "") + _t2245 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2246 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2247 = logic_pb2.StorageIntegration(provider=_t2242, azure_sas_token=_t2243, s3_region=_t2244, s3_access_key_id=_t2245, s3_secret_access_key=_t2246) + return _t2247 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) - _t2246 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2246 - _t2247 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2247 - _t2248 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2248 - _t2249 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2249 - _t2250 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2250 - _t2251 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2251 - _t2252 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2252 - _t2253 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2253 - _t2254 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2254 - _t2255 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2255 - _t2256 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2256 + _t2248 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2248 + _t2249 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2249 + _t2250 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2250 + _t2251 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2251 + _t2252 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2252 + _t2253 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2253 + _t2254 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2254 + _t2255 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2255 + _t2256 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2256 + _t2257 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2257 + _t2258 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2258 def default_configure(self) -> transactions_pb2.Configure: - _t2257 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2257 - _t2258 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2258 + _t2259 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2259 + _t2260 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2260 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -653,57 +663,57 @@ 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 - _t2259 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2259 - _t2260 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2260 - _t2261 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2261 + _t2261 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2261 + _t2262 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2262 + _t2263 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2263 def construct_export_csv_config(self, path: str, columns: Sequence[transactions_pb2.ExportCSVColumn], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.ExportCSVConfig: config = dict(config_dict) - _t2262 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2262 - _t2263 = self._extract_value_string(config.get("compression"), "") - compression = _t2263 - _t2264 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2264 - _t2265 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2265 - _t2266 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2266 - _t2267 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2267 - _t2268 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2268 - _t2269 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2269 + _t2264 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2264 + _t2265 = self._extract_value_string(config.get("compression"), "") + compression = _t2265 + _t2266 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2266 + _t2267 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2267 + _t2268 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2268 + _t2269 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2269 + _t2270 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2270 + _t2271 = 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 _t2271 def construct_export_csv_config_with_location(self, location: tuple[str, str], csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2270 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) - return _t2270 + _t2272 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) + return _t2272 def construct_iceberg_catalog_config(self, catalog_uri: str, scope_opt: str | None, property_pairs: Sequence[tuple[str, str]], auth_property_pairs: Sequence[tuple[str, str]]) -> logic_pb2.IcebergCatalogConfig: props = dict(property_pairs) auth_props = dict(auth_property_pairs) - _t2271 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2271 + _t2273 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2273 def construct_iceberg_data(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, columns: Sequence[logic_pb2.GNFColumn], from_snapshot_opt: str | None, to_snapshot_opt: str | None, returns_delta: bool) -> logic_pb2.IcebergData: - _t2272 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) - return _t2272 + _t2274 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) + return _t2274 def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, table_def: logic_pb2.RelationId, table_property_pairs: Sequence[tuple[str, str]], config_dict: Sequence[tuple[str, logic_pb2.Value]] | None) -> transactions_pb2.ExportIcebergConfig: cfg = dict((config_dict if config_dict is not None else [])) - _t2273 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2273 - _t2274 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2274 - _t2275 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2275 + _t2275 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2275 + _t2276 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2276 + _t2277 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2277 table_props = dict(table_property_pairs) - _t2276 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2276 + _t2278 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2278 # --- Parse methods --- diff --git a/sdks/python/tests/test_parser.py b/sdks/python/tests/test_parser.py index ff2b4bcc..170d749b 100644 --- a/sdks/python/tests/test_parser.py +++ b/sdks/python/tests/test_parser.py @@ -68,6 +68,27 @@ def test_parse_transaction_rejects_fragment(): parse_transaction(_SIMPLE_FRAGMENT) +def _csv_fragment(header_row: str) -> str: + return f""" + (fragment :f + (csv_data + (csv_locator (paths "s3://bucket/data.csv")) + (csv_config {{ :csv_header_row {header_row} }}) + (columns (column "c" :c [INT])) + (asof "2025-01-01T00:00:00Z"))) + """ + + +def test_int32_config_accepts_bare_int(): + # A bare integer literal parses to `int_value`, an i32-suffixed one to + # `int32_value`. Both must land in the int32 `header_row` field identically; + # regression against silently falling back to the field default (1). + bare, _ = parse_fragment(_csv_fragment("-1")) + suffixed, _ = parse_fragment(_csv_fragment("-1i32")) + assert bare.declarations[0].data.csv_data.config.header_row == -1 + assert bare == suffixed + + class TestSymbolLexing: """Tests for SYMBOL token regex — hyphen must be literal, not a range.""" From e608fc674918baf1df1bcef5710e42f83783cccb Mon Sep 17 00:00:00 2001 From: Henrik Barthels <25176271+hbarthels@users.noreply.github.com> Date: Sat, 11 Jul 2026 00:18:35 +0200 Subject: [PATCH 2/2] Bump version to v0.5.6 Co-Authored-By: Claude Opus 4.8 --- sdks/julia/LogicalQueryProtocol.jl/Project.toml | 2 +- sdks/python/pyproject.toml | 2 +- sdks/python/uv.lock | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/sdks/julia/LogicalQueryProtocol.jl/Project.toml b/sdks/julia/LogicalQueryProtocol.jl/Project.toml index 5ba5f719..8dc011c5 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/Project.toml +++ b/sdks/julia/LogicalQueryProtocol.jl/Project.toml @@ -1,6 +1,6 @@ name = "LogicalQueryProtocol" uuid = "a92373ee-6cc4-4662-ae66-0c99a03ebae1" -version = "0.5.5" +version = "0.5.6" authors = ["RelationalAI"] [deps] diff --git a/sdks/python/pyproject.toml b/sdks/python/pyproject.toml index c1d4f3b9..5e9f1c24 100644 --- a/sdks/python/pyproject.toml +++ b/sdks/python/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "lqp" -version = "0.5.5" +version = "0.5.6" description = "Validate and translate Logical Query Protocol (LQP) S-expressions into Protobuf" readme = "README.md" authors = [ diff --git a/sdks/python/uv.lock b/sdks/python/uv.lock index 37e64873..9acfe4af 100644 --- a/sdks/python/uv.lock +++ b/sdks/python/uv.lock @@ -62,7 +62,7 @@ wheels = [ [[package]] name = "lqp" -version = "0.5.3" +version = "0.5.6" source = { editable = "." } dependencies = [ { name = "protobuf" },