fix(tsql): inject time fallbacks into FROM subqueries

The fallback WHERE injection only targeted the top-level SELECT, so a
query shaped as an outer aggregation over a FROM subquery failed to
compile: the time column only exists inside the subquery. Descend into
the subquery so the fallback lands next to the table reference.

Author: ericallam

internal-packages/tsql/src/index.test.ts

@@ -231,6 +231,26 @@ describe("injectFallbackConditions", () => {
       expect(modified.where.expression_type).toBe("and");
     }
   });
+
+  it("should inject into a FROM subquery, where the fallback column's table lives", () => {
+    const ast = parseTSQLSelect(
+      "SELECT t, sum(total) AS total FROM (SELECT time AS t, status, count(*) AS total FROM task_runs GROUP BY t, status) GROUP BY t"
+    );
+    const fallbacks: Record<string, WhereClauseCondition> = {
+      time: { op: "gte", value: "2024-01-01" },
+    };
+
+    const modified = injectFallbackConditions(ast, fallbacks);
+    expect(modified.expression_type).toBe("select_query");
+    if (modified.expression_type === "select_query") {
+      expect(modified.where).toBeUndefined();
+      const inner = modified.select_from?.table;
+      expect(inner?.expression_type).toBe("select_query");
+      if (inner?.expression_type === "select_query") {
+        expect(isColumnReferencedInExpression(inner.where, "time")).toBe(true);
+      }
+    }
+  });
 });
 
 describe("compileTSQL with whereClauseFallback", () => {

internal-packages/tsql/src/index.ts

@@ -429,6 +429,24 @@ export function injectFallbackConditions(
 
   // Handle SelectQuery
   const selectQuery = ast as SelectQuery;
+
+  // When the FROM is a subquery, the fallback columns belong to the inner query's
+  // table, not this level; descend so e.g. a time fallback lands next to the table ref.
+  const fromTable = selectQuery.select_from?.table;
+  if (
+    fromTable &&
+    (fromTable.expression_type === "select_query" ||
+      fromTable.expression_type === "select_set_query")
+  ) {
+    return {
+      ...selectQuery,
+      select_from: {
+        ...selectQuery.select_from!,
+        table: injectFallbackConditions(fromTable, fallbacks) as SelectQuery | SelectSetQuery,
+      },
+    };
+  }
+
   const existingWhere = selectQuery.where;
 
   // Collect fallback expressions for columns not already in WHERE