squirreling 0.11.1 → 0.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "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 {
@@ -240,7 +244,7 @@ async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
   if (spec.funcName === 'COUNT' && spec.distinct) {
     const seen = new Set()
     for await (const chunk of values) {
-      if (signal?.aborted) return null
+      if (signal?.aborted) return
       for (let i = 0; i < chunk.length; i++) {
         const v = chunk[i]
         if (v == null) continue
@@ -253,7 +257,7 @@ async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
   if (spec.funcName === 'COUNT') {
     let count = 0
     for await (const chunk of values) {
-      if (signal?.aborted) return null
+      if (signal?.aborted) return
       for (let i = 0; i < chunk.length; i++) {
         if (chunk[i] != null) count++
       }
@@ -270,7 +274,7 @@ async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
   let max = null
 
   for await (const chunk of values) {
-    if (signal?.aborted) return null
+    if (signal?.aborted) return
     for (let i = 0; i < chunk.length; i++) {
       const v = chunk[i]
       if (v == null) continue

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,15 +95,30 @@ 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 })
+
+  // Fast path: single column scan without WHERE
+  if (table.scanColumn && plan.hints.columns?.length === 1 && !plan.hints.where) {
+    const column = plan.hints.columns[0]
+    const chunks = table.scanColumn({
+      column,
+      limit: plan.hints.limit,
+      offset: plan.hints.offset,
+      signal,
+    })
+    const columns = [column]
+    for await (const chunk of chunks) {
+      if (signal?.aborted) return
+      for (let i = 0; i < chunk.length; i++) {
+        const value = chunk[i]
+        yield {
+          columns,
+          cells: { [column]: () => Promise.resolve(value) },
+        }
+      }
+    }
+    return
   }
 
   // do the scan
@@ -138,10 +153,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 +285,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/parse/parse.js

@@ -169,19 +169,25 @@ function parseIntersectOperations(state) {
  */
 function parseSelect(state) {
   const { positionStart } = current(state)
-  expect(state, 'keyword', 'SELECT')
-
-  const distinct = match(state, 'keyword', 'DISTINCT')
-
-  const columns = parseSelectList(state)
+  /** @type {SelectColumn[]} */
+  let columns
+  let distinct = false
 
-  expect(state, 'keyword', 'FROM')
+  // Support duckdb-style shorthand "FROM table"
+  if (match(state, 'keyword', 'FROM')) {
+    columns = [{ type: 'star' }]
+  } else {
+    expect(state, 'keyword', 'SELECT')
+    distinct = match(state, 'keyword', 'DISTINCT')
+    columns = parseSelectList(state)
+    expect(state, 'keyword', 'FROM')
+  }
 
   // Check if it's a subquery or table name
   /** @type {FromTable | FromSubquery} */
   let from
-  const tok = current(state)
-  if (tok.type === 'paren' && tok.value === '(') {
+  const fromTok = current(state)
+  if (fromTok.type === 'paren' && fromTok.value === '(') {
     // Subquery: SELECT * FROM (SELECT ...) AS alias
     expect(state, 'paren', '(')
     const query = parseStatement(state)
@@ -191,7 +197,7 @@ function parseSelect(state) {
       type: 'subquery',
       query,
       alias,
-      positionStart: tok.positionStart,
+      positionStart: fromTok.positionStart,
       positionEnd: state.lastPos,
     }
   } else {
@@ -200,9 +206,9 @@ function parseSelect(state) {
     const alias = parseTableAlias(state)
     from = {
       type: 'table',
-      table: tok.value,
+      table: fromTok.value,
       alias,
-      positionStart: tok.positionStart,
+      positionStart: fromTok.positionStart,
       positionEnd: state.lastPos,
     }
   }

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)
       }
@@ -83,7 +84,7 @@ export function extractColumns({ select, parentColumns }) {
     collectColumnsFromExpr(item.expr, identifiers, selectAliases)
   }
   for (const expr of select.groupBy) {
-    collectColumnsFromExpr(expr, identifiers)
+    collectColumnsFromExpr(expr, identifiers, selectAliases)
   }
   collectColumnsFromExpr(select.having, identifiers, selectAliases)
   for (const join of select.joins) {
@@ -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,26 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   // Source alias for FROM clause
   const sourceAlias = fromAlias(select.from)
 
+  // Validate qualified references and resolve aliases
+  const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table)].map(a => [a, true]))
+  /** @type {Map<string, ExprNode>} */
+  const aliases = new Map()
+  const columns = select.columns.map(col => {
+    if (col.type === 'derived') {
+      validateTableRefs(col.expr, scopeTables)
+      const expr = resolveAliases(col.expr, aliases)
+      if (col.alias) {
+        aliases.set(col.alias, expr)
+      }
+      return { ...col, expr }
+    }
+    // Validate qualified references
+    if (col.table && !(col.table in scopeTables)) {
+      throw new TableNotFoundError({ table: col.table, tables: scopeTables })
+    }
+    return col
+  })
+
   // 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} */
@@ -147,11 +168,15 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // Aggregation path: GROUP BY or scalar aggregate
     // HAVING is integrated into aggregate nodes for access to group context
     if (select.groupBy.length) {
-      plan = { type: 'HashAggregate', groupBy: select.groupBy, columns: select.columns, having: select.having, child: plan }
+      // Resolve SELECT aliases in GROUP BY expressions at plan time
+      const groupBy = aliases.size > 0
+        ? select.groupBy.map(expr => resolveAliases(expr, aliases))
+        : select.groupBy
+      plan = { type: 'HashAggregate', groupBy, columns, having: select.having, child: plan }
     } else if (!select.having && !select.where && plan.type === 'Scan' && isOwnScan && isAllCountStar(select.columns)) {
       plan = { type: 'Count', table: plan.table, columns: select.columns }
     } else {
-      plan = { type: 'ScalarAggregate', columns: select.columns, having: select.having, child: plan }
+      plan = { type: 'ScalarAggregate', columns, having: select.having, child: plan }
     }
 
     // ORDER BY (after aggregation)
@@ -174,13 +199,6 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // ORDER BY (before projection so it can access all columns)
     // Resolve SELECT aliases in ORDER BY expressions at plan time
     if (select.orderBy.length) {
-      /** @type {Map<string, ExprNode>} */
-      const aliases = new Map()
-      for (const col of select.columns) {
-        if (col.type === 'derived' && col.alias) {
-          aliases.set(col.alias, col.expr)
-        }
-      }
       const orderBy = aliases.size > 0
         ? select.orderBy.map(term => ({ ...term, expr: resolveAliases(term.expr, aliases) }))
         : select.orderBy
@@ -191,13 +209,13 @@ 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) {
+      let projectColumns = columns
       // 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 +258,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 +335,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 +404,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

@@ -1,4 +1,4 @@
-import type { ExprNode, SelectStatement, SqlPrimitive, Statement } from './ast.js'
+import type { ExprNode, SqlPrimitive, Statement } from './ast.js'
 
 export * from './ast.js'
 export { ParserState, Token, TokenType } from './parse/types.js'

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)
+  }
+}