Make a string result refuse clashing utf8 null sentinels

utf8_span_eval took the first non-None sentinel it found and stamped it on
every null row of the result, so an expression over two utf8 operands with
different null_values relabelled one operand's nulls as the other's --
and which one won depended on the operand mapping's order.

A result column has one sentinel, so there is no answer here to pick;
refuse instead, and only where it shows. A boolean result forces nulls
False whatever they were spelled as, and keeps working.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: FrancescAlted

src/blosc2/_utf8_array.py

@@ -151,7 +151,9 @@ def utf8_span_eval(
 
     Nulls are materialized to ``""`` so no string kernel ever sees a sentinel,
     and nullity is re-applied afterwards: a boolean result is forced ``False``
-    (SQL ``WHERE`` semantics), a string result gets the sentinel back.
+    (SQL ``WHERE`` semantics), a string result gets the sentinel back.  A string
+    result therefore needs the operands to agree on one sentinel, and raises
+    ``ValueError`` when they do not.
 
     Span operands are handed over as blosc2 arrays rather than NumPy ones: the
     NumPy route evaluates through ``slices_eval``, which never reaches
@@ -163,7 +165,12 @@ def utf8_span_eval(
 
     n_logical = min(len(a) for a in arrays.values())
     compute_kwargs = {"strict_miniexpr": True} if strict else {}
-    null_value = next((v for v in sentinels.values() if v is not None), None)
+    # One result column, so one sentinel.  Reading it off whichever operand came
+    # first would make the answer depend on the operand mapping's order, so a
+    # disagreement is refused instead -- but only where it shows, on a string
+    # result; a boolean one forces nulls False whatever they were spelled as.
+    distinct_sentinels = sorted({v for v in sentinels.values() if v is not None})
+    null_value = distinct_sentinels[0] if distinct_sentinels else None
 
     out = None
     utf8_out = None
@@ -191,6 +198,13 @@ def utf8_span_eval(
                     res.astype(f"<U{max(res.dtype.itemsize // 4, len(null_value))}"),
                 )
         if res.dtype.kind == "U":
+            if len(distinct_sentinels) > 1:
+                raise ValueError(
+                    f"utf8 operands carry different null sentinels ({distinct_sentinels}); "
+                    "a string result can only have one, and picking one of them would "
+                    "silently relabel the other's nulls. Give the operands a common "
+                    "null_value, or compute on fixed-width arrays (blosc2.from_utf8)."
+                )
             if utf8_out is None:
                 utf8_out = UTF8Array(blosc2.utf8(null_value=null_value))
             # tolist() gives plain str, which is UTF8Array.extend's fast path.

tests/ctable/test_utf8.py

@@ -1341,6 +1341,26 @@ def test_utf8_array_constructor_with_spec_and_nulls():
     assert list(arr[:]) == ["a", "<NA>", "c"]
 
 
+def test_utf8_string_expr_rejects_clashing_sentinels():
+    """One result column means one sentinel, so operands must agree on it; the
+    old first-wins pick relabelled the other operand's nulls silently."""
+    a = blosc2.utf8_array(["x", None, "z"], blosc2.utf8(null_value="<NA_A>"))
+    b = blosc2.utf8_array(["1", "2", None], blosc2.utf8(null_value="<NA_B>"))
+    with pytest.raises(ValueError, match="different null sentinels"):
+        blosc2.lazyexpr("a + b", {"a": a, "b": b}).compute()
+    # A boolean result never carries a sentinel, so it is unaffected.
+    assert list(blosc2.lazyexpr("a > b", {"a": a, "b": b}).compute()) == [True, False, False]
+
+
+def test_utf8_string_expr_shared_sentinel_survives():
+    spec = blosc2.utf8(null_value="<NA>")
+    a = blosc2.utf8_array(["x", None, "z"], spec)
+    b = blosc2.utf8_array(["1", "2", None], spec)
+    res = blosc2.lazyexpr("a + b", {"a": a, "b": b}).compute()
+    assert list(res[:]) == ["x1", "<NA>", "<NA>"]
+    assert res.spec.null_value == "<NA>"
+
+
 def test_utf8_array_ctor_rejects_none_if_not_null():
     with pytest.raises(TypeError, match="not nullable"):
         blosc2.utf8_array(["a", None])