Fix: route multi-model window filters away from preagg shared WHERE

Author: nicosuave

sidemantic/sql/generator.py

@@ -679,10 +679,11 @@ def _classify_filters_for_pushdown(
             Tuple of (pushdown_filters_by_model, main_query_filters, window_dim_filters_by_model)
             - pushdown_filters_by_model: Dict mapping model name to list of filters for that model
             - main_query_filters: Filters that reference multiple models or metrics (can't push down)
-            - window_dim_filters_by_model: Dict mapping model name to filters on window dimensions.
-              These can't be pushed into CTE WHERE (window not yet evaluated) but reference a
-              single model. In the standard path they belong in the outer query; in the preagg
-              path they are pushed into each model's sub-query (which has its own outer WHERE).
+            - window_dim_filters_by_model: Dict mapping model name to filters that reference
+              a window dimension on that model. These can't be pushed into CTE WHERE (window
+              not yet evaluated). In the standard path they belong in the outer query; in the
+              preagg path they are pushed into each model's sub-query (which has its own outer
+              WHERE). Multi-model filters are keyed by the model that owns the window dim.
         """
         pushdown_filters = {model: [] for model in all_models}
         main_query_filters = []
@@ -711,7 +712,7 @@ def _classify_filters_for_pushdown(
             # Find all table references in the filter
             referenced_models = set()
             references_metric = False
-            references_window_dim = False
+            window_dim_models: set[str] = set()
 
             for column in parsed.find_all(exp.Column):
                 table_name = column.table
@@ -732,22 +733,23 @@ def _classify_filters_for_pushdown(
                         if model:
                             dim = model.get_dimension(column_name)
                             if dim and dim.window is not None:
-                                references_window_dim = True
+                                window_dim_models.add(clean_name)
 
             # Filters that reference metrics must stay in main query (can't push down)
             # because metrics don't exist in CTEs (only _raw columns)
             if references_metric:
                 main_query_filters.append(filter_expr)
-            # Single-model window-dim filters: kept separate so callers can
-            # handle them appropriately.  In the standard path they go to the
-            # outer WHERE; in the preagg path they are pushed into each model's
-            # sub-query (which has its own outer WHERE after window evaluation).
-            elif references_window_dim and len(referenced_models) == 1:
-                model_name = list(referenced_models)[0]
-                window_dim_filters[model_name].append(filter_expr)
-            elif references_window_dim:
-                # Window-dim filter spanning multiple models: outer query
-                main_query_filters.append(filter_expr)
+            # Window-dim filters: kept separate so callers can handle them
+            # appropriately.  In the standard path they go to the outer WHERE;
+            # in the preagg path they are pushed into each model's sub-query
+            # (which has its own outer WHERE after window evaluation).
+            # For multi-model filters, route to each model that owns a window
+            # dim column so the preagg path includes them in the correct
+            # sub-queries (the recursive generate() call will join in any
+            # additional models referenced by the filter).
+            elif window_dim_models:
+                for wdm in window_dim_models:
+                    window_dim_filters[wdm].append(filter_expr)
             # If filter references exactly one model and no metrics, push it down
             elif len(referenced_models) == 1:
                 model = list(referenced_models)[0]

tests/optimizations/test_predicate_pushdown.py

@@ -602,3 +602,86 @@ def test_window_dim_filter_excluded_from_preagg_shared_filters(layer):
     preagg_end = sql.index("order_items_preagg AS (")
     orders_subquery = sql[preagg_start:preagg_end]
     assert "next_status" in orders_subquery, "Window-dim filter should be pushed into orders sub-query"
+
+
+def test_multi_model_window_dim_filter_excluded_from_preagg_shared_filters(layer):
+    """Test that multi-model window-dim filters do not become shared_filters in the preagg path.
+
+    When a filter references columns from multiple models and at least one is a
+    window dimension, it must NOT be applied as a shared filter on preagg CTEs
+    (which only project query dimensions/metrics, not window columns). Instead it
+    should be routed into window_dim_filters for the model that owns the window
+    dimension, so the recursive generate() call can handle it.
+    """
+    from sidemantic.core.model import Relationship
+
+    orders = Model(
+        name="orders",
+        table="orders_table",
+        primary_key="order_id",
+        dimensions=[
+            Dimension(name="status", type="categorical", sql="status"),
+            Dimension(
+                name="next_status",
+                type="categorical",
+                sql="status",
+                window="LEAD(status) OVER (PARTITION BY customer_id ORDER BY created_at)",
+            ),
+            Dimension(name="order_date", type="time", sql="order_date", granularity="day"),
+        ],
+        metrics=[
+            Metric(name="revenue", agg="sum", sql="amount"),
+        ],
+        relationships=[
+            Relationship(
+                name="order_items",
+                type="one_to_many",
+                sql="order_id",
+                foreign_key="order_id",
+            ),
+        ],
+    )
+
+    order_items = Model(
+        name="order_items",
+        table="order_items_table",
+        primary_key="item_id",
+        dimensions=[
+            Dimension(name="item_status", type="categorical", sql="item_status"),
+        ],
+        metrics=[
+            Metric(name="quantity", agg="sum", sql="qty"),
+        ],
+        relationships=[
+            Relationship(
+                name="orders",
+                type="many_to_one",
+                foreign_key="order_id",
+                primary_key="order_id",
+            ),
+        ],
+    )
+
+    layer.add_model(orders)
+    layer.add_model(order_items)
+
+    # Multi-model filter: window dim from orders + regular dim from order_items
+    sql = layer.compile(
+        metrics=["orders.revenue", "order_items.quantity"],
+        dimensions=["orders.order_date"],
+        filters=["orders.next_status = order_items.item_status"],
+    )
+
+    # The SQL should use pre-aggregation (two model CTEs joined together)
+    assert "orders_preagg" in sql, "Should use pre-aggregation path"
+    assert "order_items_preagg" in sql, "Should use pre-aggregation path"
+
+    # The multi-model window-dim filter must NOT appear in the outer WHERE
+    # referencing _preagg CTEs, because preagg CTEs don't project window columns
+    assert "orders_preagg.next_status" not in sql, "Multi-model window-dim filter should NOT reference preagg CTE"
+
+    # The filter should be pushed into the orders sub-query instead
+    preagg_start = sql.index("orders_preagg AS (")
+    preagg_end = sql.index("order_items_preagg AS (")
+    orders_subquery = sql[preagg_start:preagg_end]
+    assert "next_status" in orders_subquery, "Multi-model window-dim filter should be pushed into orders sub-query"