fix(exec): eagerly validate window function args, FILTER and WHERE too

Extends the window `OVER` column validator to a complete window-query column
check. In addition to each window spec's `PARTITION BY` / `ORDER BY`, it now
resolves the projection expressions (a window function's arguments and its
`FILTER` predicate are visited by the shallow-column walker), the `WHERE`, and
each join `ON` against the base source columns, plus `GROUP BY` / `HAVING` / the
query's top-level `ORDER BY` with the usual output-alias exemption for a bare
name. So `sum(zzz) OVER ()`, `sum(a) FILTER(WHERE zzz > 0) OVER ()`, and a bad
`WHERE` column in a window query are now rejected at prepare time — matching
SQLite — even over an empty or filtered table, closing the last window-query
lazy-validation gaps. Verified vs sqlite3 3.50.4
(`tests/eager_window_over_columns.rs`).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

src/exec/mod.rs

@@ -21104,12 +21104,49 @@ impl Connection {
         for t in &sel.order_by {
             gather(&t.expr, &mut specs);
         }
-        let mut parts: Vec<&Expr> = Vec::new();
+        // Base-column targets with NO output-alias exemption: the projection exprs
+        // (`walk_shallow_columns` visits a window function's arguments and `FILTER`
+        // predicate), `WHERE`, each join `ON`, and every window spec's
+        // `PARTITION BY` / `ORDER BY` (which never bind to an output alias).
+        let mut strict: Vec<&Expr> = Vec::new();
+        for rc in &sel.columns {
+            if let ResultColumn::Expr { expr, .. } = rc {
+                strict.push(expr);
+            }
+        }
+        if let Some(w) = &sel.where_clause {
+            strict.push(w);
+        }
+        for j in &from.joins {
+            if let Some(on) = &j.on {
+                strict.push(on);
+            }
+        }
         for spec in &specs {
-            windowspec_parts(spec, &mut parts);
+            windowspec_parts(spec, &mut strict);
+        }
+        // `GROUP BY` / `HAVING` / the query's top-level `ORDER BY` may name an
+        // output alias with a bare identifier, which is not a base column.
+        let aliases: Vec<&str> = sel
+            .columns
+            .iter()
+            .filter_map(|c| match c {
+                ResultColumn::Expr { alias: Some(a), .. } => Some(a.as_str()),
+                _ => None,
+            })
+            .collect();
+        let mut clause_refs: Vec<&Expr> = Vec::new();
+        for g in &sel.group_by {
+            clause_refs.push(g);
+        }
+        if let Some(h) = &sel.having {
+            clause_refs.push(h);
+        }
+        for t in &sel.order_by {
+            clause_refs.push(&t.expr);
         }
         let mut missing: Option<Error> = None;
-        for e in parts {
+        for e in strict {
             if missing.is_some() {
                 break;
             }
@@ -21119,6 +21156,22 @@ impl Connection {
                 }
             });
         }
+        for e in clause_refs {
+            if missing.is_some() {
+                break;
+            }
+            walk_shallow_columns(e, &mut |schema, table, column, quoted| {
+                if missing.is_some() {
+                    return;
+                }
+                if table.is_none() && aliases.iter().any(|a| a.eq_ignore_ascii_case(column)) {
+                    return;
+                }
+                if !column_resolves_scoped(columns, schema, table, column) {
+                    missing = Some(eval::no_such_column(schema, table, column, quoted));
+                }
+            });
+        }
         match missing {
             Some(e) => Err(e),
             None => Ok(()),

tests/eager_window_over_columns.rs

@@ -40,21 +40,55 @@ fn window_over_column_validation_matches_sqlite() {
         // Bad column in an OVER clause → rejected (empty table, so caught eagerly).
         (empty, "SELECT sum(a) OVER (PARTITION BY zzz) FROM t"),
         (empty, "SELECT sum(a) OVER (ORDER BY zzz) FROM t"),
-        (empty, "SELECT sum(a) OVER (PARTITION BY a ORDER BY zzz) FROM t"),
-        (empty, "SELECT sum(a) OVER w FROM t WINDOW w AS (PARTITION BY zzz)"),
+        (
+            empty,
+            "SELECT sum(a) OVER (PARTITION BY a ORDER BY zzz) FROM t",
+        ),
+        (
+            empty,
+            "SELECT sum(a) OVER w FROM t WINDOW w AS (PARTITION BY zzz)",
+        ),
         (empty, "SELECT 1 + sum(a) OVER (PARTITION BY zzz) FROM t"),
         // An output alias is NOT a valid window partition/order term.
         (full, "SELECT a AS x, sum(b) OVER (PARTITION BY x) FROM t"),
+        // A bad column in a window function's argument, its FILTER, or the WHERE
+        // of a window query is likewise rejected at prepare time.
+        (empty, "SELECT sum(zzz) OVER () FROM t"),
+        (empty, "SELECT sum(a) FILTER(WHERE zzz > 0) OVER () FROM t"),
+        (
+            empty,
+            "SELECT count(*) OVER (PARTITION BY a ORDER BY b), sum(zzz) OVER () FROM t",
+        ),
+        (
+            empty,
+            "SELECT a FROM t WHERE zzz > 0 AND sum(a) OVER () > 0",
+        ),
         // Valid — must not be a false positive.
-        (full, "SELECT sum(a) OVER (PARTITION BY b ORDER BY a) FROM t"),
+        (
+            full,
+            "SELECT sum(a) OVER (PARTITION BY b ORDER BY a) FROM t",
+        ),
         (full, "SELECT sum(a) OVER (PARTITION BY a + 0) FROM t"),
         (full, "SELECT sum(b) OVER (PARTITION BY rowid) FROM t"),
         (full, "SELECT sum(b) OVER w FROM t WINDOW w AS (ORDER BY a)"),
         (
             full,
             "SELECT t.a, sum(d) OVER (PARTITION BY t.b) FROM t JOIN u ON t.a = u.c",
         ),
-        (full, "SELECT row_number() OVER (ORDER BY a), a FROM t ORDER BY a"),
+        (
+            full,
+            "SELECT row_number() OVER (ORDER BY a), a FROM t ORDER BY a",
+        ),
+        (full, "SELECT sum(a) FILTER(WHERE b > 0) OVER () FROM t"),
+        (
+            full,
+            "SELECT a AS x, sum(b) OVER (ORDER BY a) FROM t ORDER BY x",
+        ),
+        (full, "SELECT sum(a + b) OVER () FROM t"),
+        (
+            full,
+            "SELECT a, row_number() OVER (ORDER BY b) AS rn FROM t ORDER BY rn",
+        ),
     ];
     for (base, q) in cases {
         assert_eq!(