fix: soundness round

examples/dimensional_indexing.py

@@ -210,7 +210,7 @@ def get_autocomplete_suggestions(prefix: str, limit: int = 10):
     flights_with_origin = flights.join_one(airports, lambda f, a: f.origin == a.code)
 
     joined_index = (
-        flights_with_origin.index(s.cols("carrier", "airports__state"))
+        flights_with_origin.index(s.cols("carrier", "airports.state"))
         .order_by(lambda t: t.weight.desc())
         .limit(15)
         .execute()

src/boring_semantic_layer/calc_compiler.py

@@ -414,9 +414,12 @@ def compile_calc_measure(
         )
         for col_name in totals_schema:
             prefixed = f"{totals_prefix}{col_name}"
-            target_name = prefixed if prefixed in rwt_columns else col_name
-            if target_name in rwt_columns:
-                subs[Field(totals_vt_op, col_name)] = Field(rwt_op, target_name)
+            # Only substitute the real TOTALS column. Falling back to the
+            # unprefixed per-group column silently replaced the grand total
+            # with the group's own value (every share became 1.0) and made
+            # the unresolved-reference guard below unreachable.
+            if prefixed in rwt_columns:
+                subs[Field(totals_vt_op, col_name)] = Field(rwt_op, prefixed)
 
     rewritten = op.replace(subs)
 
@@ -635,21 +638,19 @@ def attach_windowed_totals(
         try:
             agg_expr = agg_specs[name](new_base)
         except Exception as exc:
-            logger.debug(
-                "could not evaluate agg_spec for %r when attaching windowed totals: %s",
-                name,
-                exc,
-            )
-            continue
+            raise TotalsNotAvailableError(
+                f"Could not evaluate the aggregation for {name!r} while "
+                "attaching totals; a skipped totals column would silently "
+                "substitute the per-group value for the grand total."
+            ) from exc
         try:
             windowed = agg_expr.over(ibis_mod.window())
         except Exception as exc:
-            logger.debug(
-                "could not wrap %r in window() for windowed totals: %s",
-                name,
-                exc,
-            )
-            continue
+            raise TotalsNotAvailableError(
+                f"Could not window the aggregation for {name!r} while "
+                "attaching totals; a skipped totals column would silently "
+                "substitute the per-group value for the grand total."
+            ) from exc
         col = f"{totals_prefix}{name}"
         new_base = new_base.mutate(**{col: windowed})
         arbitrary_specs[col] = (lambda t, _c=col: t[_c].arbitrary())
@@ -772,10 +773,11 @@ def attach_calc_totals(
             else:
                 totals_expr = fn
         except Exception as exc:
-            logger.debug(
-                "calc-of-calc totals evaluation failed for %r: %s", calc_name, exc
-            )
-            continue
+            raise TotalsNotAvailableError(
+                f"Could not evaluate totals for calc measure {calc_name!r}; "
+                "a skipped totals column would silently substitute the "
+                "per-group value for the grand total."
+            ) from exc
         col = f"{totals_prefix}{calc_name}"
         real_agg_tbl = real_agg_tbl.mutate(**{col: totals_expr})
 

src/boring_semantic_layer/expr.py

@@ -1107,7 +1107,7 @@ def join_one(
         self,
         other: SemanticModel,
         on: Callable[[Any, Any], ir.BooleanValue] | str | Deferred | Sequence[str | Deferred],
-        how: str = "inner",
+        how: str = "left",
     ) -> SemanticJoin:
         """Join with one-to-one relationship semantics."""
         return SemanticJoin(
@@ -1243,7 +1243,7 @@ def join_one(
         self,
         other: SemanticModel,
         on: Callable[[Any, Any], ir.BooleanValue] | str | Deferred | Sequence[str | Deferred],
-        how: str = "inner",
+        how: str = "left",
     ) -> SemanticJoin:
         """Join with one-to-one relationship semantics."""
         return SemanticJoin(
@@ -1289,6 +1289,18 @@ def __init__(self, source: SemanticTableOp, keys: tuple[str, ...]) -> None:
         op = SemanticGroupByOp(source=source, keys=keys)
         super().__init__(op)
 
+    def filter(self, predicate: Callable) -> SemanticGroupBy:
+        """Filter rows before aggregation, keeping the grouping keys.
+
+        A filter between group_by and aggregate is pre-aggregation row
+        filtering, so it commutes with the grouping. The inherited filter
+        wrapped the group-by op itself, and aggregate() — which only
+        recovers keys from its direct source — silently dropped the
+        requested grouping.
+        """
+        filtered = SemanticFilter(source=self.op().source, predicate=predicate)
+        return SemanticGroupBy(source=filtered.op(), keys=self.op().keys)
+
     @property
     def source(self):
         return self.op().source
@@ -1469,7 +1481,7 @@ def join_one(
         self,
         other: SemanticModel,
         on: Callable[[Any, Any], ir.BooleanValue] | str | Deferred | Sequence[str | Deferred],
-        how: str = "inner",
+        how: str = "left",
     ) -> SemanticJoin:
         """Join with one-to-one relationship semantics."""
         return SemanticJoin(

src/boring_semantic_layer/nested_compile.py

@@ -140,7 +140,10 @@ def join_tables(by_cols: Iterable[str], tables: list) -> Any:
     by_cols_set = set(by_cols)
 
     def join_step(left, right):
-        predicates = [left[c] == right[c] for c in by_cols]
+        # Null-safe equality: group keys can legitimately be NULL (real NULL
+        # dim values, or keys minted by an outer join). Plain == drops those
+        # groups from every table but the first.
+        predicates = [left[c].identical_to(right[c]) for c in by_cols]
         right_cols = [c for c in right.columns if c not in by_cols_set]
         right_select = [right[c] for c in right_cols]
         return left.left_join(right, predicates).select([left] + right_select)