Merge branch 'main' of github.com:RelationalAI/logical-query-protocol into vs-iceberg-base-relations

Author: vustef

Makefile

@@ -109,7 +109,7 @@ force-protobuf:
 	mkdir -p $(GO_PROTO_DIR)
 	cp gen/go/relationalai/lqp/v1/*.pb.go $(GO_PROTO_DIR)/
 	rm -rf gen/python gen/go
-	cd sdks/julia && julia --project=LogicalQueryProtocol.jl generate_proto.jl
+	cd sdks/julia && julia --startup-file=no --project=LogicalQueryProtocol.jl generate_proto.jl
 
 $(PY_PROTO_GENERATED) $(GO_PROTO_GENERATED): $(PROTO_FILES)
 	buf lint
@@ -130,7 +130,7 @@ $(PY_PROTO_GENERATED) $(GO_PROTO_GENERATED): $(PROTO_FILES)
 $(JL_PROTO_GENERATED): $(PROTO_FILES)
 	buf lint
 	buf breaking --against ".git#branch=main,subdir=proto"
-	cd sdks/julia && julia --project=LogicalQueryProtocol.jl generate_proto.jl
+	cd sdks/julia && julia --startup-file=no --project=LogicalQueryProtocol.jl generate_proto.jl
 
 # ---------- parser generation ----------
 
@@ -203,7 +203,7 @@ update-snapshots: $(PY_PARSER) $(PY_PROTO_GENERATED)
 	cd sdks/python && uv run python -m pytest --snapshot-update
 
 test-julia: $(JL_PARSER) $(JL_PROTO_GENERATED)
-	cd sdks/julia && julia --project=LogicalQueryProtocol.jl -e 'using Pkg; Pkg.test()'
+	cd sdks/julia && julia --startup-file=no --project=LogicalQueryProtocol.jl -e 'using Pkg; Pkg.test()'
 
 test-go: $(GO_PARSER) $(GO_PROTO_GENERATED)
 	cd sdks/go && go test ./test/...

meta/src/meta/codegen_go.py

@@ -195,6 +195,7 @@ def none_generator(
         terminal_field_map = {
             "INT": "i64",
             "INT32": "i32",
+            "UINT32": "u32",
             "FLOAT": "f64",
             "FLOAT32": "f32",
             "STRING": "str",
@@ -939,6 +940,7 @@ def format_literal_token_spec(self, escaped_literal: str) -> str:
         "STRING": ("scanString", "kindString", "str"),
         "INT": ("scanInt", "kindInt64", "i64"),
         "INT32": ("scanInt32", "kindInt32", "i32"),
+        "UINT32": ("scanUint32", "kindUint32", "u32"),
         "FLOAT": ("scanFloat", "kindFloat64", "f64"),
         "FLOAT32": ("scanFloat32", "kindFloat32", "f32"),
         "UINT128": ("scanUint128", "kindUint128", "uint128"),

meta/src/meta/codegen_templates.py

@@ -43,6 +43,7 @@ class BuiltinTemplate:
     "length": BuiltinTemplate("len({0})"),
     "unwrap_option_or": BuiltinTemplate("({0} if {0} is not None else {1})"),
     "int64_to_int32": BuiltinTemplate("int({0})"),
+    "int64_to_uint32": BuiltinTemplate("int({0})"),
     "float64_to_float32": BuiltinTemplate("float({0})"),
     "to_ptr_int64": BuiltinTemplate("{0}"),  # Python doesn't need pointers
     "to_ptr_string": BuiltinTemplate("{0}"),
@@ -85,6 +86,7 @@ class BuiltinTemplate:
     "try_flat_io": BuiltinTemplate("self._try_flat({0}, {1})"),
     "format_int64": BuiltinTemplate("str({0})"),
     "format_int32": BuiltinTemplate("(str({0}) + 'i32')"),
+    "format_uint32": BuiltinTemplate("(str({0}) + 'u32')"),
     "format_float32": BuiltinTemplate("(self.format_float32_value({0}) + 'f32')"),
     "format_float64": BuiltinTemplate("str({0})"),
     "format_string": BuiltinTemplate("self.format_string_value({0})"),
@@ -97,6 +99,7 @@ class BuiltinTemplate:
     "to_string": BuiltinTemplate("str({0})"),
     # Type conversions used by pretty printer
     "int32_to_int64": BuiltinTemplate("int({0})"),
+    "uint32_to_int64": BuiltinTemplate("int({0})"),
     "float32_to_float64": BuiltinTemplate("float({0})"),
     "is_empty": BuiltinTemplate("len({0}) == 0"),
     "decode_string": BuiltinTemplate("{0}.decode('utf-8')"),
@@ -140,6 +143,7 @@ class BuiltinTemplate:
     "length": BuiltinTemplate("length({0})"),
     "unwrap_option_or": BuiltinTemplate("(!isnothing({0}) ? {0} : {1})"),
     "int64_to_int32": BuiltinTemplate("Int32({0})"),
+    "int64_to_uint32": BuiltinTemplate("UInt32({0})"),
     "float64_to_float32": BuiltinTemplate("Float32({0})"),
     "to_ptr_int64": BuiltinTemplate("{0}"),  # Julia doesn't need pointers
     "to_ptr_string": BuiltinTemplate("{0}"),
@@ -178,6 +182,7 @@ class BuiltinTemplate:
     "try_flat_io": BuiltinTemplate("try_flat(pp, {0}, {1})"),
     "format_int64": BuiltinTemplate("format_int(pp, {0})"),
     "format_int32": BuiltinTemplate('(string(Int64({0})) * "i32")'),
+    "format_uint32": BuiltinTemplate('(string(Int64({0})) * "u32")'),
     "format_float32": BuiltinTemplate('(lowercase(string({0})) * "f32")'),
     "format_float64": BuiltinTemplate("format_float(pp, {0})"),
     "format_string": BuiltinTemplate("format_string(pp, {0})"),
@@ -190,6 +195,7 @@ class BuiltinTemplate:
     "to_string": BuiltinTemplate("string({0})"),
     # Type conversions used by pretty printer
     "int32_to_int64": BuiltinTemplate("Int64({0})"),
+    "uint32_to_int64": BuiltinTemplate("Int64({0})"),
     "float32_to_float64": BuiltinTemplate("Float64({0})"),
     "is_empty": BuiltinTemplate("isempty({0})"),
     "decode_string": BuiltinTemplate("String(copy({0}))"),
@@ -236,6 +242,7 @@ class BuiltinTemplate:
     # unwrap_option_or is handled specially in codegen_go.py due to Go's lack of ternary
     "unwrap_option_or": BuiltinTemplate("{0}"),  # Placeholder - overridden in codegen
     "int64_to_int32": BuiltinTemplate("int32({0})"),
+    "int64_to_uint32": BuiltinTemplate("uint32({0})"),
     "float64_to_float32": BuiltinTemplate("float32({0})"),
     "to_ptr_int64": BuiltinTemplate("ptrInt64({0})"),
     "to_ptr_string": BuiltinTemplate("ptrString({0})"),
@@ -273,6 +280,7 @@ class BuiltinTemplate:
     "try_flat_io": BuiltinTemplate("p.tryFlat({0}, func() {{ {1}({0}) }})"),
     "format_int64": BuiltinTemplate('fmt.Sprintf("%d", {0})'),
     "format_int32": BuiltinTemplate('fmt.Sprintf("%di32", {0})'),
+    "format_uint32": BuiltinTemplate('fmt.Sprintf("%du32", {0})'),
     "format_float32": BuiltinTemplate(
         "fmt.Sprintf(\"%sf32\", strconv.FormatFloat(float64({0}), 'g', -1, 32))"
     ),
@@ -287,6 +295,7 @@ class BuiltinTemplate:
     "to_string": BuiltinTemplate('fmt.Sprintf("%v", {0})'),
     # Type conversions used by pretty printer
     "int32_to_int64": BuiltinTemplate("int64({0})"),
+    "uint32_to_int64": BuiltinTemplate("int64({0})"),
     "float32_to_float64": BuiltinTemplate("float64({0})"),
     "is_empty": BuiltinTemplate("len({0}) == 0"),
     "decode_string": BuiltinTemplate("string({0})"),

meta/src/meta/extra_pretty_gen.py

@@ -57,7 +57,7 @@
     "string": "format_string",
     "int32": "format_int32",
     "int64": "format_int64",
-    "uint32": "format_int64",
+    "uint32": "format_uint32",
     "uint64": "format_int64",
     "fixed64": "format_int64",
     "float": "format_float32",

meta/src/meta/grammar.y

@@ -40,6 +40,7 @@
 %token FLOAT32 Float32 r'[-]?\d+\.\d+f32'
 %token INT Int64 r'[-]?\d+'
 %token INT32 Int32 r'[-]?\d+i32'
+%token UINT32 UInt32 r'\d+u32'
 %token INT128 logic.Int128Value r'[-]?\d+i128'
 %token STRING String r'"(?:[^"\\]|\\.)*"'
 %token SYMBOL String r'[a-zA-Z_][a-zA-Z0-9_./#-]*'
@@ -121,6 +122,7 @@
 %nonterm instruction logic.Instruction
 %nonterm int_type logic.IntType
 %nonterm int32_type logic.Int32Type
+%nonterm uint32_type logic.UInt32Type
 %nonterm int128_type logic.Int128Type
 %nonterm loop logic.Loop
 %nonterm lt logic.Primitive
@@ -257,6 +259,10 @@ value
       construct: $$ = logic.Value(float32_value=$1)
       deconstruct if builtin.has_proto_field($$, 'float32_value'):
         $1: Float32 = $$.float32_value
+    | UINT32
+      construct: $$ = logic.Value(uint32_value=$1)
+      deconstruct if builtin.has_proto_field($$, 'uint32_value'):
+        $1: UInt32 = $$.uint32_value
 
 date
     : "(" "date" INT INT INT ")"
@@ -455,6 +461,10 @@ type
       construct: $$ = logic.Type(float32_type=$1)
       deconstruct if builtin.has_proto_field($$, 'float32_type'):
         $1: logic.Float32Type = $$.float32_type
+    | uint32_type
+      construct: $$ = logic.Type(uint32_type=$1)
+      deconstruct if builtin.has_proto_field($$, 'uint32_type'):
+        $1: logic.UInt32Type = $$.uint32_type
 
 unspecified_type
     : "UNKNOWN"
@@ -507,6 +517,10 @@ float32_type
     : "FLOAT32"
       construct: $$ = logic.Float32Type()
 
+uint32_type
+    : "UINT32"
+      construct: $$ = logic.UInt32Type()
+
 boolean_type
     : "BOOLEAN"
       construct: $$ = logic.BooleanType()

meta/src/meta/pretty_gen.py

@@ -677,6 +677,8 @@ def _format_terminal(terminal: NamedTerminal, value_var: Var) -> TargetExpr:
         return Call(make_builtin("format_int64"), [value_var])
     elif terminal.name == "INT32":
         return Call(make_builtin("format_int32"), [value_var])
+    elif terminal.name == "UINT32":
+        return Call(make_builtin("format_uint32"), [value_var])
     elif terminal.name == "INT128":
         return Call(make_builtin("format_int128"), [value_var])
     elif terminal.name == "FLOAT":

meta/src/meta/target_builtins.py

@@ -29,6 +29,7 @@
 # Type aliases for convenience
 ANY = VarType("Any")
 INT32 = BaseType("Int32")
+UINT32 = BaseType("UInt32")
 INT64 = BaseType("Int64")
 FLOAT32 = BaseType("Float32")
 FLOAT64 = BaseType("Float64")
@@ -159,6 +160,8 @@ def is_builtin(name: str) -> bool:
 # === Type conversions ===
 register_builtin("int64_to_int32", [INT64], INT32)
 register_builtin("int32_to_int64", [INT32], INT64)
+register_builtin("int64_to_uint32", [INT64], UINT32)
+register_builtin("uint32_to_int64", [UINT32], INT64)
 register_builtin("float64_to_float32", [FLOAT64], FLOAT32)
 register_builtin("float32_to_float64", [FLOAT32], FLOAT64)
 register_builtin("decode_string", [BYTES], STRING)
@@ -237,6 +240,7 @@ def is_builtin(name: str) -> bool:
 # === Formatting for terminal types ===
 register_builtin("format_int64", [INT64], STRING)
 register_builtin("format_int32", [INT32], STRING)
+register_builtin("format_uint32", [UINT32], STRING)
 register_builtin("format_float32", [FLOAT32], STRING)
 register_builtin("format_float64", [FLOAT64], STRING)
 register_builtin("format_string", [STRING], STRING)
@@ -333,6 +337,7 @@ def make_builtin_with_type(name: str, func_type: FunctionType) -> Builtin:
     "ANY",
     "INT64",
     "INT32",
+    "UINT32",
     "FLOAT32",
     "FLOAT64",
     "STRING",

meta/src/meta/templates/parser.go.template

@@ -62,6 +62,7 @@ const (
 	kindString tokenKind = iota
 	kindInt64
 	kindInt32
+	kindUint32
 	kindFloat64
 	kindFloat32
 	kindUint128
@@ -75,6 +76,7 @@ type TokenValue struct {{
 	str     string
 	i64     int64
 	i32     int32
+	u32     uint32
 	f64     float64
 	f32     float32
 	uint128 *pb.UInt128Value
@@ -88,6 +90,8 @@ func (tv TokenValue) String() string {{
 		return strconv.FormatInt(tv.i64, 10)
 	case kindInt32:
 		return fmt.Sprintf("%di32", tv.i32)
+	case kindUint32:
+		return fmt.Sprintf("%du32", tv.u32)
 	case kindFloat64:
 		return strconv.FormatFloat(tv.f64, 'g', -1, 64)
 	case kindFloat32:
@@ -242,6 +246,15 @@ func scanInt32(s string) int32 {{
 	return int32(n)
 }}
 
+func scanUint32(s string) uint32 {{
+	numStr := s[:len(s)-3] // Remove "u32" suffix
+	n, err := strconv.ParseUint(numStr, 10, 32)
+	if err != nil {{
+		panic(ParseError{{msg: fmt.Sprintf("Invalid uint32: %s", s)}})
+	}}
+	return uint32(n)
+}}
+
 func scanFloat32(s string) float32 {{
 	numStr := s[:len(s)-3] // Remove "f32" suffix
 	f, err := strconv.ParseFloat(numStr, 32)

meta/src/meta/templates/parser.jl.template

@@ -83,6 +83,8 @@ scan_int(n::String) = Base.parse(Int64, n)
 
 scan_int32(n::String) = Base.parse(Int32, n[1:end-3])  # Remove "i32" suffix
 
+scan_uint32(n::String) = Base.parse(UInt32, n[1:end-3])  # Remove "u32" suffix
+
 scan_float32(f::String) = Base.parse(Float32, f[1:end-3])  # Remove "f32" suffix
 
 function scan_float(f::String)
@@ -376,7 +378,7 @@ end
 # Export main parse functions and error type
 export parse, parse_transaction, parse_fragment, ParseError
 # Export scanner functions for testing
-export scan_string, scan_int, scan_int32, scan_float, scan_float32, scan_int128, scan_uint128, scan_decimal
+export scan_string, scan_int, scan_int32, scan_uint32, scan_float, scan_float32, scan_int128, scan_uint128, scan_decimal
 # Export Lexer and provenance types for testing
 export Lexer, Location, Span
 

meta/src/meta/templates/parser.py.template

@@ -160,6 +160,15 @@ class Lexer:
             raise ParseError(f"Int32 literal out of range: {{n}}")
         return val
 
+    @staticmethod
+    def scan_uint32(n: str) -> int:
+        """Parse UINT32 token."""
+        n = n[:-3]  # Remove "u32" suffix
+        val = int(n)
+        if val < 0 or val >= (1 << 32):
+            raise ParseError(f"UInt32 literal out of range: {{n}}")
+        return val
+
     @staticmethod
     def scan_float32(f: str) -> float:
         """Parse FLOAT32 token."""