fix: aggregate expression args (COUNT(a+b)) no longer collide with COUNT(*)

compileAggregate and rewriteAggregatesAsColumns both fell back to "*"
for non-column aggregate arguments, causing COUNT(expr) to produce
the same output column name as COUNT(*). Added aggArgKey() in ast.ts
that serializes expressions to deterministic keys (e.g. "add(a,b)"),
used by both sites so HAVING column lookups always match.

Author: teamchong

src/sql/ast.ts

@@ -118,3 +118,26 @@ export type SqlStatement =
   | { kind: "select"; stmt: SelectStmt }
   | { kind: "show_versions"; stmt: ShowVersionsStmt }
   | { kind: "diff"; stmt: DiffStmt };
+
+/**
+ * Deterministic string key for an aggregate argument expression.
+ * Returns "col" for column refs, "*" for star, or a serialized form
+ * for complex expressions (e.g. "add(a,b)" for a + b).
+ * Used by both compileAggregate and rewriteAggregatesAsColumns so
+ * their output column names always match.
+ */
+export function aggArgKey(expr: SqlExpr): string {
+  switch (expr.kind) {
+    case "star": return "*";
+    case "column": return expr.name;
+    case "value": {
+      const v = expr.value;
+      return v.type === "null" ? "null" : String(v.value);
+    }
+    case "binary": return `${expr.op}(${aggArgKey(expr.left)},${aggArgKey(expr.right)})`;
+    case "unary": return `${expr.op}(${aggArgKey(expr.operand)})`;
+    case "call": return `${expr.name}(${expr.args.map(aggArgKey).join(",")})`;
+    case "cast": return `cast(${aggArgKey(expr.expr)},${expr.targetType})`;
+    default: return "_expr";
+  }
+}

src/sql/compiler.test.ts

@@ -94,6 +94,19 @@ describe("SQL Compiler", () => {
     expect(desc.aggregates).toEqual([{ fn: "count_distinct", column: "user_id" }]);
   });
 
+  it("compiles SUM(expression) with deterministic column key", () => {
+    const desc = sql("SELECT SUM(price * quantity) FROM orders");
+    expect(desc.aggregates).toEqual([{ fn: "sum", column: "multiply(price,quantity)" }]);
+  });
+
+  it("COUNT(expr) does not collide with COUNT(*)", () => {
+    const desc = sql("SELECT COUNT(*), COUNT(a + b) FROM t");
+    expect(desc.aggregates).toHaveLength(2);
+    expect(desc.aggregates![0].column).toBe("*");
+    expect(desc.aggregates![1].column).toBe("add(a,b)");
+    expect(desc.aggregates![0].column).not.toBe(desc.aggregates![1].column);
+  });
+
   it("compiles GROUP BY", () => {
     const desc = sql("SELECT region, SUM(sales) FROM data GROUP BY region");
     expect(desc.groupBy).toEqual(["region"]);
@@ -234,6 +247,16 @@ describe("SQL Compiler - compileFull", () => {
     }
   });
 
+  it("HAVING with expression-arg aggregate uses matching column key", () => {
+    const result = sqlFull("SELECT dept, SUM(price * qty) FROM t GROUP BY dept HAVING SUM(price * qty) > 100");
+    expect(result.havingExpr).toBeDefined();
+    if (result.havingExpr!.kind === "binary" && result.havingExpr!.left.kind === "column") {
+      expect(result.havingExpr!.left.name).toBe("sum_multiply(price,qty)");
+    }
+    // Must match the aggregate's column key
+    expect(result.descriptor.aggregates![0].column).toBe("multiply(price,qty)");
+  });
+
   it("returns allOrderBy for multi-column ORDER BY", () => {
     const result = sqlFull("SELECT * FROM t ORDER BY name ASC, age DESC");
     expect(result.allOrderBy).toBeDefined();

src/sql/compiler.ts

@@ -2,7 +2,7 @@
 
 import type { QueryDescriptor } from "../client.js";
 import type { AggregateOp, FilterOp, WindowSpec } from "../types.js";
-import type { SelectStmt, SqlExpr, TableRef, SqlOrderBy, CteDef } from "./ast.js";
+import { aggArgKey, type SelectStmt, type SqlExpr, type TableRef, type SqlOrderBy, type CteDef } from "./ast.js";
 import { rewriteAggregatesAsColumns } from "./evaluator.js";
 
 const AGGREGATE_FNS = new Set(["COUNT", "SUM", "AVG", "MIN", "MAX", "COUNT_DISTINCT", "STDDEV", "VARIANCE", "MEDIAN", "PERCENTILE"]);
@@ -227,6 +227,7 @@ function extractColumnName(expr: SqlExpr): string | undefined {
   return undefined;
 }
 
+
 function isAggregateCall(name: string): boolean {
   return AGGREGATE_FNS.has(name.toUpperCase());
 }
@@ -240,8 +241,7 @@ function compileAggregate(expr: SqlExpr & { kind: "call" }, alias?: string): Agg
   }
 
   if (expr.args.length > 0 && expr.args[0].kind !== "star") {
-    const colName = extractColumnName(expr.args[0]);
-    if (colName) column = colName;
+    column = aggArgKey(expr.args[0]);
   }
 
   const result: AggregateOp = { fn, column };

src/sql/evaluator.ts

@@ -1,7 +1,7 @@
 /** Runtime SQL expression evaluator — evaluates AST nodes against Row data */
 
 import type { Row } from "../types.js";
-import type { SqlExpr } from "./ast.js";
+import { aggArgKey, type SqlExpr } from "./ast.js";
 import { compileLikeRegex } from "../decode.js";
 
 export function evaluateExpr(expr: SqlExpr, row: Row): unknown {
@@ -208,7 +208,7 @@ export function rewriteAggregatesAsColumns(expr: SqlExpr): SqlExpr {
     case "call": {
       const fnUpper = expr.name.toUpperCase();
       if (isAggregate(fnUpper)) {
-        const col = expr.args[0]?.kind === "star" ? "*" : (expr.args[0]?.kind === "column" ? expr.args[0].name : "*");
+        const col = expr.args[0] ? aggArgKey(expr.args[0]) : "*";
         const fn = (expr.distinct && fnUpper === "COUNT") ? "count_distinct" : fnUpper.toLowerCase();
         return { kind: "column", name: `${fn}_${col}` };
       }