squirreling 0.11.2 → 0.11.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.11.2",
+  "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]
         }
@@ -244,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
@@ -257,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++
       }
@@ -274,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

@@ -98,6 +98,29 @@ async function* executeScan(plan, context) {
   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
   const { rows, appliedWhere, appliedLimitOffset } = table.scan({ ...plan.hints, signal })
 
@@ -267,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/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/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)
@@ -84,7 +85,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) {
@@ -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 }) {
@@ -113,15 +113,25 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   // Source alias for FROM clause
   const sourceAlias = fromAlias(select.from)
 
-  // Validate qualified references
+  // Validate qualified references and resolve aliases
   const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table)].map(a => [a, true]))
-  for (const col of select.columns) {
+  /** @type {Map<string, ExprNode>} */
+  const aliases = new Map()
+  const columns = select.columns.map(col => {
     if (col.type === 'derived') {
       validateTableRefs(col.expr, scopeTables)
-    } else if (col.table && !(col.table in 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)
@@ -158,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)
@@ -185,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
@@ -205,21 +212,11 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // 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 }
-      })
+      let projectColumns = columns
       // 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 }
@@ -255,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) {
@@ -345,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) }
@@ -397,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/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/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