fix: HAVING/ORDER BY stripped columns not in SELECT, compiler missed HAVING aggregates, append dropped booleans

Three bugs fixed:

1. SqlWrappingExecutor applied projection filter (step 3b) before HAVING
   and ORDER BY, stripping aggregate/sort columns not in SELECT.
   Example: SELECT dept FROM t GROUP BY dept HAVING SUM(salary) > 1000
   would strip sum_salary before HAVING could evaluate it.
   Fix: defer projections to after HAVING + ORDER BY (step 5b), also
   strip projections from inner query when HAVING or multi-sort present,
   and propagate correct columns to final result.

2. Compiler only extracted aggregates from SELECT items. HAVING
   referencing aggregates not in SELECT (e.g. HAVING COUNT(*) > 5 with
   SELECT dept) produced no aggregates — executor never computed them.
   Fix: extractAggregatesFromExpr() walks HAVING expression tree and
   adds missing aggregates (deduped) before rewriting to column refs.

3. local-executor append() silently dropped boolean columns — the
   if/else chain handled number/bigint/string but not boolean.
   Fix: added boolean branch converting to int64 (0/1).

Author: teamchong

src/local-executor.ts

@@ -130,6 +130,10 @@ export class LocalExecutor implements QueryExecutor {
         const arr = new BigInt64Array(rows.length);
         for (let i = 0; i < rows.length; i++) arr[i] = rows[i][colName] as bigint;
         columnArrays.push({ name: colName, dtype: "int64", values: arr.buffer });
+      } else if (typeof sample === "boolean") {
+        const arr = new BigInt64Array(rows.length);
+        for (let i = 0; i < rows.length; i++) { const v = rows[i][colName]; arr[i] = v === null || v === undefined ? 0n : v ? 1n : 0n; }
+        columnArrays.push({ name: colName, dtype: "int64", values: arr.buffer });
       } else if (typeof sample === "string") {
         const enc = textEncoder;
         const parts: Uint8Array[] = [];

src/sql/compiler.ts

@@ -152,8 +152,10 @@ export function compileFull(stmt: SelectStmt): SqlCompileResult {
   }
 
   // HAVING — rewrite aggregate calls to column refs for post-aggregation evaluation
+  // Also extract any aggregates referenced in HAVING that aren't already in SELECT
   let havingExpr: SqlExpr | undefined;
   if (stmt.groupBy?.having) {
+    extractAggregatesFromExpr(stmt.groupBy.having, aggregates);
     havingExpr = rewriteAggregatesAsColumns(stmt.groupBy.having);
   }
 
@@ -235,6 +237,48 @@ function isAggregateCall(name: string): boolean {
   return AGGREGATE_FNS.has(name.toUpperCase());
 }
 
+/** Walk an expression and add any aggregate calls to the list (deduped by fn+column). */
+function extractAggregatesFromExpr(expr: SqlExpr, aggregates: AggregateOp[]): void {
+  switch (expr.kind) {
+    case "call":
+      if (isAggregateCall(expr.name)) {
+        const agg = compileAggregate(expr);
+        // Dedupe: don't add if an equivalent aggregate already exists
+        const exists = aggregates.some(a => a.fn === agg.fn && a.column === agg.column);
+        if (!exists) aggregates.push(agg);
+      }
+      for (const arg of expr.args) extractAggregatesFromExpr(arg, aggregates);
+      return;
+    case "binary":
+      extractAggregatesFromExpr(expr.left, aggregates);
+      extractAggregatesFromExpr(expr.right, aggregates);
+      return;
+    case "unary":
+      extractAggregatesFromExpr(expr.operand, aggregates);
+      return;
+    case "between":
+      extractAggregatesFromExpr(expr.expr, aggregates);
+      extractAggregatesFromExpr(expr.low, aggregates);
+      extractAggregatesFromExpr(expr.high, aggregates);
+      return;
+    case "in_list":
+      extractAggregatesFromExpr(expr.expr, aggregates);
+      for (const v of expr.values) extractAggregatesFromExpr(v, aggregates);
+      return;
+    case "case_expr":
+      if (expr.operand) extractAggregatesFromExpr(expr.operand, aggregates);
+      for (const w of expr.whenClauses) {
+        extractAggregatesFromExpr(w.condition, aggregates);
+        extractAggregatesFromExpr(w.result, aggregates);
+      }
+      if (expr.elseResult) extractAggregatesFromExpr(expr.elseResult, aggregates);
+      return;
+    case "cast":
+      extractAggregatesFromExpr(expr.expr, aggregates);
+      return;
+  }
+}
+
 function compileAggregate(expr: SqlExpr & { kind: "call" }, alias?: string): AggregateOp {
   let fn = expr.name.toLowerCase() as AggregateOp["fn"];
   let column = "*";

src/sql/executor.ts

@@ -55,10 +55,13 @@ export class SqlWrappingExecutor implements QueryExecutor {
       delete innerQuery.groupBy;
     }
 
-    // If we have computed expressions, we need all columns for evaluation
-    // — strip projections from inner query and apply them after computing
+    // Strip projections when we need columns not in SELECT:
+    // - computedExprs reference arbitrary columns for CASE/CAST/arithmetic
+    // - havingExpr references aggregate columns that may not be in SELECT
+    // - multi-column ORDER BY may sort on columns not in SELECT
+    // Projections are re-applied after HAVING and ORDER BY (step 5b).
     let savedProjections: string[] | undefined;
-    if (this.opts.computedExprs && this.opts.computedExprs.length > 0) {
+    if ((this.opts.computedExprs && this.opts.computedExprs.length > 0) || this.opts.havingExpr || hasMultiSort) {
       savedProjections = innerQuery.projections;
       innerQuery.projections = [];
     }
@@ -105,16 +108,6 @@ export class SqlWrappingExecutor implements QueryExecutor {
       });
     }
 
-    // 3b. Apply deferred projections (after computed expressions added their columns)
-    if (savedProjections && savedProjections.length > 0) {
-      const keep = new Set([...savedProjections, ...((this.opts.computedExprs ?? []).map(e => e.alias))]);
-      rows = rows.map(row => {
-        const out: Row = {};
-        for (const k of keep) if (k in row) out[k] = row[k];
-        return out;
-      });
-    }
-
     // 4. HAVING filter (post-aggregation)
     if (this.opts.havingExpr) {
       const havingExpr = this.opts.havingExpr;
@@ -143,13 +136,26 @@ export class SqlWrappingExecutor implements QueryExecutor {
       });
     }
 
+    // 5b. Apply deferred projections (after HAVING/ORDER BY which may reference non-SELECT columns)
+    if (savedProjections && savedProjections.length > 0) {
+      const keep = new Set([...savedProjections, ...((this.opts.computedExprs ?? []).map(e => e.alias))]);
+      rows = rows.map(row => {
+        const out: Row = {};
+        for (const k of keep) if (k in row) out[k] = row[k];
+        return out;
+      });
+    }
+
     // 6. Re-apply offset + limit (stripped when post-filtering or multi-sorting)
     if (needsExternalLimit) {
       if (externalOffset) rows = rows.slice(externalOffset);
       if (externalLimit !== undefined) rows = rows.slice(0, externalLimit);
     }
 
-    return { ...result, rows, rowCount: rows.length };
+    const finalColumns = savedProjections && savedProjections.length > 0
+      ? [...new Set([...savedProjections, ...((this.opts.computedExprs ?? []).map(e => e.alias))])]
+      : result.columns;
+    return { ...result, rows, rowCount: rows.length, columns: finalColumns };
   }
 
   async explain(query: QueryDescriptor): Promise<import("../types.js").ExplainResult> {

src/sql/integration.test.ts

@@ -207,6 +207,43 @@ describe("SQL Integration - buildSqlDataFrame", () => {
   });
 });
 
+describe("SQL Integration - HAVING with projections", () => {
+  it("HAVING references aggregate column not in SELECT", async () => {
+    const df = buildSqlDataFrame(
+      "SELECT dept FROM data GROUP BY dept HAVING SUM(salary) > 300000",
+      makeExecutor(),
+    );
+    const result = await df.collect();
+    // eng: 120k+95k+130k = 345k > 300k ✓, sales: 110k+105k = 215k < 300k ✗
+    expect(result.rowCount).toBe(1);
+    expect(result.rows[0].dept).toBe("eng");
+    // sum_salary should NOT be in final output since it's not in SELECT
+    expect(result.columns).toEqual(["dept"]);
+  });
+
+  it("HAVING with COUNT not in SELECT", async () => {
+    const df = buildSqlDataFrame(
+      "SELECT dept FROM data GROUP BY dept HAVING COUNT(*) >= 3",
+      makeExecutor(),
+    );
+    const result = await df.collect();
+    // eng: 3 rows ✓, sales: 2 rows ✗
+    expect(result.rowCount).toBe(1);
+    expect(result.rows[0].dept).toBe("eng");
+  });
+
+  it("ORDER BY column not in SELECT", async () => {
+    const df = buildSqlDataFrame(
+      "SELECT name FROM data ORDER BY age ASC, salary DESC",
+      makeExecutor(),
+    );
+    const result = await df.collect();
+    // Bob(25), Diana(28), Alice(30), Eve(32), Charlie(35)
+    expect(result.rows.map(r => r.name)).toEqual(["Bob", "Diana", "Alice", "Eve", "Charlie"]);
+    expect(result.columns).toEqual(["name"]);
+  });
+});
+
 describe("SQL Integration - CTEs", () => {
   it("CTE inlines filters into main query", async () => {
     const df = buildSqlDataFrame(