squirreling 0.12.2 → 0.12.4

package/README.md

@@ -140,7 +140,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 
 - `SELECT` statements with `DISTINCT`, `WHERE`, `ORDER BY`, `LIMIT`, `OFFSET`
 - `WITH` clause for Common Table Expressions (CTEs)
-- Subqueries in `SELECT`, `FROM`, and `WHERE` clauses
+- Subqueries in `SELECT`, `FROM`, `WHERE`, and correlated subqueries
 - `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`, `CROSS JOIN`, `POSITIONAL JOIN`
 - `GROUP BY` and `HAVING` clauses
 - Set operations: `UNION`, `UNION ALL`, `INTERSECT`, `INTERSECT ALL`, `EXCEPT`, `EXCEPT ALL`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

package/src/execute/execute.js

@@ -2,7 +2,8 @@ import { memorySource } from '../backend/dataSource.js'
 import { derivedAlias } from '../expression/alias.js'
 import { evaluateExpr } from '../expression/evaluate.js'
 import { parseSql } from '../parse/parse.js'
-import { planSql } from '../plan/plan.js'
+import { planSql, planStatement } from '../plan/plan.js'
+import { fromAlias } from '../plan/columns.js'
 import { validateScan, validateTable } from '../validation/tables.js'
 import { executeHashAggregate, executeScalarAggregate } from './aggregates.js'
 import { executeHashJoin, executeNestedLoopJoin, executePositionalJoin } from './join.js'
@@ -24,30 +25,18 @@ export function executeSql({ tables, query, functions, signal }) {
   const parsed = typeof query === 'string' ? parseSql({ query, functions }) : query
 
   // Normalize tables: convert arrays to AsyncDataSource
-  // Fast path: skip normalization when no arrays are present
-  let needsNormalization = false
-  const tableKeys = Object.keys(tables)
-  for (let i = 0; i < tableKeys.length; i++) {
-    if (Array.isArray(tables[tableKeys[i]])) {
-      needsNormalization = true
-      break
-    }
-  }
-
   /** @type {Record<string, AsyncDataSource>} */
-  let normalizedTables
-  if (needsNormalization) {
-    normalizedTables = {}
-    for (let i = 0; i < tableKeys.length; i++) {
-      const name = tableKeys[i]
-      const data = tables[name]
-      normalizedTables[name] = Array.isArray(data) ? memorySource({ data }) : data
+  const normalizedTables = {}
+  for (const [name, data] of Object.entries(tables)) {
+    if (Array.isArray(data)) {
+      normalizedTables[name] = memorySource({ data })
+    } else {
+      normalizedTables[name] = data
     }
-  } else {
-    normalizedTables = /** @type {Record<string, AsyncDataSource>} */ (tables)
   }
 
-  const context = { tables: normalizedTables, functions, signal }
+  const scope = statementScope(parsed)
+  const context = { tables: normalizedTables, functions, signal, scope }
   const plan = planSql({ query: parsed, functions, tables: normalizedTables })
   return executePlan({ plan, context })
 }
@@ -58,11 +47,26 @@ export function executeSql({ tables, query, functions, signal }) {
  * @param {Object} options
  * @param {Statement} options.query
  * @param {ExecuteContext} options.context
+ * @param {string[]} [options.outerScope] - outer query aliases for correlated subqueries
  * @returns {QueryResults}
  */
-export function executeStatement({ query, context }) {
-  const plan = planSql({ query, functions: context.functions, tables: context.tables })
-  return executePlan({ plan, context })
+export function executeStatement({ query, context, outerScope }) {
+  const plan = planStatement({ stmt: query, tables: context.tables, outerScope })
+  // Compute this query's scope (FROM alias + JOIN aliases) for nested correlated subqueries
+  const scope = statementScope(query)
+  return executePlan({ plan, context: scope ? { ...context, scope } : context })
+}
+
+/**
+ * Extracts the table aliases from a statement's FROM and JOIN clauses.
+ *
+ * @param {Statement} stmt
+ * @returns {string[] | undefined}
+ */
+function statementScope(stmt) {
+  if (stmt.type === 'with') return statementScope(stmt.query)
+  if (stmt.type === 'compound') return undefined
+  return [fromAlias(stmt.from), ...stmt.joins.map(j => j.alias ?? j.table)]
 }
 
 /**

package/src/expression/evaluate.js

@@ -39,6 +39,10 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       if (qualified in row.cells) {
         return row.cells[qualified]()
       }
+      // Check outer row for correlated subquery references
+      if (context.outerRow && context.outerAliases?.has(node.prefix) && node.name in context.outerRow.cells) {
+        return context.outerRow.cells[node.name]()
+      }
       // Fall back to just the column part
       if (node.name in row.cells) {
         return row.cells[node.name]()
@@ -66,7 +70,11 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
 
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
-    const gen = executeStatement({ query: node.subquery, context }).rows()
+    const outerScope = context.scope
+    const subContext = outerScope
+      ? { ...context, outerRow: row, outerAliases: new Set(outerScope) }
+      : context
+    const gen = executeStatement({ query: node.subquery, context: subContext, outerScope }).rows()
     const { value } = await gen.next()
     gen.return(undefined)
     if (!value) return null

package/src/parse/functions.js

@@ -104,6 +104,16 @@ export function parseFunctionCall(state, positionStart) {
     expect(state, 'paren', ')')
   }
 
+  // Check for OVER clause (window functions not supported)
+  const overTok = current(state)
+  if (overTok.type === 'identifier' && overTok.value.toUpperCase() === 'OVER') {
+    throw new ParseError({
+      message: `Window functions are not supported: ${funcName}(...) OVER (...)`,
+      positionStart,
+      positionEnd: overTok.positionEnd,
+    })
+  }
+
   return {
     type: 'function',
     funcName,

package/src/plan/columns.js

@@ -163,7 +163,54 @@ function collectColumnsFromExpr(expr, columns, aliases) {
       collectColumnsFromExpr(expr.elseResult, columns, aliases)
     }
   }
-  // No columns: count(*), literal, interval, exists, not exists, subquery
+  // Subqueries: collect prefixed identifiers for correlated column detection.
+  // Only prefixed identifiers are collected because correlated outer references
+  // are always qualified (e.g. users.id, a.session_id). Unprefixed identifiers
+  // from the inner query would incorrectly be attributed to the outer table.
+  if (expr.type === 'subquery' || expr.type === 'in' || expr.type === 'exists' || expr.type === 'not exists') {
+    if (expr.type === 'in') {
+      collectColumnsFromExpr(expr.expr, columns, aliases)
+    }
+    const sub = expr.subquery
+    if (sub) {
+      /** @type {IdentifierNode[]} */
+      const inner = []
+      collectColumnsFromStatement(sub, inner)
+      for (const id of inner) {
+        if (id.prefix) columns.push(id)
+      }
+    }
+  }
+  // No columns: count(*), literal, interval
+}
+
+/**
+ * Collects identifiers from a subquery statement for correlated column detection.
+ *
+ * @param {Statement} stmt
+ * @param {IdentifierNode[]} columns
+ */
+function collectColumnsFromStatement(stmt, columns) {
+  if (stmt.type === 'compound') {
+    collectColumnsFromStatement(stmt.left, columns)
+    collectColumnsFromStatement(stmt.right, columns)
+    return
+  }
+  if (stmt.type === 'with') {
+    collectColumnsFromStatement(stmt.query, columns)
+    return
+  }
+  for (const col of stmt.columns) {
+    if (col.type === 'derived') collectColumnsFromExpr(col.expr, columns)
+  }
+  collectColumnsFromExpr(stmt.where, columns)
+  if (stmt.from?.type === 'subquery') {
+    collectColumnsFromStatement(stmt.from.query, columns)
+  }
+  for (const join of stmt.joins) collectColumnsFromExpr(join.on, columns)
+  for (const expr of stmt.groupBy) collectColumnsFromExpr(expr, columns)
+  collectColumnsFromExpr(stmt.having, columns)
+  for (const item of stmt.orderBy) collectColumnsFromExpr(item.expr, columns)
 }
 
 /**

package/src/plan/plan.js

@@ -32,9 +32,10 @@ export function planSql({ query, functions, tables }) {
  * @param {Map<string, string[]>} [options.cteColumns]
  * @param {Record<string, AsyncDataSource>} [options.tables]
  * @param {IdentifierNode[]} [options.parentColumns] - columns needed by the parent query (for subquery pushdown)
+ * @param {string[]} [options.outerScope] - aliases from an outer query (for correlated subqueries)
  * @returns {QueryPlan}
  */
-function planStatement({ stmt, ctePlans, cteColumns, tables, parentColumns }) {
+export function planStatement({ stmt, ctePlans, cteColumns, tables, parentColumns, outerScope }) {
   if (stmt.type === 'with') {
     // Build CTE plans in order (each CTE can reference preceding CTEs)
     ctePlans ??= new Map()
@@ -44,12 +45,12 @@ function planStatement({ stmt, ctePlans, cteColumns, tables, parentColumns }) {
       ctePlans.set(cte.name.toLowerCase(), ctePlan)
       cteColumns.set(cte.name.toLowerCase(), inferStatementColumns({ stmt: cte.query, cteColumns, tables }))
     }
-    return planStatement({ stmt: stmt.query, ctePlans, cteColumns, tables, parentColumns })
+    return planStatement({ stmt: stmt.query, ctePlans, cteColumns, tables, parentColumns, outerScope })
   }
   if (stmt.type === 'compound') {
-    return planSetOperation({ compound: stmt, ctePlans, cteColumns, tables })
+    return planSetOperation({ compound: stmt, ctePlans, cteColumns, tables, parentColumns })
   }
-  return planSelect({ select: stmt, ctePlans, cteColumns, tables, parentColumns })
+  return planSelect({ select: stmt, ctePlans, cteColumns, tables, parentColumns, outerScope })
 }
 
 /**
@@ -60,11 +61,12 @@ function planStatement({ stmt, ctePlans, cteColumns, tables, parentColumns }) {
  * @param {Map<string, QueryPlan>} [options.ctePlans]
  * @param {Map<string, string[]>} [options.cteColumns]
  * @param {Record<string, AsyncDataSource>} [options.tables]
+ * @param {IdentifierNode[]} [options.parentColumns] - columns needed by the parent query
  * @returns {QueryPlan}
  */
-function planSetOperation({ compound, ctePlans, cteColumns, tables }) {
-  const left = planStatement({ stmt: compound.left, ctePlans, cteColumns, tables })
-  const right = planStatement({ stmt: compound.right, ctePlans, cteColumns, tables })
+function planSetOperation({ compound, ctePlans, cteColumns, tables, parentColumns }) {
+  const left = planStatement({ stmt: compound.left, ctePlans, cteColumns, tables, parentColumns })
+  const right = planStatement({ stmt: compound.right, ctePlans, cteColumns, tables, parentColumns })
   const leftColumns = inferStatementColumns({ stmt: compound.left, cteColumns, tables })
   const rightColumns = inferStatementColumns({ stmt: compound.right, cteColumns, tables })
 
@@ -100,9 +102,10 @@ function planSetOperation({ compound, ctePlans, cteColumns, tables }) {
  * @param {Map<string, string[]>} [options.cteColumns]
  * @param {Record<string, AsyncDataSource>} [options.tables]
  * @param {IdentifierNode[]} [options.parentColumns] - columns needed by the parent query (for subquery pushdown)
+ * @param {string[]} [options.outerScope] - aliases from an outer query (for correlated subqueries)
  * @returns {QueryPlan}
  */
-function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
+function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outerScope }) {
   // Check for aggregation
   const hasAggregate = select.columns.some(col =>
     col.type === 'derived' && findAggregate(col.expr)
@@ -114,7 +117,8 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   const sourceAlias = fromAlias(select.from)
 
   // Resolve aliases (and validate qualified references)
-  const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table)].map(a => [a, true]))
+  // Include outerScope aliases so correlated references pass validation
+  const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table), ...outerScope ?? []].map(a => [a, true]))
   /** @type {Map<string, ExprNode>} */
   const aliases = new Map()
   const columns = select.columns.map(col => {
@@ -153,6 +157,11 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   const hints = {}
   const perTableColumns = extractColumns({ select, parentColumns })
   hints.columns = perTableColumns.get(sourceAlias)
+  // Empty columns array means no columns were referenced, but a FROM subquery
+  // still needs its own columns (e.g. for DISTINCT). Treat empty as unrestricted.
+  if (hints.columns?.length === 0 && select.from.type === 'subquery') {
+    hints.columns = undefined
+  }
   if (!select.joins.length) {
     hints.where = select.where
     if (!needsBuffering && !select.distinct) {
@@ -163,7 +172,7 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
 
   // Start with the data source (FROM clause)
   /** @type {QueryPlan} */
-  let plan = planFrom({ select, ctePlans, cteColumns, hints, tables })
+  let plan = planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope })
 
   // Add JOINs
   if (select.joins.length) {
@@ -255,9 +264,10 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
  * @param {Map<string, string[]>} [options.cteColumns]
  * @param {ScanOptions} options.hints
  * @param {Record<string, AsyncDataSource>} [options.tables]
+ * @param {string[]} [options.outerScope]
  * @returns {QueryPlan}
  */
-function planFrom({ select, ctePlans, cteColumns, hints, tables }) {
+function planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope }) {
   if (select.from.type === 'table') {
     const ctePlan = ctePlans?.get(select.from.table.toLowerCase())
     if (ctePlan) {
@@ -271,6 +281,7 @@ function planFrom({ select, ctePlans, cteColumns, hints, tables }) {
       ctePlans,
       cteColumns,
       tables,
+      outerScope,
       parentColumns: hints.columns?.map(name => ({ type: 'identifier', name, positionStart: 0, positionEnd: 0 })),
     })
     // Validate that requested columns exist in subquery output

package/src/types.d.ts

@@ -40,6 +40,12 @@ export interface ExecuteContext {
   tables: Record<string, AsyncDataSource>
   functions?: Record<string, UserDefinedFunction>
   signal?: AbortSignal
+  // current query's FROM + JOIN aliases (e.g. ['a', 'b'])
+  scope?: string[]
+  // the enclosing query's current row, for resolving correlated references
+  outerRow?: AsyncRow
+  // aliases from the enclosing query that are valid correlated references
+  outerAliases?: Set<string>
 }
 
 // AsyncRow represents a row with async cell values

package/src/validation/parseErrors.js

@@ -1,5 +1,12 @@
 import { FUNCTION_SIGNATURES } from './functions.js'
 
+/** Well-known window functions that are not supported */
+const WINDOW_FUNCTIONS = new Set([
+  'ROW_NUMBER', 'RANK', 'DENSE_RANK', 'NTILE',
+  'LAG', 'LEAD', 'FIRST_VALUE', 'LAST_VALUE', 'NTH_VALUE',
+  'CUME_DIST', 'PERCENT_RANK',
+])
+
 /**
  * Structured parse error with position range.
  */
@@ -103,10 +110,16 @@ export class UnknownFunctionError extends ParseError {
    * @param {number} options.positionEnd
    */
   constructor({ funcName, positionStart, positionEnd }) {
-    const suggestions = suggestFunctions(funcName)
-    let message = `Unknown function "${funcName}" at position ${positionStart}.`
-    if (suggestions.length) {
-      message += ` Did you mean ${suggestions.join(', ')}?`
+    const upper = funcName.toUpperCase()
+    let message
+    if (WINDOW_FUNCTIONS.has(upper)) {
+      message = `Window function "${funcName}" is not supported at position ${positionStart}`
+    } else {
+      const suggestions = suggestFunctions(funcName)
+      message = `Unknown function "${funcName}" at position ${positionStart}.`
+      if (suggestions.length) {
+        message += ` Did you mean ${suggestions.join(', ')}?`
+      }
     }
     super({ message, positionStart, positionEnd })
   }