Fix: window dim check takes priority over metric check in filter classification

Author: nicosuave

sidemantic/sql/generator.py

@@ -735,21 +735,27 @@ def _classify_filters_for_pushdown(
                             if dim and dim.window is not None:
                                 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)
-            # 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).
+            # Window-dim filters take priority: 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).
+            # This check must come BEFORE the metric check because a filter
+            # that references both a metric and a window dimension (e.g.,
+            # "orders.next_status = 'complete' OR orders.revenue > 100") must
+            # NOT land in main_query_filters/shared_filters: preagg CTEs do
+            # not project window dimension columns, so applying the filter on
+            # the outer preagg join would reference a non-existent column.
             # 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:
+            if window_dim_models:
                 for wdm in window_dim_models:
                     window_dim_filters[wdm].append(filter_expr)
+            # Filters that reference metrics must stay in main query (can't push down)
+            # because metrics don't exist in CTEs (only _raw columns)
+            elif references_metric:
+                main_query_filters.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

@@ -685,3 +685,84 @@ def test_multi_model_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, "Multi-model window-dim filter should be pushed into orders sub-query"
+
+
+def test_mixed_metric_and_window_dim_filter_excluded_from_preagg_shared_filters(layer):
+    """Test that a filter referencing both a metric and a window dim goes to window_dim_filters.
+
+    When a filter like "orders.next_status = 'complete' OR orders.revenue > 100"
+    references both a window dimension (next_status) and a metric (revenue), the
+    window dim check must take priority over the metric check. Otherwise the filter
+    lands in main_query_filters/shared_filters and gets rewritten onto preagg CTEs
+    that don't project window dimension columns, causing a runtime failure.
+    """
+    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=[],
+        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)
+
+    # Filter references BOTH a window dim (next_status) and a metric (revenue)
+    sql = layer.compile(
+        metrics=["orders.revenue", "order_items.quantity"],
+        dimensions=["orders.order_date"],
+        filters=["orders.next_status = 'complete' OR orders.revenue > 100"],
+    )
+
+    # Should use pre-aggregation path
+    assert "orders_preagg" in sql, "Should use pre-aggregation path"
+    assert "order_items_preagg" in sql, "Should use pre-aggregation path"
+
+    # The mixed filter must NOT appear in the outer WHERE referencing _preagg
+    # because preagg CTEs don't project window dimension columns
+    assert "orders_preagg.next_status" not in sql, "Mixed metric/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, "Mixed metric/window-dim filter should be pushed into orders sub-query"