squirreling 0.11.3 → 0.11.4

package/package.json

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

package/src/ast.d.ts

@@ -74,6 +74,7 @@ export interface LiteralNode extends AstBase {
 export interface IdentifierNode extends AstBase {
   type: 'identifier'
   name: string
+  prefix?: string
 }
 
 export interface UnaryNode extends AstBase {

package/src/execute/aggregates.js

@@ -30,7 +30,7 @@ function projectAggregateColumns(selectColumns, group, context) {
         for (const key of firstRow.columns) {
           if (prefix && !key.startsWith(prefix)) continue
           const dotIndex = key.indexOf('.')
-          const outputKey = dotIndex >= 0 ? key.substring(dotIndex + 1) : key
+          const outputKey = prefix ? key.substring(prefix.length) : dotIndex >= 0 ? key.substring(dotIndex + 1) : key
           columns.push(outputKey)
           cells[outputKey] = firstRow.cells[key]
         }

package/src/execute/execute.js

@@ -290,7 +290,7 @@ async function* executeProject(plan, context) {
           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
+          const outputKey = prefix ? key.substring(prefix.length) : dotIndex >= 0 ? key.substring(dotIndex + 1) : key
           columns.push(outputKey)
           cells[outputKey] = row.cells[key]
         }

package/src/execute/join.js

@@ -26,18 +26,18 @@ export async function* executeNestedLoopJoin(plan, context) {
     rightRows.push(row)
   }
 
-  const rightPrefixedCols = rightRows.length ? prefixColumns(rightRows[0].columns, rightTable) : []
+  const rightCols = rightRows.length ? rightRows[0].columns : []
 
   /** @type {string[] | undefined} */
-  let leftPrefixedCols = undefined
+  let leftCols = undefined
   /** @type {Set<AsyncRow> | undefined} */
   const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : undefined
 
   for await (const leftRow of executePlan({ plan: plan.left, context })) {
     if (context.signal?.aborted) break
 
-    if (!leftPrefixedCols) {
-      leftPrefixedCols = prefixColumns(leftRow.columns, leftTable)
+    if (!leftCols) {
+      leftCols = leftRow.columns
     }
 
     let hasMatch = false
@@ -58,7 +58,7 @@ export async function* executeNestedLoopJoin(plan, context) {
     }
 
     if (!hasMatch && (plan.joinType === 'LEFT' || plan.joinType === 'FULL')) {
-      const nullRight = createNullRow(rightPrefixedCols)
+      const nullRight = createNullRow(rightCols)
       yield mergeRows(leftRow, nullRight, leftTable, rightTable)
     }
   }
@@ -67,7 +67,7 @@ export async function* executeNestedLoopJoin(plan, context) {
   if (matchedRightRows) {
     for (const rightRow of rightRows) {
       if (!matchedRightRows.has(rightRow)) {
-        const nullLeft = createNullRow(leftPrefixedCols ?? [])
+        const nullLeft = createNullRow(leftCols ?? [])
         yield mergeRows(nullLeft, rightRow, leftTable, rightTable)
       }
     }
@@ -104,13 +104,11 @@ export async function* executePositionalJoin(plan, context) {
   const maxLen = Math.max(leftRows.length, rightRows.length)
   const leftCols = leftRows[0]?.columns ?? []
   const rightCols = rightRows[0]?.columns ?? []
-  const leftPrefixedCols = prefixColumns(leftCols, leftTable)
-  const rightPrefixedCols = prefixColumns(rightCols, rightTable)
 
   for (let i = 0; i < maxLen; i++) {
     if (signal?.aborted) return
-    const leftRow = leftRows[i] ?? createNullRow(leftPrefixedCols)
-    const rightRow = rightRows[i] ?? createNullRow(rightPrefixedCols)
+    const leftRow = leftRows[i] ?? createNullRow(leftCols)
+    const rightRow = rightRows[i] ?? createNullRow(rightCols)
     yield mergeRows(leftRow, rightRow, leftTable, rightTable)
   }
 }
@@ -154,10 +152,9 @@ export async function* executeHashJoin(plan, context) {
 
   // Get column info for NULL row generation
   const rightCols = rightRows.length ? rightRows[0].columns : []
-  const rightPrefixedCols = prefixColumns(rightCols, rightTable)
 
   /** @type {string[] | undefined} */
-  let leftPrefixedCols
+  let leftCols
   /** @type {Set<AsyncRow> | undefined} */
   const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : undefined
 
@@ -165,8 +162,8 @@ export async function* executeHashJoin(plan, context) {
   for await (const leftRow of executePlan({ plan: plan.left, context })) {
     if (context.signal?.aborted) break
 
-    if (!leftPrefixedCols) {
-      leftPrefixedCols = prefixColumns(leftRow.columns, leftTable)
+    if (!leftCols) {
+      leftCols = leftRow.columns
     }
 
     const keyValue = await evaluateExpr({
@@ -183,7 +180,7 @@ export async function* executeHashJoin(plan, context) {
         yield mergeRows(leftRow, rightRow, leftTable, rightTable)
       }
     } else if (plan.joinType === 'LEFT' || plan.joinType === 'FULL') {
-      const nullRight = createNullRow(rightPrefixedCols)
+      const nullRight = createNullRow(rightCols)
       yield mergeRows(leftRow, nullRight, leftTable, rightTable)
     }
   }
@@ -192,7 +189,7 @@ export async function* executeHashJoin(plan, context) {
   if (matchedRightRows) {
     for (const rightRow of rightRows) {
       if (!matchedRightRows.has(rightRow)) {
-        const nullLeft = createNullRow(leftPrefixedCols ?? [])
+        const nullLeft = createNullRow(leftCols ?? [])
         yield mergeRows(nullLeft, rightRow, leftTable, rightTable)
       }
     }
@@ -244,14 +241,3 @@ function mergeRows(leftRow, rightRow, leftTable, rightTable) {
 
   return { columns, cells }
 }
-
-/**
- * Prefixes column names with table alias, keeping already-prefixed columns as-is
- *
- * @param {string[]} cols
- * @param {string} table
- * @returns {string[]}
- */
-function prefixColumns(cols, table) {
-  return cols.map(col => col.includes('.') ? col : `${table}.${col}`)
-}

package/src/expression/alias.js

@@ -10,11 +10,6 @@
  */
 export function derivedAlias(expr) {
   if (expr.type === 'identifier') {
-    // For qualified names like 'users.name', use just the column part as alias
-    const dotIndex = expr.name.indexOf('.')
-    if (dotIndex >= 0) {
-      return expr.name.substring(dotIndex + 1)
-    }
     return expr.name
   }
   if (expr.type === 'literal') {

package/src/expression/evaluate.js

@@ -33,18 +33,21 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   }
 
   if (node.type === 'identifier') {
-    // Try exact match first (handles both qualified and unqualified names)
-    if (node.name in row.cells) {
-      return row.cells[node.name]()
-    }
-    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]()
+    // Try qualified name first (e.g. 'users.id')
+    if (node.prefix) {
+      const qualified = node.prefix + '.' + node.name
+      if (qualified in row.cells) {
+        return row.cells[qualified]()
+      }
+      // Fall back to just the column part
+      if (node.name in row.cells) {
+        return row.cells[node.name]()
       }
     } else {
+      // Try exact match first
+      if (node.name in row.cells) {
+        return row.cells[node.name]()
+      }
       // 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))
@@ -54,7 +57,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     }
     // Unknown identifier
     throw new ColumnNotFoundError({
-      missingColumn: node.name,
+      missingColumn: node.prefix ? node.prefix + '.' + node.name : node.name,
       availableColumns: row.columns,
       rowIndex,
       ...node,

package/src/parse/primary.js

@@ -112,15 +112,19 @@ export function parsePrimary(state) {
 
     // Table identifier
     let name = consume(state).value
+    /** @type {string | undefined} */
+    let prefix
 
     // table.column
     if (match(state, 'dot')) {
-      name += '.' + expect(state, 'identifier').value
+      prefix = name
+      name = expect(state, 'identifier').value
     }
 
     return {
       type: 'identifier',
       name,
+      prefix,
       positionStart,
       positionEnd: state.lastPos,
     }

package/src/plan/columns.js

@@ -1,7 +1,7 @@
 import { derivedAlias } from '../expression/alias.js'
 
 /**
- * @import { AsyncDataSource, ExprNode, FromSubquery, FromTable, SelectStatement, Statement } from '../types.js'
+ * @import { AsyncDataSource, ExprNode, FromSubquery, FromTable, IdentifierNode, SelectStatement, Statement } from '../types.js'
  */
 
 /**
@@ -18,7 +18,7 @@ export function fromAlias(from) {
  *
  * @param {object} options
  * @param {SelectStatement} options.select
- * @param {string[]} [options.parentColumns] - columns needed by the parent query
+ * @param {IdentifierNode[]} [options.parentColumns] - columns needed by the parent query
  * @returns {Map<string, string[] | undefined>}
  */
 export function extractColumns({ select, parentColumns }) {
@@ -54,7 +54,8 @@ export function extractColumns({ select, parentColumns }) {
   // directly. For non-star queries, parent names may be aliases and are
   // handled below by filtering derived columns and collecting from expressions.
   const hasStar = select.columns.some(col => col.type === 'star' && !col.table)
-  const identifiers = new Set(hasStar ? parentColumns : undefined)
+  /** @type {IdentifierNode[]} */
+  const identifiers = hasStar && parentColumns ? [...parentColumns] : []
 
   // Collect ORDER BY identifiers, excluding SELECT aliases (their underlying
   // columns are already collected from select.columns expressions above)
@@ -69,7 +70,7 @@ export function extractColumns({ select, parentColumns }) {
       // When parentColumns is set, skip columns the parent doesn't need
       if (parentColumns) {
         const outputName = col.alias ?? derivedAlias(col.expr)
-        if (!parentColumns.includes(outputName)) continue
+        if (!parentColumns.some(id => id.name === outputName)) continue
       }
       // Exclude earlier SELECT aliases so they aren't treated as source columns
       collectColumnsFromExpr(col.expr, identifiers, selectAliases)
@@ -92,14 +93,11 @@ export function extractColumns({ select, parentColumns }) {
   }
 
   // Partition identifiers by table prefix
-  for (const name of identifiers) {
-    const dotIndex = name.indexOf('.')
-    if (dotIndex >= 0) {
+  for (const { prefix, name } of identifiers) {
+    if (prefix) {
       // Qualified: add to matching table only
-      const tablePrefix = name.substring(0, dotIndex)
-      const columnName = name.substring(dotIndex + 1)
-      const set = perTable.get(tablePrefix)
-      if (set) set.add(columnName)
+      const set = perTable.get(prefix)
+      if (set) set.add(name)
     } else if (aliases.length > 1) {
       // Unqualified in a JOIN: can't disambiguate, request all columns from all tables
       for (const alias of aliases) {
@@ -122,17 +120,17 @@ export function extractColumns({ select, parentColumns }) {
 }
 
 /**
- * Recursively collects column names (identifiers) from an expression
+ * Recursively collects identifier nodes from an expression
  *
  * @param {ExprNode} expr
- * @param {Set<string>} columns
+ * @param {IdentifierNode[]} columns
  * @param {Set<string>} [aliases] - aliases to exclude from columns
  */
 function collectColumnsFromExpr(expr, columns, aliases) {
   if (!expr) return
   if (expr.type === 'identifier') {
-    if (!aliases?.has(expr.name)) {
-      columns.add(expr.name)
+    if (expr.prefix || !aliases?.has(expr.name)) {
+      columns.push(expr)
     }
   } else if (expr.type === 'binary') {
     collectColumnsFromExpr(expr.left, columns, aliases)

package/src/plan/plan.js

@@ -6,7 +6,7 @@ import { validateScan, validateTableRefs } from '../validation/tables.js'
 import { extractColumns, fromAlias, inferStatementColumns } from './columns.js'
 
 /**
- * @import { AsyncDataSource, ExprNode, DerivedColumn, JoinClause, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement, SetOperationStatement, Statement } from '../types.js'
+ * @import { AsyncDataSource, ExprNode, DerivedColumn, IdentifierNode, JoinClause, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement, SetOperationStatement, Statement } from '../types.js'
  * @import { QueryPlan } from './types.d.ts'
  */
 
@@ -31,7 +31,7 @@ export function planSql({ query, functions, tables }) {
  * @param {Map<string, QueryPlan>} [options.ctePlans]
  * @param {Map<string, string[]>} [options.cteColumns]
  * @param {Record<string, AsyncDataSource>} [options.tables]
- * @param {string[]} [options.parentColumns] - columns needed by the parent query (for subquery pushdown)
+ * @param {IdentifierNode[]} [options.parentColumns] - columns needed by the parent query (for subquery pushdown)
  * @returns {QueryPlan}
  */
 function planStatement({ stmt, ctePlans, cteColumns, tables, parentColumns }) {
@@ -99,7 +99,7 @@ function planSetOperation({ compound, ctePlans, cteColumns, tables }) {
  * @param {Map<string, QueryPlan>} [options.ctePlans]
  * @param {Map<string, string[]>} [options.cteColumns]
  * @param {Record<string, AsyncDataSource>} [options.tables]
- * @param {string[]} [options.parentColumns] - columns needed by the parent query (for subquery pushdown)
+ * @param {IdentifierNode[]} [options.parentColumns] - columns needed by the parent query (for subquery pushdown)
  * @returns {QueryPlan}
  */
 function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
@@ -216,7 +216,7 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
       // When parent only needs specific columns, drop unneeded projections
       if (parentColumns) {
         projectColumns = projectColumns.filter(col =>
-          col.type === 'star' || parentColumns.includes(col.alias ?? derivedAlias(col.expr))
+          col.type === 'star' || parentColumns.some(id => id.name === (col.alias ?? derivedAlias(col.expr)))
         )
       }
       plan = { type: 'Project', columns: projectColumns, child: plan }
@@ -252,7 +252,13 @@ function planFrom({ select, ctePlans, cteColumns, hints, tables }) {
     validateScan({ ...select.from, hints, tables })
     return { type: 'Scan', table: select.from.table, hints }
   } else {
-    const subPlan = planStatement({ stmt: select.from.query, ctePlans, cteColumns, tables, parentColumns: hints.columns })
+    const subPlan = planStatement({
+      stmt: select.from.query,
+      ctePlans,
+      cteColumns,
+      tables,
+      parentColumns: hints.columns?.map(name => ({ type: 'identifier', name, positionStart: 0, positionEnd: 0 })),
+    })
     // Validate that requested columns exist in subquery output
     const availableColumns = inferStatementColumns({ stmt: select.from.query, cteColumns, tables })
     if (hints.columns && availableColumns.length) {
@@ -342,7 +348,7 @@ function planJoin({ left, joins, leftTable, ctePlans, cteColumns, perTableColumn
 function resolveAliases(node, aliases) {
   if (!node || !aliases.size) return node
   if (node.type === 'identifier') {
-    return aliases.get(node.name) ?? node
+    return node.prefix ? node : aliases.get(node.name) ?? node
   }
   if (node.type === 'unary') {
     return { ...node, argument: resolveAliases(node.argument, aliases) }
@@ -394,8 +400,8 @@ function extractSimpleJoinKeys({ condition, leftTable, rightTable }) {
   if (left.type !== 'identifier' || right.type !== 'identifier') return
 
   // Check if keys are in swapped order (right table ref on left side)
-  const leftRefsRight = left.name.startsWith(`${rightTable}.`)
-  const rightRefsLeft = right.name.startsWith(`${leftTable}.`)
+  const leftRefsRight = left.prefix === rightTable
+  const rightRefsLeft = right.prefix === leftTable
 
   if (leftRefsRight && rightRefsLeft) {
     return { leftKey: right, rightKey: left }

package/src/validation/tables.js

@@ -53,11 +53,9 @@ export function validateScan({ table, hints, tables, positionStart, positionEnd
 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 })
+    if (expr.prefix) {
+      if (!(expr.prefix in tables)) {
+        throw new TableNotFoundError({ table: expr.prefix, tables, positionStart: expr.positionStart, positionEnd: expr.positionStart + expr.prefix.length })
       }
     }
     return