feat(codegen): || operator (NULL-propagating concat) — TASK-29 Phase A

Author: ahrzb

sql_transform/_codegen/engine.py

@@ -40,6 +40,7 @@
     "gte": "rt.gte",
     "and": "rt.and_",
     "or": "rt.or_",
+    "dpipe": "rt.dpipe",
 }
 
 _BUILTINS = {

sql_transform/_codegen/plan.py

@@ -323,9 +323,9 @@ def _convert_expr(e: exp.Expression) -> Any:
         # NULL propagation. infer_type/emit already handle "sub".
         return BinaryOp("sub", Literal(0), inner)
     if isinstance(e, exp.DPipe):
-        # The `||` string-concat operator: supported by DataFusion and native,
-        # deferred by codegen (its NULL-propagating semantics differ from CONCAT).
-        raise UnsupportedInCodegen("the || operator is not supported in codegen yet")
+        # The `||` operator: NULL-propagating string concat (mirrors native
+        # concat_op). Binary -- a||b||c nests as DPipe(DPipe(a,b), c).
+        return BinaryOp("dpipe", _convert_expr(e.this), _convert_expr(e.expression))
     if isinstance(e, exp.Not):
         return Not(_convert_expr(e.this))
     if isinstance(e, exp.Case):
@@ -740,6 +740,8 @@ def infer_type(e: Any, schemas: dict) -> FieldType:
         if e.op in ("add", "sub", "mul", "div", "mod"):
             base = INT if left.base == INT and right.base == INT else FLOAT
             return FieldType(base, nullable)
+        if e.op == "dpipe":
+            return FieldType(STR, nullable)
         if is_container(left.base) or is_container(right.base):
             # Comparing/combining structs or lists needs deep equality, which
             # the runtime doesn't implement -- without this it silently reaches

sql_transform/_codegen/runtime.py

@@ -393,6 +393,15 @@ def concat(*a: Any) -> str:
     return "".join(display(x) for x in a if x is not None)
 
 
+def dpipe(l: Any, r: Any) -> Any:  # noqa: E741
+    """The `||` operator: NULL-propagating string concat -- any NULL operand
+    yields NULL (unlike concat(), which skips NULLs). Mirrors expr.rs concat_op:
+    non-NULL operands are rendered via display() and joined."""
+    if l is None or r is None:
+        return None
+    return display(l) + display(r)
+
+
 def abs_(*a: Any) -> Any:
     v = a[0]
     if v is None:

tests/test_codegen_coverage.py

@@ -17,8 +17,7 @@
     ("SELECT a AS x FROM t", {"t": rows({"a": "int"}, [{"a": 1}])}),
     ("SELECT a + 1 AS x FROM t", {"t": rows({"a": "int"}, [{"a": 1}])}),
     ("SELECT -a AS x FROM t", {"t": rows({"a": "int"}, [{"a": 5}])}),
-    # NB: the `||` operator is deliberately absent here until Phase A Task 2 lands
-    # it -- see the codegen deferred-surface spec.
+    ("SELECT a || '!' AS x FROM t", {"t": rows({"a": "str"}, [{"a": "hi"}])}),
     (
         "SELECT a / b AS x FROM t",
         {"t": rows({"a": "int", "b": "int"}, [{"a": 7, "b": 2}])},