squirreling 0.11.0 → 0.11.2

package/package.json

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

package/src/execute/aggregates.js

@@ -26,9 +26,13 @@ function projectAggregateColumns(selectColumns, group, context) {
     if (col.type === 'star') {
       const firstRow = group[0]
       if (firstRow) {
+        const prefix = col.table ? `${col.table}.` : undefined
         for (const key of firstRow.columns) {
-          columns.push(key)
-          cells[key] = firstRow.cells[key]
+          if (prefix && !key.startsWith(prefix)) continue
+          const dotIndex = key.indexOf('.')
+          const outputKey = dotIndex >= 0 ? key.substring(dotIndex + 1) : key
+          columns.push(outputKey)
+          cells[outputKey] = firstRow.cells[key]
         }
       }
     } else {
@@ -161,16 +165,17 @@ export async function* executeScalarAggregate(plan, context) {
  * @param {ExecuteContext} context
  * @returns {AsyncGenerator<AsyncRow> | undefined}
  */
-function tryColumnScanAggregate(plan, context) {
+function tryColumnScanAggregate(plan, { tables, signal }) {
   // No HAVING support in fast path
   if (plan.having) return
   // Child must be a direct table scan
   if (plan.child.type !== 'Scan') return
   const scanNode = plan.child
-  // No WHERE in scan (scanColumn doesn't support filtering)
-  if (scanNode.hints.where) return
+  const { limit, offset, where } = scanNode.hints
+  // scanColumn doesn't support filtering
+  if (where) return
 
-  const table = context.tables[scanNode.table]
+  const table = tables[scanNode.table]
   if (!table?.scanColumn) return
 
   // All columns must be simple aggregates on plain identifiers
@@ -190,9 +195,8 @@ function tryColumnScanAggregate(plan, context) {
     const cells = {}
 
     for (const spec of specs) {
-      const value = await scanColumnAggregate(table, spec, context.signal)
       columns.push(spec.alias)
-      cells[spec.alias] = () => Promise.resolve(value)
+      cells[spec.alias] = () => scanColumnAggregate({ table, spec, limit, offset, signal })
     }
 
     yield { columns, cells }
@@ -226,13 +230,16 @@ function extractColumnAggSpec({ expr, alias }) {
 /**
  * Scans a single column and computes an aggregate value.
  *
- * @param {AsyncDataSource} table
- * @param {ColumnAggSpec} spec
- * @param {AbortSignal} [signal]
+ * @param {Object} options
+ * @param {AsyncDataSource} options.table
+ * @param {ColumnAggSpec} options.spec
+ * @param {number} [options.limit]
+ * @param {number} [options.offset]
+ * @param {AbortSignal} [options.signal]
  * @returns {Promise<SqlPrimitive>}
  */
-async function scanColumnAggregate(table, spec, signal) {
-  const values = table.scanColumn({ column: spec.column, signal })
+async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
+  const values = table.scanColumn({ column: spec.column, limit, offset, signal })
 
   if (spec.funcName === 'COUNT' && spec.distinct) {
     const seen = new Set()

package/src/execute/execute.js

@@ -3,7 +3,7 @@ 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 { TableNotFoundError } from '../validation/planErrors.js'
+import { validateScan, validateTable } from '../validation/tables.js'
 import { executeHashAggregate, executeScalarAggregate } from './aggregates.js'
 import { executeHashJoin, executeNestedLoopJoin, executePositionalJoin } from './join.js'
 import { executeSort } from './sort.js'
@@ -95,16 +95,8 @@ export async function* executePlan({ plan, context }) {
  */
 async function* executeScan(plan, context) {
   const { tables, signal } = context
-  // check table
-  const table = tables[plan.table]
-  if (!table) {
-    throw new TableNotFoundError({ table: plan.table, tables })
-  }
-  // check columns
-  const missingColumn = plan.hints.columns?.find(col => !table.columns.includes(col))
-  if (missingColumn) {
-    throw new Error(`Column "${missingColumn}" not found. Available columns: ${table.columns.join(', ') || '[]'}`)
-  }
+  const table = validateTable({ ...plan, tables })
+  validateScan({ ...plan, tables })
 
   // do the scan
   const { rows, appliedWhere, appliedLimitOffset } = table.scan({ ...plan.hints, signal })
@@ -138,10 +130,7 @@ async function* executeScan(plan, context) {
  * @yields {AsyncRow}
  */
 async function* executeCount(plan, { tables, signal }) {
-  const table = tables[plan.table]
-  if (!table) {
-    throw new TableNotFoundError({ table: plan.table, tables })
-  }
+  const table = validateTable({ ...plan, tables })
 
   // Use source numRows if available
   let count = table.numRows
@@ -273,9 +262,14 @@ async function* executeProject(plan, context) {
 
     for (const col of plan.columns) {
       if (col.type === 'star') {
+        const prefix = col.table ? `${col.table}.` : undefined
         for (const key of row.columns) {
-          columns.push(key)
-          cells[key] = row.cells[key]
+          if (prefix && !key.startsWith(prefix)) continue
+          // Strip table prefix for output column names
+          const dotIndex = key.indexOf('.')
+          const outputKey = dotIndex >= 0 ? key.substring(dotIndex + 1) : key
+          columns.push(outputKey)
+          cells[outputKey] = row.cells[key]
         }
       } else {
         const alias = col.alias ?? derivedAlias(col.expr)

package/src/execute/join.js

@@ -230,27 +230,16 @@ function mergeRows(leftRow, rightRow, leftTable, rightTable) {
 
   // Add left table columns with prefix
   for (const [key, cell] of Object.entries(leftRow.cells)) {
-    // Skip already-prefixed keys (from previous joins)
-    if (!key.includes('.')) {
-      const alias = `${leftTable}.${key}`
-      columns.push(alias)
-      cells[alias] = cell
-    }
-    // Also keep unqualified name for convenience
-    columns.push(key)
-    cells[key] = cell
+    const alias = key.includes('.') ? key : `${leftTable}.${key}`
+    columns.push(alias)
+    cells[alias] = cell
   }
 
   // Add right table columns with prefix
   for (const [key, cell] of Object.entries(rightRow.cells)) {
-    if (!key.includes('.')) {
-      const alias = `${rightTable}.${key}`
-      columns.push(alias)
-      cells[alias] = cell
-    }
-    // Unqualified name (overwrites if same name exists in left table)
-    columns.push(key)
-    cells[key] = cell
+    const alias = key.includes('.') ? key : `${rightTable}.${key}`
+    columns.push(alias)
+    cells[alias] = cell
   }
 
   return { columns, cells }
@@ -264,5 +253,5 @@ function mergeRows(leftRow, rightRow, leftTable, rightTable) {
  * @returns {string[]}
  */
 function prefixColumns(cols, table) {
-  return cols.flatMap(col => col.includes('.') ? [col] : [`${table}.${col}`, col])
+  return cols.map(col => col.includes('.') ? col : `${table}.${col}`)
 }

package/src/expression/evaluate.js

@@ -37,16 +37,24 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     if (node.name in row.cells) {
       return row.cells[node.name]()
     }
-    // For qualified names like 'users.id', also try just the column part
-    if (node.name.includes('.')) {
-      const colName = node.name.split('.').pop()
-      if (colName && colName in row.cells) {
+    const dotIndex = node.name.indexOf('.')
+    if (dotIndex >= 0) {
+      // For qualified names like 'users.id', try just the column part
+      const colName = node.name.substring(dotIndex + 1)
+      if (colName in row.cells) {
         return row.cells[colName]()
       }
+    } else {
+      // For unqualified names, search for a matching prefixed column (e.g. 'id' to 'a.id')
+      const suffix = '.' + node.name
+      const match = row.columns.find(col => col.endsWith(suffix))
+      if (match) {
+        return row.cells[match]()
+      }
     }
     // Unknown identifier
     throw new ColumnNotFoundError({
-      columnName: node.name,
+      missingColumn: node.name,
       availableColumns: row.columns,
       rowIndex,
       ...node,

package/src/plan/columns.js

@@ -71,7 +71,8 @@ export function extractColumns({ select, parentColumns }) {
         const outputName = col.alias ?? derivedAlias(col.expr)
         if (!parentColumns.includes(outputName)) continue
       }
-      collectColumnsFromExpr(col.expr, identifiers)
+      // Exclude earlier SELECT aliases so they aren't treated as source columns
+      collectColumnsFromExpr(col.expr, identifiers, selectAliases)
       if (col.alias) {
         selectAliases.add(col.alias)
       }
@@ -223,12 +224,12 @@ function inferSelectSourceColumns({ select, cteColumns, tables }) {
   const result = []
   const fromAlias = select.from.alias ?? select.from.table
   for (const col of lookupTableColumns(select.from.table, cteColumns, tables)) {
-    result.push(`${fromAlias}.${col}`, col)
+    result.push(`${fromAlias}.${col}`)
   }
   for (const join of select.joins) {
     const alias = join.alias ?? join.table
     for (const col of lookupTableColumns(join.table, cteColumns, tables)) {
-      result.push(`${alias}.${col}`, col)
+      result.push(`${alias}.${col}`)
     }
   }
   return result

package/src/plan/plan.js

@@ -2,6 +2,7 @@ import { derivedAlias } from '../expression/alias.js'
 import { parseSql } from '../parse/parse.js'
 import { findAggregate } from '../validation/aggregates.js'
 import { ColumnNotFoundError, TableNotFoundError } from '../validation/planErrors.js'
+import { validateScan, validateTableRefs } from '../validation/tables.js'
 import { extractColumns, fromAlias, inferStatementColumns } from './columns.js'
 
 /**
@@ -112,6 +113,16 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   // Source alias for FROM clause
   const sourceAlias = fromAlias(select.from)
 
+  // Validate qualified references
+  const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table)].map(a => [a, true]))
+  for (const col of select.columns) {
+    if (col.type === 'derived') {
+      validateTableRefs(col.expr, scopeTables)
+    } else if (col.table && !(col.table in scopeTables)) {
+      throw new TableNotFoundError({ table: col.table, tables: scopeTables })
+    }
+  }
+
   // Determine scan hints for direct table scans (WHERE and LIMIT/OFFSET are
   // included so they are only applied to fresh scans, not CTE/subquery plans)
   /** @type {ScanOptions} */
@@ -191,13 +202,23 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // However, for streaming distinct we need to project first
     // So the order is: Sort -> Project -> Distinct -> Limit
 
-    // Fast path for SELECT *
-    const isPassthrough = select.columns.length === 1 && select.columns[0].type === 'star'
+    // Fast path for SELECT * without joins
+    const isPassthrough = select.columns.length === 1 && select.columns[0].type === 'star' && !select.joins.length
     if (!isPassthrough) {
+      // Resolve earlier SELECT aliases in later column expressions
+      /** @type {Map<string, ExprNode>} */
+      const colAliases = new Map()
+      let projectColumns = select.columns.map(col => {
+        if (col.type !== 'derived') return col
+        const expr = resolveAliases(col.expr, colAliases)
+        if (col.alias) {
+          colAliases.set(col.alias, expr)
+        }
+        return { ...col, expr }
+      })
       // When parent only needs specific columns, drop unneeded projections
-      let projectColumns = select.columns
       if (parentColumns) {
-        projectColumns = select.columns.filter(col =>
+        projectColumns = projectColumns.filter(col =>
           col.type === 'star' || parentColumns.includes(col.alias ?? derivedAlias(col.expr))
         )
       }
@@ -240,11 +261,7 @@ function planFrom({ select, ctePlans, cteColumns, hints, tables }) {
     if (hints.columns && availableColumns.length) {
       const missingColumn = hints.columns.find(col => !availableColumns.includes(col))
       if (missingColumn) {
-        throw new ColumnNotFoundError({
-          columnName: missingColumn,
-          availableColumns,
-          ...select.from,
-        })
+        throw new ColumnNotFoundError({ missingColumn, availableColumns, ...select.from })
       }
     }
     return subPlan
@@ -321,50 +338,44 @@ function planJoin({ left, joins, leftTable, ctePlans, cteColumns, perTableColumn
  * Recursively replaces identifier nodes that match SELECT aliases
  * with their aliased expressions.
  *
- * @param {ExprNode} node
+ * @param {ExprNode | undefined} node
  * @param {Map<string, ExprNode>} aliases
  * @returns {ExprNode}
  */
 function resolveAliases(node, aliases) {
+  if (!node || !aliases.size) return node
   if (node.type === 'identifier') {
-    const resolved = aliases.get(node.name)
-    if (resolved) return resolved
-    return node
+    return aliases.get(node.name) ?? node
   }
   if (node.type === 'unary') {
-    const argument = resolveAliases(node.argument, aliases)
-    return argument === node.argument ? node : { ...node, argument }
+    return { ...node, argument: resolveAliases(node.argument, aliases) }
   }
   if (node.type === 'binary') {
     const left = resolveAliases(node.left, aliases)
     const right = resolveAliases(node.right, aliases)
-    return left === node.left && right === node.right ? node : { ...node, left, right }
+    return { ...node, left, right }
   }
   if (node.type === 'function') {
     const args = node.args.map(arg => resolveAliases(arg, aliases))
-    const changed = args.some((arg, i) => arg !== node.args[i])
-    return changed ? { ...node, args } : node
+    return { ...node, args }
   }
   if (node.type === 'cast') {
-    const expr = resolveAliases(node.expr, aliases)
-    return expr === node.expr ? node : { ...node, expr }
+    return { ...node, expr: resolveAliases(node.expr, aliases) }
   }
   if (node.type === 'in valuelist') {
     const expr = resolveAliases(node.expr, aliases)
     const values = node.values.map(v => resolveAliases(v, aliases))
-    const changed = expr !== node.expr || values.some((v, i) => v !== node.values[i])
-    return changed ? { ...node, expr, values } : node
+    return { ...node, expr, values }
   }
   if (node.type === 'case') {
-    const caseExpr = node.caseExpr ? resolveAliases(node.caseExpr, aliases) : node.caseExpr
+    const caseExpr = resolveAliases(node.caseExpr, aliases)
     const whenClauses = node.whenClauses.map(w => {
       const condition = resolveAliases(w.condition, aliases)
       const result = resolveAliases(w.result, aliases)
-      return condition === w.condition && result === w.result ? w : { ...w, condition, result }
+      return { ...w, condition, result }
     })
-    const elseResult = node.elseResult ? resolveAliases(node.elseResult, aliases) : node.elseResult
-    const changed = caseExpr !== node.caseExpr || elseResult !== node.elseResult || whenClauses.some((w, i) => w !== node.whenClauses[i])
-    return changed ? { ...node, caseExpr, whenClauses, elseResult } : node
+    const elseResult = resolveAliases(node.elseResult, aliases)
+    return { ...node, caseExpr, whenClauses, elseResult }
   }
   // literal, interval, subquery, in, exists: no identifiers to resolve
   return node
@@ -396,33 +407,6 @@ function extractSimpleJoinKeys({ condition, leftTable, rightTable }) {
   return { leftKey: left, rightKey: right }
 }
 
-/**
- * Validates that a table exists and requested columns are available.
- *
- * @param {object} options
- * @param {string} options.table
- * @param {ScanOptions} options.hints
- * @param {Record<string, AsyncDataSource>} [options.tables]
- * @param {number} options.positionStart
- * @param {number} options.positionEnd
- */
-function validateScan({ table, hints, tables, positionStart, positionEnd }) {
-  if (!tables) return
-  const resolved = tables[table]
-  if (!resolved) {
-    throw new TableNotFoundError({ table, tables, positionStart, positionEnd })
-  }
-  const missingColumn = hints.columns?.find(col => !resolved.columns.includes(col))
-  if (missingColumn) {
-    throw new ColumnNotFoundError({
-      columnName: missingColumn,
-      availableColumns: resolved.columns,
-      positionStart,
-      positionEnd,
-    })
-  }
-}
-
 /**
  * Checks if every SELECT column is a plain COUNT(*).
  *

package/src/types.d.ts

@@ -84,6 +84,8 @@ export interface ScanOptions {
  */
 export interface ScanColumnOptions {
   column: string
+  limit?: number
+  offset?: number
   signal?: AbortSignal
 }
 

package/src/validation/planErrors.js

@@ -30,18 +30,18 @@ export class TableNotFoundError extends ExecutionError {
 export class ColumnNotFoundError extends ExecutionError {
   /**
    * @param {Object} options
-   * @param {string} options.columnName - The missing column name
+   * @param {string} options.missingColumn - The missing column name
    * @param {string[]} options.availableColumns - List of available column names
    * @param {number} options.positionStart
    * @param {number} options.positionEnd
    * @param {number} [options.rowIndex] - 1-based row number where error occurred
    */
-  constructor({ columnName, availableColumns, positionStart, positionEnd, rowIndex }) {
+  constructor({ missingColumn, availableColumns, positionStart, positionEnd, rowIndex }) {
     const available = availableColumns.length > 0
       ? `. Available columns: ${availableColumns.join(', ')}`
       : ''
     super({
-      message: `Column "${columnName}" not found${available}`,
+      message: `Column "${missingColumn}" not found${available}`,
       positionStart,
       positionEnd,
       rowIndex,

package/src/validation/tables.js

@@ -0,0 +1,89 @@
+import { ColumnNotFoundError, TableNotFoundError } from './planErrors.js'
+
+/**
+ * @import { AsyncDataSource, ExprNode, ScanOptions } from '../types.js'
+ */
+
+/**
+ * @param {Object} options
+ * @param {string} options.table - The name of the table to validate
+ * @param {Record<string, AsyncDataSource>} options.tables - Object mapping table names to data sources
+ * @param {number} [options.positionStart] - Optional start position for error reporting
+ * @param {number} [options.positionEnd] - Optional end position for error reporting
+ * @returns {AsyncDataSource}
+ */
+export function validateTable({ table, tables, positionStart, positionEnd } ) {
+  const resolved = tables[table]
+  if (!resolved) {
+    throw new TableNotFoundError({ table, tables, positionStart, positionEnd })
+  }
+  return resolved
+}
+
+/**
+ * Validates that a table exists and requested columns are available.
+ *
+ * @param {object} options
+ * @param {string} [options.table]
+ * @param {ScanOptions} options.hints
+ * @param {Record<string, AsyncDataSource>} [options.tables]
+ * @param {number} [options.positionStart]
+ * @param {number} [options.positionEnd]
+ */
+export function validateScan({ table, hints, tables, positionStart, positionEnd }) {
+  if (!tables) return
+  const resolved = validateTable({ table, tables, positionStart, positionEnd })
+  const missingColumn = hints.columns?.find(col => !resolved.columns.includes(col))
+  if (missingColumn) {
+    throw new ColumnNotFoundError({
+      missingColumn,
+      availableColumns: resolved.columns,
+      positionStart,
+      positionEnd,
+    })
+  }
+}
+
+/**
+ * Validates that qualified identifiers reference known table aliases.
+ *
+ * @param {ExprNode} expr
+ * @param {Record<string, any>} tables
+ */
+export function validateTableRefs(expr, tables) {
+  if (!expr) return
+  if (expr.type === 'identifier') {
+    const dotIndex = expr.name.indexOf('.')
+    if (dotIndex >= 0) {
+      const table = expr.name.substring(0, dotIndex)
+      if (!(table in tables)) {
+        throw new TableNotFoundError({ table, tables, positionStart: expr.positionStart, positionEnd: expr.positionStart + dotIndex })
+      }
+    }
+    return
+  }
+  if (expr.type === 'binary') {
+    validateTableRefs(expr.left, tables)
+    validateTableRefs(expr.right, tables)
+  } else if (expr.type === 'unary') {
+    validateTableRefs(expr.argument, tables)
+  } else if (expr.type === 'function') {
+    for (const arg of expr.args) {
+      validateTableRefs(arg, tables)
+    }
+  } else if (expr.type === 'cast') {
+    validateTableRefs(expr.expr, tables)
+  } else if (expr.type === 'in valuelist') {
+    validateTableRefs(expr.expr, tables)
+    for (const val of expr.values) {
+      validateTableRefs(val, tables)
+    }
+  } else if (expr.type === 'case') {
+    validateTableRefs(expr.caseExpr, tables)
+    for (const w of expr.whenClauses) {
+      validateTableRefs(w.condition, tables)
+      validateTableRefs(w.result, tables)
+    }
+    validateTableRefs(expr.elseResult, tables)
+  }
+}