squirreling 0.12.13 → 0.12.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.13",
+  "version": "0.12.14",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -41,7 +41,7 @@
   "devDependencies": {
     "@types/node": "25.6.0",
     "@vitest/coverage-v8": "4.1.5",
-    "eslint": "9.39.2",
+    "eslint": "9.39.4",
     "eslint-plugin-jsdoc": "62.9.0",
     "typescript": "6.0.3",
     "vitest": "4.1.5"

package/src/expression/evaluate.js

@@ -62,6 +62,14 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       if (context.outerRow && context.outerAliases?.has(node.prefix) && node.name in context.outerRow.cells) {
         return context.outerRow.cells[node.name]()
       }
+      // Standalone `FROM UNNEST(...) AS alias` row has a single bare column;
+      // `alias.field` should struct-access that column's element.
+      if (context.scope?.includes(node.prefix) && row.columns.length === 1) {
+        const value = await row.cells[row.columns[0]]()
+        if (isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, node.name)) {
+          return value[node.name]
+        }
+      }
       // Fall back to just the column part
       if (node.name in row.cells) {
         return row.cells[node.name]()
@@ -650,13 +658,15 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   }
 
   // EXISTS and NOT EXISTS with subqueries
-  if (node.type === 'exists') {
-    const results = await executeStatement({ query: node.subquery, context }).rows().next()
-    return results.done === false
-  }
-  if (node.type === 'not exists') {
-    const results = await executeStatement({ query: node.subquery, context }).rows().next()
-    return results.done === true
+  if (node.type === 'exists' || node.type === 'not exists') {
+    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 results = await gen.next()
+    gen.return(undefined)
+    return node.type === 'exists' ? results.done === false : results.done === true
   }
 
   // CASE expressions

package/src/plan/columns.js

@@ -268,6 +268,11 @@ function collectColumnsFromExpr(expr, columns, aliases) {
       for (const id of inner) {
         if (id.prefix) columns.push(id)
       }
+      // FROM-function args (e.g. UNNEST in the subquery's FROM) are evaluated
+      // against the outer scope — the table function is itself the FROM, so
+      // any identifier inside its args must be correlated. Push them even if
+      // unprefixed so the outer scan reads the columns they reference.
+      collectFromFunctionArgs(sub, columns)
     }
   }
   // No columns: count(*), literal, interval
@@ -309,6 +314,33 @@ function collectColumnsFromStatement(stmt, columns) {
   for (const item of stmt.orderBy) collectColumnsFromExpr(item.expr, columns)
 }
 
+/**
+ * Walks a subquery statement and collects identifiers from FROM-function args
+ * (e.g. UNNEST(col) in FROM). These identifiers are necessarily correlated
+ * outer references because the table function is the only source.
+ *
+ * @param {Statement} stmt
+ * @param {IdentifierNode[]} columns
+ */
+function collectFromFunctionArgs(stmt, columns) {
+  if (stmt.type === 'compound') {
+    collectFromFunctionArgs(stmt.left, columns)
+    collectFromFunctionArgs(stmt.right, columns)
+    return
+  }
+  if (stmt.type === 'with') {
+    collectFromFunctionArgs(stmt.query, columns)
+    return
+  }
+  if (stmt.from?.type === 'function') {
+    for (const arg of stmt.from.args) {
+      collectColumnsFromExpr(arg, columns)
+    }
+  } else if (stmt.from?.type === 'subquery') {
+    collectFromFunctionArgs(stmt.from.query, columns)
+  }
+}
+
 /**
  * Infers output columns for set-operation validation.
  *

package/src/plan/plan.js

@@ -343,7 +343,7 @@ function planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope }) {
     return { type: 'Scan', table: select.from.table, hints }
   } else if (select.from.type === 'function') {
     for (const arg of select.from.args) {
-      validateNoIdentifiers(arg, select.from.funcName)
+      validateNoIdentifiers(arg, select.from.funcName, outerScope)
     }
     return planTableFunction(select.from)
   } else {

package/src/validation/tables.js

@@ -48,13 +48,22 @@ export function validateScan({ table, hints, tables, positionStart, positionEnd
 /**
  * Throws if the expression references any column identifier. Used for
  * expressions that have no row scope (e.g. table function arguments in FROM).
+ * When `outerScope` is provided, identifiers that resolve to an outer query's
+ * alias (correlated reference) are allowed — they will be evaluated against
+ * the outer row at runtime.
  *
  * @param {ExprNode} expr
  * @param {string} context - context for the error message (e.g. function name)
+ * @param {string[]} [outerScope] - aliases of outer queries
  */
-export function validateNoIdentifiers(expr, context) {
+export function validateNoIdentifiers(expr, context, outerScope) {
   if (!expr) return
   if (expr.type === 'identifier') {
+    if (outerScope?.length) {
+      // Correlated reference: prefix matches an outer alias, or unqualified
+      // (resolved against the outer row at runtime).
+      if (!expr.prefix || outerScope.includes(expr.prefix)) return
+    }
     const name = expr.prefix ? `${expr.prefix}.${expr.name}` : expr.name
     throw new ExecutionError({
       message: `${context} argument cannot reference column "${name}" — use JOIN ${context}(...) to reference columns from another table`,
@@ -63,31 +72,31 @@ export function validateNoIdentifiers(expr, context) {
     })
   }
   if (expr.type === 'binary') {
-    validateNoIdentifiers(expr.left, context)
-    validateNoIdentifiers(expr.right, context)
+    validateNoIdentifiers(expr.left, context, outerScope)
+    validateNoIdentifiers(expr.right, context, outerScope)
   } else if (expr.type === 'unary') {
-    validateNoIdentifiers(expr.argument, context)
+    validateNoIdentifiers(expr.argument, context, outerScope)
   } else if (expr.type === 'function') {
     for (const arg of expr.args) {
-      validateNoIdentifiers(arg, context)
+      validateNoIdentifiers(arg, context, outerScope)
     }
   } else if (expr.type === 'cast') {
-    validateNoIdentifiers(expr.expr, context)
+    validateNoIdentifiers(expr.expr, context, outerScope)
   } else if (expr.type === 'in valuelist') {
-    validateNoIdentifiers(expr.expr, context)
+    validateNoIdentifiers(expr.expr, context, outerScope)
     for (const val of expr.values) {
-      validateNoIdentifiers(val, context)
+      validateNoIdentifiers(val, context, outerScope)
     }
   } else if (expr.type === 'in') {
     // LHS is in our scope; subquery is self-contained and planned separately.
-    validateNoIdentifiers(expr.expr, context)
+    validateNoIdentifiers(expr.expr, context, outerScope)
   } else if (expr.type === 'case') {
-    validateNoIdentifiers(expr.caseExpr, context)
+    validateNoIdentifiers(expr.caseExpr, context, outerScope)
     for (const w of expr.whenClauses) {
-      validateNoIdentifiers(w.condition, context)
-      validateNoIdentifiers(w.result, context)
+      validateNoIdentifiers(w.condition, context, outerScope)
+      validateNoIdentifiers(w.result, context, outerScope)
     }
-    validateNoIdentifiers(expr.elseResult, context)
+    validateNoIdentifiers(expr.elseResult, context, outerScope)
   }
   // subquery / exists / not exists are self-contained — their identifiers
   // resolve to their own FROM and are validated when the subquery is planned.