Fix: route window dimension filters to outer query

Window function dimensions (LEAD, LAG, etc.) are computed in the CTE
SELECT but haven't been evaluated at CTE WHERE time. The filter pushdown
logic now detects dimensions with window != None and keeps their filters
in the outer query. Also ensures columns referenced by outer-query
filters are included in CTE SELECT lists.

Author: nicosuave

sidemantic/sql/generator.py

@@ -411,6 +411,25 @@ def metric_needs_window(m):
         # Extract columns needed for metric-level filters (before building CTEs)
         metric_filter_cols_by_model = self._extract_metric_filter_columns(metrics)
 
+        # Ensure dimensions referenced in outer-query filters (e.g. window dims)
+        # are included in the relevant CTE SELECT lists.
+        for filter_expr in main_query_filters:
+            try:
+                parsed = sqlglot.parse_one(filter_expr, dialect=self.dialect)
+                for column in parsed.find_all(exp.Column):
+                    if column.table:
+                        model_name = column.table.replace("_cte", "")
+                        if model_name in all_models:
+                            if model_name not in metric_filter_cols_by_model:
+                                metric_filter_cols_by_model[model_name] = set()
+                            metric_filter_cols_by_model[model_name].add(column.name)
+            except Exception:
+                logging.debug(
+                    "Failed to parse outer filter for column extraction: %s",
+                    filter_expr,
+                    exc_info=True,
+                )
+
         # Build CTEs for all models with pushed-down filters
         cte_sqls = []
         for model_name in all_models:
@@ -681,6 +700,7 @@ def _classify_filters_for_pushdown(
             # Find all table references in the filter
             referenced_models = set()
             references_metric = False
+            references_window_dim = False
 
             for column in parsed.find_all(exp.Column):
                 table_name = column.table
@@ -697,10 +717,20 @@ def _classify_filters_for_pushdown(
                         if model and model.get_metric(column_name):
                             references_metric = True
 
+                        # Check if this column is a window dimension
+                        if model:
+                            dim = model.get_dimension(column_name)
+                            if dim and dim.window is not None:
+                                references_window_dim = True
+
             # 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)
+            # Filters on window dimensions must stay in outer query because the
+            # window function hasn't been evaluated yet in the CTE WHERE context
+            elif references_window_dim:
+                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

@@ -384,6 +384,135 @@ def test_metric_level_filters_not_pushed(layer):
     assert "completed" in case_sql
 
 
+def test_window_dimension_filter_not_pushed_down(layer):
+    """Test that filters on window dimensions stay in the outer query.
+
+    Window functions (LEAD, LAG, ROW_NUMBER, etc.) are computed in the CTE
+    SELECT but haven't been evaluated yet at WHERE-clause time, so pushing
+    a filter on a window dimension into the CTE WHERE would produce invalid
+    SQL. The filter must be applied in the outer query instead.
+    """
+    model = Model(
+        name="events",
+        table="events_table",
+        primary_key="event_id",
+        dimensions=[
+            Dimension(name="person_id", type="categorical", sql="person_id"),
+            Dimension(name="event_type", type="categorical", sql="event_type"),
+            Dimension(
+                name="next_event",
+                type="categorical",
+                sql="event_type",
+                window="LEAD(event_type) OVER (PARTITION BY person_id ORDER BY created_at)",
+            ),
+        ],
+        metrics=[
+            Metric(name="event_count", agg="count"),
+        ],
+    )
+
+    layer.add_model(model)
+
+    sql = layer.compile(
+        metrics=["events.event_count"],
+        dimensions=["events.event_type"],
+        filters=["events.next_event = 'purchase'"],
+    )
+
+    parsed = sqlglot.parse_one(sql)
+
+    # Find the CTE
+    cte = None
+    for cte_def in parsed.find_all(exp.CTE):
+        if cte_def.alias == "events_cte":
+            cte = cte_def
+            break
+
+    assert cte is not None, "CTE not found"
+
+    # CTE should NOT have a WHERE clause for the window dimension filter
+    cte_where = cte.this.find(exp.Where)
+    if cte_where is not None:
+        cte_where_sql = cte_where.sql()
+        assert "next_event" not in cte_where_sql, "Window dimension filter should NOT be in CTE WHERE clause"
+        assert "purchase" not in cte_where_sql, "Window dimension filter value should NOT be in CTE WHERE clause"
+
+    # The window expression should still appear in the CTE SELECT
+    cte_sql = cte.sql()
+    assert "LEAD" in cte_sql.upper(), "Window function should appear in CTE SELECT"
+
+    # The filter should appear in the outer query WHERE
+    outer_where = parsed.find(exp.Where)
+    assert outer_where is not None, "Filter should be in outer query WHERE"
+    outer_where_sql = outer_where.sql()
+    assert "next_event" in outer_where_sql or "purchase" in outer_where_sql, (
+        "Window dimension filter should appear in outer query"
+    )
+
+
+def test_window_dimension_filter_with_regular_filter(layer):
+    """Test mixed filters: regular filter pushed down, window filter stays outer."""
+    model = Model(
+        name="events",
+        table="events_table",
+        primary_key="event_id",
+        dimensions=[
+            Dimension(name="person_id", type="categorical", sql="person_id"),
+            Dimension(name="event_type", type="categorical", sql="event_type"),
+            Dimension(
+                name="next_event",
+                type="categorical",
+                sql="event_type",
+                window="LEAD(event_type) OVER (PARTITION BY person_id ORDER BY created_at)",
+            ),
+        ],
+        metrics=[
+            Metric(name="event_count", agg="count"),
+        ],
+    )
+
+    layer.add_model(model)
+
+    sql = layer.compile(
+        metrics=["events.event_count"],
+        dimensions=["events.event_type"],
+        filters=[
+            "events.event_type = 'click'",
+            "events.next_event = 'purchase'",
+        ],
+    )
+
+    parsed = sqlglot.parse_one(sql)
+
+    # Find the CTE
+    cte = None
+    for cte_def in parsed.find_all(exp.CTE):
+        if cte_def.alias == "events_cte":
+            cte = cte_def
+            break
+
+    assert cte is not None, "CTE not found"
+
+    # Regular filter (event_type) should be pushed into CTE WHERE
+    cte_where = cte.this.find(exp.Where)
+    assert cte_where is not None, "Regular filter should be pushed into CTE WHERE"
+    cte_where_sql = cte_where.sql()
+    assert "event_type" in cte_where_sql, "Regular filter should be in CTE WHERE"
+    assert "click" in cte_where_sql, "Regular filter value should be in CTE WHERE"
+
+    # Window filter (next_event) should NOT be in CTE WHERE
+    assert "next_event" not in cte_where_sql, "Window dimension filter should NOT be in CTE WHERE"
+    assert "purchase" not in cte_where_sql, "Window dimension filter value should NOT be in CTE WHERE"
+
+    # Window filter should be in outer query WHERE
+    outer_where = parsed.find(exp.Where)
+    assert outer_where is not None, "Window filter should be in outer query"
+    outer_where_sql = outer_where.sql()
+    assert "next_event" in outer_where_sql or "purchase" in outer_where_sql, (
+        "Window dimension filter should appear in outer query WHERE"
+    )
+
+
 if __name__ == "__main__":
     import pytest