Guard for unsupported computed-column expressions

Author: FrancescAlted

src/blosc2/ctable.py

@@ -8566,6 +8566,25 @@ def _normalize_transformer(self, expr, inputs=None) -> dict:
                 "jit_backend": obj.kwargs.get("jit_backend"),
             }
         lazy, col_deps = self._normalize_expression_transformer(obj)
+        # Guard: verify the expression string round-trips before storing.
+        # An empty string means the LazyExpr was not fully constructed, and a
+        # malformed string would silently break on reload.  Catching both here
+        # gives an early, actionable error instead of a confusing failure later.
+        expression = lazy.expression
+        if not expression:
+            raise ValueError(
+                "The computed-column expression serializes to an empty string "
+                "and cannot be persisted. Make sure the lambda returns a "
+                "blosc2 expression built from table columns (e.g. cols['x'] * 2)."
+            )
+        try:
+            _ops = {f"o{i}": self._cols[dep] for i, dep in enumerate(col_deps)}
+            blosc2.lazyexpr(expression, _ops)
+        except Exception as exc:
+            raise ValueError(
+                f"The computed-column expression {expression!r} cannot be safely "
+                f"persisted and reloaded: {exc}"
+            ) from exc
         return {"kind": "expression", "lazy": lazy, "col_deps": col_deps}
 
     def _dsl_result_dtype(self, kernel, col_deps, dtype):

tests/ctable/test_ctable_computed_cols.py

@@ -1047,3 +1047,37 @@ def test_dsl_no_jit_backend_not_in_schema():
     schema = t._schema_dict_with_computed()
     mat = {m["name"]: m for m in schema["materialized_columns"]}
     assert "jit_backend" not in mat["total"]
+
+
+def test_add_computed_column_empty_expression_raises(monkeypatch):
+    """add_computed_column raises ValueError when the LazyExpr serializes to empty string."""
+    t = _make_invoice_table()
+
+    original_normalize = t._normalize_expression_transformer.__func__
+
+    def patched(self, expr):
+        lazy, col_deps = original_normalize(self, expr)
+        monkeypatch.setattr(lazy, "expression", "")
+        return lazy, col_deps
+
+    monkeypatch.setattr(type(t), "_normalize_expression_transformer", patched)
+
+    with pytest.raises(ValueError, match="empty string"):
+        t.add_computed_column("total", lambda cols: cols["price"] * cols["qty"])
+
+
+def test_add_computed_column_malformed_expression_raises(monkeypatch):
+    """add_computed_column raises ValueError when the expression string cannot be re-parsed."""
+    t = _make_invoice_table()
+
+    original_normalize = t._normalize_expression_transformer.__func__
+
+    def patched(self, expr):
+        lazy, col_deps = original_normalize(self, expr)
+        monkeypatch.setattr(lazy, "expression", "this is not valid @@@ numexpr")
+        return lazy, col_deps
+
+    monkeypatch.setattr(type(t), "_normalize_expression_transformer", patched)
+
+    with pytest.raises(ValueError, match="cannot be safely persisted"):
+        t.add_computed_column("total", lambda cols: cols["price"] * cols["qty"])