satisfactoscript 1.1.0__tar.gz → 1.2.0__tar.gz

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satisfactoscript
-Version: 1.1.0
+Version: 1.2.0
 Summary: Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery).
 Author-email: julhouba <houbartjulien80@gmail.com>
 License: MIT

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satisfactoscript"
-version = "1.1.0"
+version = "1.2.0"
 description = "Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery)."
 readme = "README.md"
 license = { text = "MIT" }

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/backends/snowpark.py

@@ -19,6 +19,9 @@ import logging
 from functools import reduce
 from typing import Any
 
+from satisfactoscript.backends.sql_base import ANTI_SEMI_JOIN_UNSUPPORTED_MSG
+from satisfactoscript.core.ir import _normalise_join_type
+
 logger = logging.getLogger(__name__)
 
 
@@ -368,6 +371,9 @@ class SnowparkBackend:
         return df.filter(condition)
 
     def join(self, left: Any, right: Any, on: Any, how: str = "left") -> Any:
+        join_type = _normalise_join_type(how)
+        if join_type in {"left_anti", "left_semi"}:
+            raise NotImplementedError(ANTI_SEMI_JOIN_UNSUPPORTED_MSG)
         return left.join(right, on=on, how=how)
 
     def drop_columns(self, df: Any, columns: list) -> Any:

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/backends/sql_base.py

@@ -30,6 +30,11 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 _alias_counter = itertools.count(1)
+ANTI_SEMI_JOIN_UNSUPPORTED_MSG = (
+    "anti/semi join only supported on the Spark DataFrame backend so far "
+    "(see Plan 21)"
+)
+_UNSUPPORTED_SQL_JOIN_TYPES = {"LEFT ANTI", "LEFT SEMI"}
 
 
 def _next_alias() -> str:
@@ -342,6 +347,8 @@ class SQLQuery:
                 right_inner = right_q._base_to_sql()
                 on_sql = _build_join_on(self._alias, right_q._alias, on_cond)
                 jt = _normalise_join_type(how)
+                if jt in _UNSUPPORTED_SQL_JOIN_TYPES:
+                    raise NotImplementedError(ANTI_SEMI_JOIN_UNSUPPORTED_MSG)
                 parts.append(f"{jt} JOIN ({right_inner}) AS `{right_q._alias}`")
                 parts.append(f"  ON {on_sql}")
         else:
@@ -409,6 +416,10 @@ def _normalise_join_type(how: str) -> str:
     how = how.upper().replace("_", " ")
     if how in ("LEFT", "LEFT OUTER"):
         return "LEFT"
+    if how in ("ANTI", "LEFT ANTI"):
+        return "LEFT ANTI"
+    if how in ("SEMI", "LEFT SEMI"):
+        return "LEFT SEMI"
     if how in ("RIGHT", "RIGHT OUTER"):
         return "RIGHT"
     if how in ("INNER",):
@@ -639,14 +650,22 @@ class SQLBackend:
             inner_op_name = resolve_filter_operator(raw_op_name) or raw_op_name
             inner_val = parts[1] if len(parts) > 1 else None
             # Evaluate condition against c_expr directly (not via build_filter column lookup)
-            if inner_op_name == "is_not_null": return SQLCondition(f"{c_expr} IS NOT NULL")
-            if inner_op_name == "is_null": return SQLCondition(f"{c_expr} IS NULL")
-            if inner_op_name == "contains": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}%'")
-            if inner_op_name == "not_contains": return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(inner_val))}%'")
-            if inner_op_name == "starts_with": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}%'")
-            if inner_op_name == "ends_with": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}'")
-            if inner_op_name == "like": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}'")
-            if inner_op_name == "not_like": return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(inner_val))}'")
+            if inner_op_name == "is_not_null":
+                return SQLCondition(f"{c_expr} IS NOT NULL")
+            if inner_op_name == "is_null":
+                return SQLCondition(f"{c_expr} IS NULL")
+            if inner_op_name == "contains":
+                return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}%'")
+            if inner_op_name == "not_contains":
+                return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(inner_val))}%'")
+            if inner_op_name == "starts_with":
+                return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}%'")
+            if inner_op_name == "ends_with":
+                return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}'")
+            if inner_op_name == "like":
+                return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}'")
+            if inner_op_name == "not_like":
+                return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(inner_val))}'")
             _comp_sym = {"equals": "=", "not_equals": "!=", "greater_than": ">",
                          "less_than": "<", "greater_than_equal": ">=", "less_than_equal": "<="}
             if inner_op_name in _comp_sym:
@@ -675,6 +694,7 @@ class SQLBackend:
             "trim":      lambda: SQLColumn(f"TRIM({c_expr})"),
             "round":     lambda: SQLColumn(f"ROUND({c_expr}, {op.args[0]})"),
             "abs":       lambda: SQLColumn(f"ABS({c_expr})"),
+            "ceil":      lambda: SQLColumn(f"CEIL({c_expr})"),
             "length":    lambda: SQLColumn(f"LENGTH({c_expr})"),
             "to_date":   lambda: SQLColumn(f"PARSE_DATE('{op.args[0]}', {c_expr})"),
             "split":     lambda: SQLColumn(f"SPLIT({c_expr}, '{op.args[0]}')[ORDINAL({int(op.args[1]) + 1})]"),
@@ -702,22 +722,42 @@ class SQLBackend:
         val = f.value
         c_expr = self._q(col_name)
 
-        if op == "is_not_null": return SQLCondition(f"{c_expr} IS NOT NULL")
-        if op == "is_null": return SQLCondition(f"{c_expr} IS NULL")
+        if op == "is_not_null":
+            return SQLCondition(f"{c_expr} IS NOT NULL")
+        if op == "is_null":
+            return SQLCondition(f"{c_expr} IS NULL")
         if op in ("in", "not_in"):
             lst = val if isinstance(val, list) else [v.strip() for v in str(val).replace(";", ",").split(",")]
             vals_str = ", ".join(_smart_val(v) for v in lst)
             return SQLCondition(f"{c_expr} {'NOT ' if op == 'not_in' else ''}IN ({vals_str})")
-        if op == "contains": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}%'")
-        if op == "not_contains": return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(val))}%'")
-        if op == "starts_with": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}%'")
-        if op == "ends_with": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}'")
-        if op == "like": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}'")
-        if op == "not_like": return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(val))}'")
+        if op == "contains":
+            return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}%'")
+        if op == "not_contains":
+            return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(val))}%'")
+        if op == "starts_with":
+            return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}%'")
+        if op == "ends_with":
+            return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}'")
+        if op == "like":
+            return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}'")
+        if op == "not_like":
+            return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(val))}'")
         if op == "sql":
             if not allow_raw_sql:
                 raise ValueError("[Governance] sql: filter disabled (allow_raw_sql: false).")
             return SQLCondition(val)
+        if op == "between":
+            parts = [v.strip() for v in str(val).split(",")]
+            if len(parts) != 2:
+                raise ValueError(f"between filter on column '{col_name}' expects exactly 2 values.")
+            lo, hi = parts
+            return SQLCondition(f"({c_expr} >= {_smart_val(lo)} AND {c_expr} <= {_smart_val(hi)})")
+        if op == "not_between":
+            parts = [v.strip() for v in str(val).split(",")]
+            if len(parts) != 2:
+                raise ValueError(f"not_between filter on column '{col_name}' expects exactly 2 values.")
+            lo, hi = parts
+            return SQLCondition(f"({c_expr} < {_smart_val(lo)} OR {c_expr} > {_smart_val(hi)})")
         _comp = {"equals": "=", "not_equals": "!=", "greater_than": ">",
                  "less_than": "<", "greater_than_equal": ">=", "less_than_equal": "<="}
         if op in _comp:
@@ -893,4 +933,4 @@ class SQLBackend:
 
     def optimize_table(self, fqn: str, zorder_cols: list[str] | None = None) -> None:
         """Default no-op. Override in subclasses for platform-specific optimisation."""
-        print(f"   [SQLBackend] optimize_table: no-op for {fqn}")
+        print(f"   [SQLBackend] optimize_table: no-op for {fqn}")

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/core/interpreter.py

@@ -27,6 +27,8 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+_LEFT_ONLY_JOIN_TYPES = {"left_anti", "left_semi"}
+
 
 class SchemaInterpreter:
     """
@@ -351,7 +353,8 @@ class SchemaInterpreter:
                 else:
                     cond = reduce(lambda x, y: x & y, [df_main[lk] == df_to[rk] for lk, rk in zip(on_l, on_r)])
                     df_main = b.join(df_main, df_to, cond, join_type)
-                    df_main = b.drop_columns(df_main, [df_to[r] for r in on_r])
+                    if join_type not in _LEFT_ONLY_JOIN_TYPES:
+                        df_main = b.drop_columns(df_main, [df_to[r] for r in on_r])
 
         # 3. BUSINESS RULES
         if "business_rules" in schema_dict:

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/core/ir.py

@@ -11,7 +11,9 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
-VALID_JOIN_TYPES: frozenset[str] = frozenset({"left", "right", "inner", "full", "cross"})
+VALID_JOIN_TYPES: frozenset[str] = frozenset(
+    {"left", "right", "inner", "full", "cross", "left_anti", "left_semi"}
+)
 
 _JOIN_TYPE_ALIASES: dict[str, str] = {
     "left outer": "left",
@@ -19,6 +21,12 @@ _JOIN_TYPE_ALIASES: dict[str, str] = {
     "outer": "full",
     "full outer": "full",
     "full_outer": "full",
+    "anti": "left_anti",
+    "left anti": "left_anti",
+    "leftanti": "left_anti",
+    "semi": "left_semi",
+    "left semi": "left_semi",
+    "leftsemi": "left_semi",
 }
 
 

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/core/op_catalog.py

@@ -32,7 +32,7 @@ class OperatorSpec:
     """
     ``"none"``    — operator takes no value (``is_null``, ``is_not_null``)
     ``"single"``  — operator takes one scalar value
-    ``"list"``    — operator takes a comma-separated / YAML-list value (``in``, ``not_in``)
+    ``"list"``    — operator takes a comma-separated / YAML-list value (``in``, ``not_in``, ``between``, ``not_between``)
     ``"sql"``     — operator takes a raw SQL expression (``sql``)
     """
 
@@ -49,7 +49,7 @@ class OpSpec:
 
     arity: str = "none"
     """
-    ``"none"``        — no argument  (``upper``, ``lower``, ``trim``, ``abs``, ``length``)
+    ``"none"``        — no argument  (``upper``, ``lower``, ``trim``, ``abs``, ``length``, ``ceil``)
     ``"single"``      — one argument after ``:``  (``cast:``, ``lit:``, ``round:``, …)
     ``"two"``         — two comma-separated arguments (``split:sep,idx``, ``substring:start,len``)
     ``"expression"``  — raw SQL expression (``expr:``)
@@ -125,6 +125,16 @@ FILTER_OPERATORS: dict[str, OperatorSpec] = {
         arity="list",
         description="Passes rows where column value is in the provided list.",
     ),
+    "between": OperatorSpec(
+        canonical="between",
+        arity="list",
+        description="Passes rows where lo <= column <= hi (inclusive). Two comma-separated values.",
+    ),
+    "not_between": OperatorSpec(
+        canonical="not_between",
+        arity="list",
+        description="Passes rows where column is strictly outside the provided [lo, hi] interval.",
+    ),
     "not_in": OperatorSpec(
         canonical="not_in",
         arity="list",
@@ -189,6 +199,7 @@ COLUMN_OPS: dict[str, OpSpec] = {
     # ---- numeric ----
     "round": OpSpec("round", arity="single", description="Round to N decimal places."),
     "abs": OpSpec("abs", arity="none", description="Absolute value."),
+    "ceil": OpSpec("ceil", arity="none", description="Round up to nearest integer."),
     # ---- date ----
     "to_date": OpSpec("to_date", arity="single", description="Parse string to date using the given format."),
     # ---- null handling ----

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/core/operations.py

@@ -38,9 +38,12 @@ def _apply_operation(c, op_str, allow_raw_sql=True):
     # --- 1. CONDITIONS (WHEN) ---
     if op_str.startswith("when:"):
         cond = op_str.split(":", 1)[1]
-        if cond == "is_not_null": return c.isNotNull()
-        if cond == "is_null": return c.isNull()
-        if cond.startswith("like:"): return c.like(cond.split(":", 1)[1])
+        if cond == "is_not_null":
+            return c.isNotNull()
+        if cond == "is_null":
+            return c.isNull()
+        if cond.startswith("like:"):
+            return c.like(cond.split(":", 1)[1])
         if cond.startswith("not_like:") or cond.startswith("notlike:"):
             val = cond.split(":", 1)[1]
             return ~c.like(val)
@@ -85,10 +88,13 @@ def _apply_operation(c, op_str, allow_raw_sql=True):
 
     # --- 2. ACTIONS ---
     clean_op = op_str
-    if op_str.startswith("then:"): clean_op = op_str.split(":", 1)[1]
-    if op_str.startswith("else:"): clean_op = op_str.split(":", 1)[1]
+    if op_str.startswith("then:"):
+        clean_op = op_str.split(":", 1)[1]
+    if op_str.startswith("else:"):
+        clean_op = op_str.split(":", 1)[1]
 
-    if clean_op.startswith("lit:"): return smart_lit(clean_op.split(":", 1)[1])
+    if clean_op.startswith("lit:"):
+        return smart_lit(clean_op.split(":", 1)[1])
     if clean_op.startswith("expr:"):
         if not allow_raw_sql:
             raise ValueError(
@@ -96,10 +102,14 @@ def _apply_operation(c, op_str, allow_raw_sql=True):
                 "(allow_raw_sql: false). Remove the expr: operation or enable allow_raw_sql in config.yaml."
             )
         return F.expr(clean_op.split(":", 1)[1])
-    if clean_op.startswith("col:"): return F.col(f"`{clean_op.split(':', 1)[1]}`")
-    if clean_op == "col": return c
-    if clean_op.startswith("coalesce:"): return F.coalesce(c, smart_lit(clean_op.split(":", 1)[1]))
-    if clean_op.startswith("nvl:"): return F.coalesce(c, smart_lit(clean_op.split(":", 1)[1]))
+    if clean_op.startswith("col:"):
+        return F.col(f"`{clean_op.split(':', 1)[1]}`")
+    if clean_op == "col":
+        return c
+    if clean_op.startswith("coalesce:"):
+        return F.coalesce(c, smart_lit(clean_op.split(":", 1)[1]))
+    if clean_op.startswith("nvl:"):
+        return F.coalesce(c, smart_lit(clean_op.split(":", 1)[1]))
     if clean_op.startswith("cast:"):
         t = clean_op.split(":", 1)[1].lower()
         return c.cast("timestamp") if t in ["datetime", "timestamp"] else c.cast(t)
@@ -115,11 +125,18 @@ def _apply_operation(c, op_str, allow_raw_sql=True):
     if clean_op.startswith("to_date:"):
         fmt = clean_op.split(":", 1)[1]
         return F.to_date(c, fmt)
-    if clean_op == "trim": return F.trim(c)
-    if clean_op == "upper": return F.upper(c)
-    if clean_op == "lower": return F.lower(c)
-    if clean_op == "abs": return F.abs(c)
-    if clean_op == "length": return F.length(c)
+    if clean_op == "trim":
+        return F.trim(c)
+    if clean_op == "upper":
+        return F.upper(c)
+    if clean_op == "lower":
+        return F.lower(c)
+    if clean_op == "abs":
+        return F.abs(c)
+    if clean_op == "ceil":
+        return F.ceil(c)
+    if clean_op == "length":
+        return F.length(c)
 
     op_name = clean_op.split(":", 1)[0]
     from satisfactoscript.core.op_catalog import COLUMN_OPS, suggest as _suggest
@@ -149,37 +166,78 @@ def _build_filter_expression(filter_list, allow_raw_sql=True):
     """
     from pyspark.sql import functions as F
 
+    def parse_list_values(col_name, val):
+        if isinstance(val, str):
+            raw_vals = val.replace(";", ",").split(",")
+            val_list = []
+            for v in raw_vals:
+                stripped = v.strip()
+                if stripped != v:
+                    logger.warning(
+                        "Filter on '%s': value '%s' has leading/trailing space. "
+                        "If the value contains a comma, use the dict form instead.",
+                        col_name,
+                        v,
+                    )
+                val_list.append(stripped)
+            return val_list
+        if isinstance(val, (list, tuple)):
+            return list(val)
+        return val
+
     def build_condition(rule):
         col_name, op, val = rule["column"], rule["operator"].lower(), rule.get("value")
         c = F.col(f"`{col_name}`")
 
-        if op == "is_not_null": return c.isNotNull()
-        if op == "is_null": return c.isNull()
+        if op == "is_not_null":
+            return c.isNotNull()
+        if op == "is_null":
+            return c.isNull()
 
         if op in ["in", "not_in"]:
-            if isinstance(val, str):
-                raw_vals = val.replace(";", ",").split(",")
-                val_list = []
-                for v in raw_vals:
-                    stripped = v.strip()
-                    if stripped != v:
-                        logger.warning(
-                            "Filter on '%s': value '%s' has leading/trailing space. "
-                            "If the value contains a comma, use the dict form instead.",
-                            col_name,
-                            v,
-                        )
-                    val_list.append(stripped)
-            else:
-                val_list = val
+            val_list = parse_list_values(col_name, val)
             return c.isin(val_list) if op == "in" else ~c.isin(val_list)
+        if op == "between":
+            val_list = parse_list_values(col_name, val)
+            if not isinstance(val_list, list):
+                raise ValueError(
+                    f"Filter on column '{col_name}': between operator expects exactly 2 values "
+                    "(lo,hi)."
+                )
+            if len(val_list) != 2:
+                raise ValueError(
+                    f"Filter on column '{col_name}': between operator expects exactly 2 values "
+                    f"(lo,hi); got {len(val_list)}."
+                )
+            lo, hi = val_list
+            return (c >= lo) & (c <= hi)
+        if op == "not_between":
+            val_list = parse_list_values(col_name, val)
+            if not isinstance(val_list, list):
+                raise ValueError(
+                    f"Filter on column '{col_name}': not_between operator expects exactly 2 values "
+                    "(lo,hi)."
+                )
+            if len(val_list) != 2:
+                raise ValueError(
+                    f"Filter on column '{col_name}': not_between operator expects exactly 2 values "
+                    f"(lo,hi); got {len(val_list)}."
+                )
+            lo, hi = val_list
+            return (c < lo) | (c > hi)
 
-        if op == "contains": return c.like(f"%{val}%")
-        if op in ["not_contains", "notcontains"]: return ~c.like(f"%{val}%")
-        if op == "starts_with": return c.like(f"{val}%")
-        if op == "ends_with": return c.like(f"%{val}")
-        if op == "like": return c.like(val)
-        if op in ["not_like", "notlike"]: return ~c.like(val)
+        if op == "contains":
+            return c.like(f"%{val}%")
+        if op in ["not_contains", "notcontains"]:
+            return ~c.like(f"%{val}%")
+        if op == "starts_with":
+            return c.like(f"{val}%")
+        if op == "ends_with":
+            return c.like(f"%{val}")
+        if op == "like":
+            return c.like(val)
+        if op in ["not_like", "notlike"]:
+            return ~c.like(val)
 
         if op == "sql":
             if not allow_raw_sql:
@@ -199,12 +257,18 @@ def _build_filter_expression(filter_list, allow_raw_sql=True):
         }
         if op in op_map:
             sql_op = op_map[op]
-            if sql_op == "=":   return c == val
-            if sql_op == "!=":  return c != val
-            if sql_op == ">":   return c > val
-            if sql_op == "<":   return c < val
-            if sql_op == ">=":  return c >= val
-            if sql_op == "<=":  return c <= val
+            if sql_op == "=":
+                return c == val
+            if sql_op == "!=":
+                return c != val
+            if sql_op == ">":
+                return c > val
+            if sql_op == "<":
+                return c < val
+            if sql_op == ">=":
+                return c >= val
+            if sql_op == "<=":
+                return c <= val
 
         from satisfactoscript.core.op_catalog import FILTER_OPERATORS, suggest as _suggest
         hints = _suggest(op, FILTER_OPERATORS)
@@ -219,4 +283,3 @@ def _build_filter_expression(filter_list, allow_raw_sql=True):
         return F.lit(True)
 
     return reduce(lambda a, b: a & b, [build_condition(r) for r in filter_list])
-

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript/core/rule_executor.py

@@ -69,11 +69,18 @@ class RuleExecutor:
         """
         Fuse all projection rules into a single ``select()`` call.
 
-        Each rule returns ``dict[str, Column]``.  All new columns are appended
+        Each rule returns ``dict[str, Column]``.  Brand-new columns are appended
         to the existing schema in topological order (already sorted by the
         planner).  Duplicate column names produced by different rules are
         de-duplicated: the last rule's expression wins (consistent with
         sequential semantics).
+
+        A rule may also produce a column whose name already exists in the input
+        DataFrame (e.g. ``{"x": F.upper(F.col("x"))}``).  Such columns *replace*
+        the input column in place — keeping their original position — exactly
+        like a sequential ``withColumn``.  This avoids emitting two homonymous
+        columns in the fused ``select()`` (which would raise
+        ``AMBIGUOUS_REFERENCE``).
         """
         from pyspark.sql import functions as F
 
@@ -95,10 +102,20 @@ class RuleExecutor:
         if not new_cols:
             return df
 
-        # Build the select expression: keep all existing columns, add new ones
-        existing = [F.col(c) for c in df.columns]
-        additions = [col_expr.alias(col_name) for col_name, col_expr in new_cols.items()]
-        return df.select(*existing, *additions)
+        # Build the select expression. Columns rewritten by a rule replace the
+        # input column in place (preserving position); brand-new columns are
+        # appended. Keeping a rewritten column out of `existing` avoids two
+        # homonymous columns in the select (AMBIGUOUS_REFERENCE).
+        select_exprs = [
+            new_cols[c].alias(c) if c in new_cols else F.col(c)
+            for c in df.columns
+        ]
+        select_exprs += [
+            col_expr.alias(col_name)
+            for col_name, col_expr in new_cols.items()
+            if col_name not in df.columns
+        ]
+        return df.select(*select_exprs)
 
     def _execute_aggregation_stage(self, df: "DataFrame", stage: "RuleStage") -> "DataFrame":
         """

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/src/satisfactoscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satisfactoscript
-Version: 1.1.0
+Version: 1.2.0
 Summary: Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery).
 Author-email: julhouba <houbartjulien80@gmail.com>
 License: MIT

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/tests/test_backend_snowpark.py

@@ -257,6 +257,16 @@ def test_join(backend):
     left.join.assert_called_once_with(right, on=on, how="left")
 
 
+@pytest.mark.parametrize("join_type", ["left_anti", "anti", "left_semi", "semi", "left semi"])
+def test_join_anti_semi_fail_fast(backend, join_type):
+    left = MagicMock()
+    right = MagicMock()
+    on = MagicMock()
+    with pytest.raises(NotImplementedError, match="anti/semi join only supported on the Spark DataFrame backend so far"):
+        backend.join(left, right, on=on, how=join_type)
+    left.join.assert_not_called()
+
+
 def test_with_column_uses_snake_case(backend):
     """Snowpark uses with_column() (snake_case), not withColumn()."""
     df = MagicMock()

{satisfactoscript-1.1.0 → satisfactoscript-1.2.0}/tests/test_backend_sql_base.py

@@ -234,6 +234,14 @@ class TestSQLQuery:
         assert "FULL OUTER JOIN" in sql
         assert "customer_id" in sql
 
+    @pytest.mark.parametrize("join_type", ["left_anti", "anti", "left_semi", "semi"])
+    def test_join_anti_semi_raise_not_implemented(self, join_type):
+        left = SQLQuery("`orders`")
+        right = SQLQuery("`customers`")
+        left._joins.append((join_type, right, ["customer_id"]))
+        with pytest.raises(NotImplementedError, match="anti/semi join only supported on the Spark DataFrame backend so far"):
+            left.to_sql()
+
     def test_qualify(self):
         q = SQLQuery("`orders`")
         q._qualify = "ROW_NUMBER() OVER (PARTITION BY `id` ORDER BY 1) = 1"
@@ -413,6 +421,14 @@ class TestSQLBackend:
         assert "cust_id" in sql
         assert "LEFT JOIN" in sql
 
+    @pytest.mark.parametrize("join_type", ["left_anti", "anti", "left_semi", "semi"])
+    def test_join_anti_semi_fail_fast_on_backend(self, backend, join_type):
+        left = backend.read_table("`orders`")
+        right = backend.read_table("`customers`")
+        joined = backend.join(left, right, on=["customer_id"], how=join_type)
+        with pytest.raises(NotImplementedError, match="anti/semi join only supported on the Spark DataFrame backend so far"):
+            joined.to_sql()
+
     def test_select_sets_explicit_columns(self, backend):
         df = backend.read_table("`orders`")
         cols = [backend.col("amount").alias("total")]
@@ -565,6 +581,11 @@ class TestSQLBackend:
         result = backend.apply_operation(c, "abs")
         assert "ABS(`amount`)" == result._expr
 
+    def test_apply_operation_ceil(self, backend):
+        c = SQLColumn("`amount`")
+        result = backend.apply_operation(c, "ceil")
+        assert "CEIL(`amount`)" == result._expr
+
     def test_apply_operation_round(self, backend):
         c = SQLColumn("`amount`")
         result = backend.apply_operation(c, "round:2")
@@ -667,6 +688,42 @@ class TestSQLBackend:
         ])
         assert "`status` IN ('ACTIVE', 'PENDING')" in result._sql
 
+    def test_build_filter_between(self, backend):
+        result = backend.build_filter_expression([
+            {"column": "amount", "operator": "between", "value": "10, 20"}
+        ])
+        assert "(`amount` >= 10 AND `amount` <= 20)" in result._sql
+
+    def test_build_filter_between_escapes_strings(self, backend):
+        result = backend.build_filter_expression([
+            {"column": "name", "operator": "between", "value": "O'Brien, Zed"}
+        ])
+        assert "(`name` >= 'O\\'Brien' AND `name` <= 'Zed')" in result._sql
+
+    def test_build_filter_between_requires_two_values(self, backend):
+        with pytest.raises(ValueError, match="amount"):
+            backend.build_filter_expression([
+                {"column": "amount", "operator": "between", "value": "10,20,30"}
+            ])
+
+    def test_build_filter_not_between(self, backend):
+        result = backend.build_filter_expression([
+            {"column": "amount", "operator": "not_between", "value": "10, 20"}
+        ])
+        assert "(`amount` < 10 OR `amount` > 20)" in result._sql
+
+    def test_build_filter_not_between_escapes_strings(self, backend):
+        result = backend.build_filter_expression([
+            {"column": "name", "operator": "not_between", "value": "O'Brien, Zed"}
+        ])
+        assert "(`name` < 'O\\'Brien' OR `name` > 'Zed')" in result._sql
+
+    def test_build_filter_not_between_requires_two_values(self, backend):
+        with pytest.raises(ValueError, match="amount"):
+            backend.build_filter_expression([
+                {"column": "amount", "operator": "not_between", "value": "10,20,30"}
+            ])
+
     def test_build_filter_not_in(self, backend):
         result = backend.build_filter_expression([
             {"column": "status", "operator": "not_in", "value": "DELETED,ARCHIVED"}