squirreling 0.11.3 → 0.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -42,7 +42,7 @@
     "@types/node": "25.5.0",
     "@vitest/coverage-v8": "4.1.2",
     "eslint": "9.39.2",
-    "eslint-plugin-jsdoc": "62.8.1",
+    "eslint-plugin-jsdoc": "62.9.0",
     "typescript": "6.0.2",
     "vitest": "4.1.2"
   }

package/src/ast.d.ts

@@ -64,7 +64,7 @@ export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
 
 export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp | ArithmeticOp
 
-export type ComparisonOp = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>='
+export type ComparisonOp = '=' | '==' | '!=' | '<>' | '<' | '>' | '<=' | '>='
 
 export interface LiteralNode extends AstBase {
   type: 'literal'
@@ -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 {
@@ -166,12 +167,12 @@ export type ExprNode =
   | IntervalNode
   | StarNode
 
-export interface StarColumn {
+export interface StarColumn extends AstBase {
   type: 'star'
   table?: string
 }
 
-export interface DerivedColumn {
+export interface DerivedColumn extends AstBase {
   type: 'derived'
   expr: ExprNode
   alias?: string
@@ -179,7 +180,7 @@ export interface DerivedColumn {
 
 export type SelectColumn = StarColumn | DerivedColumn
 
-export interface OrderByItem {
+export interface OrderByItem extends AstBase {
   expr: ExprNode
   direction: 'ASC' | 'DESC'
   nulls?: 'FIRST' | 'LAST'

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/binary.js

@@ -30,7 +30,7 @@ export function applyBinaryOp(op, a, b) {
   if (op === 'AND') return Boolean(a) && Boolean(b)
   if (op === 'OR') return Boolean(a) || Boolean(b)
   if (op === '!=' || op === '<>') return a != b
-  if (op === '=') return a == b
+  if (op === '=' || op === '==') return a == b
   if (op === '<') return a < b
   if (op === '<=') return a <= b
   if (op === '>') return a > b

package/src/expression/evaluate.js

@@ -3,7 +3,7 @@ import { keyify, stringify } from '../execute/utils.js'
 import { ArgValueError, ExecutionError } from '../validation/executionErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc } from '../validation/functions.js'
 import { UnknownFunctionError } from '../validation/parseErrors.js'
-import { ColumnNotFoundError } from '../validation/planErrors.js'
+import { ColumnNotFoundError } from '../validation/tables.js'
 import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
 import { applyIntervalToDate, dateTrunc, extractField } from './date.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/expression/math.js

@@ -27,7 +27,7 @@ export function evaluateMathFunc({ funcName, args }) {
     return Number(dividend) % Number(divisor)
   }
 
-  if (funcName === 'POWER') {
+  if (funcName === 'POWER' || funcName === 'POW') {
     const [base, exponent] = args
     if (base == null || exponent == null) return null
     return Number(base) ** Number(exponent)

package/src/parse/parse.js

@@ -175,7 +175,7 @@ function parseSelect(state) {
 
   // Support duckdb-style shorthand "FROM table"
   if (match(state, 'keyword', 'FROM')) {
-    columns = [{ type: 'star' }]
+    columns = [{ type: 'star', positionStart, positionEnd: positionStart }]
   } else {
     expect(state, 'keyword', 'SELECT')
     distinct = match(state, 'keyword', 'DISTINCT')
@@ -283,6 +283,9 @@ function parseSelect(state) {
         expr,
         direction,
         nulls,
+        positionStart,
+        positionEnd: state.lastPos,
+
       })
       if (!match(state, 'comma')) break
     }
@@ -339,17 +342,17 @@ function parseSelectList(state) {
   const cols = []
 
   while (true) {
-    const tok = current(state)
+    const { positionStart, type } = current(state)
 
     // Check for qualified asterisk (table.*)
-    if (tok.type === 'identifier') {
+    if (type === 'identifier') {
       const next = peekToken(state, 1)
       const nextNext = peekToken(state, 2)
       if (next.type === 'dot' && nextNext.type === 'operator' && nextNext.value === '*') {
         const table = consume(state).value
         consume(state) // consume dot
         consume(state) // consume asterisk
-        cols.push({ type: 'star', table })
+        cols.push({ type: 'star', table, positionStart, positionEnd: state.lastPos })
         if (!match(state, 'comma')) break
         continue
       }
@@ -357,7 +360,7 @@ function parseSelectList(state) {
 
     // Check for unqualified asterisk (*)
     if (match(state, 'operator', '*')) {
-      cols.push({ type: 'star' })
+      cols.push({ type: 'star', positionStart, positionEnd: state.lastPos })
       if (!match(state, 'comma')) break
       continue
     }
@@ -365,7 +368,7 @@ function parseSelectList(state) {
     // Parse derived column with optional alias
     const expr = parseExpression(state)
     const alias = parseAs(state)
-    cols.push({ type: 'derived', expr, alias })
+    cols.push({ type: 'derived', expr, alias, positionStart, positionEnd: state.lastPos })
 
     if (!match(state, 'comma')) break
   }

package/src/parse/primary.js

@@ -4,13 +4,15 @@ import { RESERVED_KEYWORDS } from '../validation/keywords.js'
 import { parseExpression } from './expression.js'
 import { parseFunctionCall } from './functions.js'
 import { parseStatement } from './parse.js'
-import { consume, current, expect, match, peekToken } from './state.js'
+import { consume, current, expect, match, parseError, peekToken } from './state.js'
 
 /**
  * @import { ExprNode, IntervalNode, ParserState, WhenClause } from '../types.js'
  */
 
 /**
+ * Parse a primary expression, which is the innermost order of operations.
+ *
  * @param {ParserState} state
  * @returns {ExprNode}
  */
@@ -112,15 +114,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,
     }
@@ -242,7 +248,7 @@ export function parsePrimary(state) {
     }
   }
 
-  throw new SyntaxError({ expected: 'expression', ...tok })
+  throw parseError(state, 'expression')
 }
 
 /**
@@ -253,19 +259,20 @@ function parseInterval(state) {
   const { positionStart } = expect(state, 'keyword', 'INTERVAL')
 
   // Get value (number or quoted string)
-  const valueTok = consume(state)
+  const valueTok = current(state)
   /** @type {number} */
   let value
   if (valueTok.type === 'number') {
     value = Number(valueTok.numericValue)
-  } else if (valueTok.type === 'string') {
-    value = parseFloat(valueTok.value)
-    if (isNaN(value)) {
-      throw new InvalidLiteralError({ expected: 'interval value', ...valueTok })
-    }
+  } else if (valueTok.type === 'string' && valueTok.value.trim() !== '') {
+    value = Number(valueTok.value)
   } else {
-    throw new SyntaxError({ expected: 'interval value (number)', ...valueTok })
+    throw parseError(state, 'interval value (number)')
+  }
+  if (isNaN(value)) {
+    throw new InvalidLiteralError({ expected: 'interval value', ...valueTok })
   }
+  consume(state)
 
   // Get unit keyword
   const unitTok = consume(state)

package/src/parse/state.js

@@ -1,4 +1,4 @@
-import { SyntaxError } from '../validation/parseErrors.js'
+import { SyntaxError, UnexpectedDotError } from '../validation/parseErrors.js'
 
 /**
  * @import { ParserState, Token, TokenType } from '../types.js'
@@ -78,5 +78,12 @@ export function parseError(state, expected) {
   const tok = current(state)
   const prevToken = state.tokens[state.pos - 1]
   const after = prevToken?.originalValue ?? prevToken?.value
+  if (tok.type === 'dot' && prevToken?.type === 'identifier') {
+    const nextToken = state.tokens[state.pos + 1]
+    if (nextToken && (nextToken.type === 'identifier' || nextToken.type === 'keyword')) {
+      const dottedName = after + '.' + (nextToken.originalValue ?? nextToken.value)
+      return new UnexpectedDotError({ dottedName, positionStart: prevToken.positionStart, positionEnd: nextToken.positionEnd })
+    }
+  }
   return new SyntaxError({ expected, after, ...tok })
 }

package/src/parse/tokenize.js

@@ -5,7 +5,7 @@ import { InvalidLiteralError, ParseError, UnexpectedCharError } from '../validat
  * @import { Token } from '../types.d.ts'
  */
 
-const NUMBER_REGEX = /^-?(?:\d+n|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)/
+const NUMBER_REGEX = /^-?(?:\d+n|(?:\d+\.?\d*|\d*\.\d+)(?:[eE][+-]?\d+)?)/
 
 /**
  * @param {string} query
@@ -32,40 +32,42 @@ export function tokenizeSql(query) {
   }
 
   /**
-   * @param {number} positionStart
    * @returns {Token}
    */
-  function parseNumber(positionStart) {
-    const value = query.slice(i).match(NUMBER_REGEX)?.[0]
-    if (!value) {
-      throw new InvalidLiteralError({ expected: 'number', value: query[i] || 'eof', positionStart, positionEnd: i + 1 })
-    }
+  function parseNumber() {
+    const positionStart = i
+    let value = query.slice(i).match(NUMBER_REGEX)?.[0] ?? ''
     i += value.length
-    const next = peek()
-    if (isAlpha(next) || next === '.') {
-      throw new InvalidLiteralError({ expected: 'number', value: value + next, positionStart, positionEnd: i + 1 })
+    // check for invalid characters immediately following the number
+    const ch = peek()
+    if (!value || isAlphaNumeric(ch) || ch === '.') {
+      const after = query.slice(i).match(/^-?(?:[0-9a-zA-Z_$.]*[0-9][eE][+-]?[0-9])?[0-9a-zA-Z_$.]*/)?.[0] ?? ch
+      value += after
+      i += after.length
+      throw new InvalidLiteralError({ expected: 'number', value, positionStart, positionEnd: i })
     }
     if (value.endsWith('n')) {
       return {
         type: 'number',
         value,
+        numericValue: BigInt(value.slice(0, -1)),
         positionStart,
         positionEnd: i,
-        numericValue: BigInt(value.slice(0, -1)),
       }
     }
     return {
       type: 'number',
       value,
+      numericValue: Number(value),
       positionStart,
       positionEnd: i,
-      numericValue: Number(value),
     }
   }
 
   while (i < len) {
     const positionStart = i
-    const ch = peek()
+    const ch = query[i]
+    const next = query[i + 1]
 
     if (isWhitespace(ch)) {
       i++
@@ -73,7 +75,7 @@ export function tokenizeSql(query) {
     }
 
     // line comment --
-    if (ch === '-' && query[i + 1] === '-') {
+    if (ch === '-' && next === '-') {
       while (i < len && query[i] !== '\n') {
         i++
       }
@@ -81,11 +83,11 @@ export function tokenizeSql(query) {
     }
 
     // block comment /* ... */
-    if (ch === '/' && query[i + 1] === '*') {
-      i += 2
+    if (ch === '/' && next === '*') {
+      i += 3
       while (i < len) {
-        if (query[i] === '*' && query[i + 1] === '/') {
-          i += 2
+        if (query[i - 1] === '*' && query[i] === '/') {
+          i++
           break
         }
         i++
@@ -94,7 +96,7 @@ export function tokenizeSql(query) {
     }
 
     // negative numbers (when not subtraction)
-    if (ch === '-' && isDigit(query[i + 1])) {
+    if (ch === '-' && (isDigit(next) || next === '.' && isDigit(query[i + 2]))) {
       const lastToken = tokens[tokens.length - 1]
       const isValueBefore = lastToken && (
         lastToken.type === 'identifier' ||
@@ -103,23 +105,23 @@ export function tokenizeSql(query) {
         lastToken.type === 'paren' && lastToken.value === ')'
       )
       if (!isValueBefore) {
-        tokens.push(parseNumber(positionStart))
+        tokens.push(parseNumber())
         continue
       }
     }
 
     // numbers
-    if (isDigit(ch)) {
-      tokens.push(parseNumber(positionStart))
+    if (isDigit(ch) || ch === '.' && isDigit(next)) {
+      tokens.push(parseNumber())
       continue
     }
 
     // identifiers / keywords
     if (isAlpha(ch)) {
-      let value = ''
-      while (isAlphaNumeric(peek())) {
-        value += nextChar()
-      }
+      do {
+        i++
+      } while (isAlphaNumeric(query[i]))
+      const value = query.slice(positionStart, i)
       const upper = value.toUpperCase()
       if (KEYWORDS.has(upper)) {
         tokens.push({
@@ -173,7 +175,7 @@ export function tokenizeSql(query) {
     // operators
     if ('<>!=+-*/%'.includes(ch)) {
       let op = nextChar()
-      if ((op === '<' || op === '>' || op === '!') && peek() === '=') {
+      if ((op === '<' || op === '>' || op === '!' || op === '=') && peek() === '=') {
         op += nextChar()
       } else if (op === '<' && peek() === '>') {
         op += nextChar()

package/src/parse/types.d.ts

@@ -23,8 +23,8 @@ export type TokenType =
 export interface Token {
   type: TokenType
   value: string
+  numericValue?: number | bigint // only for type number
+  originalValue?: string // keywords are uppercased, this keeps the original case
   positionStart: number
   positionEnd: number
-  numericValue?: number | bigint
-  originalValue?: string
 }

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)
@@ -227,9 +225,9 @@ function inferSelectSourceColumns({ select, cteColumns, tables }) {
     result.push(`${fromAlias}.${col}`)
   }
   for (const join of select.joins) {
-    const alias = join.alias ?? join.table
+    const joinAlias = join.alias ?? join.table
     for (const col of lookupTableColumns(join.table, cteColumns, tables)) {
-      result.push(`${alias}.${col}`)
+      result.push(`${joinAlias}.${col}`)
     }
   }
   return result

package/src/plan/plan.js

@@ -1,12 +1,12 @@
 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 { ColumnNotFoundError, TableNotFoundError } from '../validation/tables.js'
 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,7 +113,7 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   // Source alias for FROM clause
   const sourceAlias = fromAlias(select.from)
 
-  // Validate qualified references and resolve aliases
+  // Resolve aliases (and validate qualified references)
   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()
@@ -128,11 +128,25 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     }
     // Validate qualified references
     if (col.table && !(col.table in scopeTables)) {
-      throw new TableNotFoundError({ table: col.table, tables: scopeTables })
+      const qualified = col.table + '.*'
+      throw new TableNotFoundError({ table: col.table, qualified, tables: scopeTables, ...col })
     }
     return col
   })
 
+  // Validate qualified references in other clauses
+  validateTableRefs(select.where, scopeTables)
+  validateTableRefs(select.having, scopeTables)
+  for (const expr of select.groupBy) {
+    validateTableRefs(expr, scopeTables)
+  }
+  for (const term of select.orderBy) {
+    validateTableRefs(term.expr, scopeTables)
+  }
+  for (const join of select.joins) {
+    validateTableRefs(join.on, 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} */
@@ -216,7 +230,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 +266,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 +362,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 +414,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

@@ -115,6 +115,7 @@ export type MathFunc =
   | 'EXP'
   | 'LN'
   | 'LOG10'
+  | 'POW'
   | 'POWER'
   | 'SQRT'
   | 'SIN'

package/src/validation/functions.js

@@ -20,7 +20,7 @@ export function isAggregateFunc(name) {
  */
 export function isMathFunc(name) {
   return [
-    'FLOOR', 'CEIL', 'CEILING', 'ROUND', 'ABS', 'SIGN', 'MOD', 'EXP', 'LN', 'LOG10', 'POWER', 'SQRT',
+    'FLOOR', 'CEIL', 'CEILING', 'ROUND', 'ABS', 'SIGN', 'MOD', 'EXP', 'LN', 'LOG10', 'POW', 'POWER', 'SQRT',
     'SIN', 'COS', 'TAN', 'COT', 'ASIN', 'ACOS', 'ATAN', 'ATAN2', 'DEGREES', 'RADIANS', 'PI',
     'RAND', 'RANDOM',
   ].includes(name)
@@ -87,7 +87,7 @@ export function isStringFunc(name) {
  * @returns {op is BinaryOp}
  */
 export function isBinaryOp(op) {
-  return ['AND', 'OR', 'LIKE', '=', '!=', '<>', '<', '>', '<=', '>='].includes(op)
+  return ['AND', 'OR', 'LIKE', '=', '==', '!=', '<>', '<', '>', '<=', '>='].includes(op)
 }
 
 /**
@@ -135,6 +135,7 @@ export const FUNCTION_SIGNATURES = {
   LN: { min: 1, max: 1, signature: 'number' },
   LOG10: { min: 1, max: 1, signature: 'number' },
   POWER: { min: 2, max: 2, signature: 'base, exponent' },
+  POW: { min: 2, max: 2, signature: 'base, exponent' },
   SQRT: { min: 1, max: 1, signature: 'number' },
   SIN: { min: 1, max: 1, signature: 'radians' },
   COS: { min: 1, max: 1, signature: 'radians' },

package/src/validation/parseErrors.js

@@ -37,6 +37,21 @@ export class SyntaxError extends ParseError {
   }
 }
 
+/**
+ * Error when a dot appears after an identifier, suggesting the user meant a dotted name.
+ */
+export class UnexpectedDotError extends ParseError {
+  /**
+   * @param {Object} options
+   * @param {string} options.dottedName - The combined dotted name (e.g., "dataset.parquet")
+   * @param {number} options.positionStart
+   * @param {number} options.positionEnd
+   */
+  constructor({ dottedName, positionStart, positionEnd }) {
+    super({ message: `Unexpected "." in "${dottedName}". If this is an identifier, use double quotes: "${dottedName}"`, positionStart, positionEnd })
+  }
+}
+
 /**
  * Error for invalid literals (numbers, intervals, etc).
  */
@@ -48,10 +63,12 @@ export class InvalidLiteralError extends ParseError {
    * @param {number} options.positionStart
    * @param {number} options.positionEnd
    * @param {string} [options.validValues] - List of valid values (for enums like interval units)
+   * @param {string} [options.after] - What token came before (for context)
    */
-  constructor({ expected, value, positionStart, positionEnd, validValues }) {
+  constructor({ expected, value, positionStart, positionEnd, validValues, after }) {
     const suffix = validValues ? `. Valid values: ${validValues}` : ''
-    super({ message: `Invalid ${expected} ${value} at position ${positionStart}${suffix}`, positionStart, positionEnd })
+    const afterStr = after ? ` after "${after}"` : ''
+    super({ message: `Invalid ${expected} ${value}${afterStr} at position ${positionStart}${suffix}`, positionStart, positionEnd })
   }
 }
 

package/src/validation/tables.js

@@ -1,4 +1,4 @@
-import { ColumnNotFoundError, TableNotFoundError } from './planErrors.js'
+import { ExecutionError } from './executionErrors.js'
 
 /**
  * @import { AsyncDataSource, ExprNode, ScanOptions } from '../types.js'
@@ -7,15 +7,16 @@ import { ColumnNotFoundError, TableNotFoundError } from './planErrors.js'
 /**
  * @param {Object} options
  * @param {string} options.table - The name of the table to validate
+ * @param {string} [options.qualified] - The qualified identifier used in the query (for error messages)
  * @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 } ) {
+export function validateTable({ table, qualified, tables, positionStart, positionEnd } ) {
   const resolved = tables[table]
   if (!resolved) {
-    throw new TableNotFoundError({ table, tables, positionStart, positionEnd })
+    throw new TableNotFoundError({ table, qualified, tables, positionStart, positionEnd })
   }
   return resolved
 }
@@ -52,15 +53,14 @@ 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 })
-      }
-    }
-    return
+  if (expr.type === 'identifier' && expr.prefix && !(expr.prefix in tables)) {
+    throw new TableNotFoundError({
+      table: expr.prefix,
+      qualified: expr.prefix + '.' + expr.name,
+      tables,
+      positionStart: expr.positionStart,
+      positionEnd: expr.positionStart + expr.prefix.length,
+    })
   }
   if (expr.type === 'binary') {
     validateTableRefs(expr.left, tables)
@@ -87,3 +87,53 @@ export function validateTableRefs(expr, tables) {
     validateTableRefs(expr.elseResult, tables)
   }
 }
+
+/**
+ * Error for missing table references.
+ */
+export class TableNotFoundError extends ExecutionError {
+  /**
+   * @param {Object} options
+   * @param {string} options.table - The missing table name
+   * @param {string} [options.qualified] - The identifier used in the query
+   * @param {Record<string, any>} options.tables - Available tables object
+   * @param {number} [options.positionStart]
+   * @param {number} [options.positionEnd]
+   */
+  constructor({ table, qualified, tables, positionStart, positionEnd }) {
+    const usage = qualified ? ` in "${qualified}"` : ''
+    const available = tables
+      ? `. Available tables: ${Object.keys(tables).join(', ')}`
+      : ''
+    super({
+      message: `Table "${table}" not found${usage}${available}`,
+      positionStart,
+      positionEnd,
+    })
+  }
+}
+
+/**
+ * Error for missing column references.
+ */
+export class ColumnNotFoundError extends ExecutionError {
+  /**
+   * @param {Object} options
+   * @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({ missingColumn, availableColumns, positionStart, positionEnd, rowIndex }) {
+    const available = availableColumns.length > 0
+      ? `. Available columns: ${availableColumns.join(', ')}`
+      : ''
+    super({
+      message: `Column "${missingColumn}" not found${available}`,
+      positionStart,
+      positionEnd,
+      rowIndex,
+    })
+  }
+}

package/src/validation/planErrors.js

@@ -1,50 +0,0 @@
-import { ExecutionError } from './executionErrors.js'
-
-/**
- * Error for missing table references.
- */
-export class TableNotFoundError extends ExecutionError {
-  /**
-   * @param {Object} options
-   * @param {string} options.table - The missing table name
-   * @param {Record<string, any>} options.tables - Available tables object
-   * @param {number} [options.positionStart]
-   * @param {number} [options.positionEnd]
-   */
-  constructor({ table, tables, positionStart, positionEnd }) {
-    const names = tables ? Object.keys(tables) : []
-    const available = names.length
-      ? `. Available tables: ${names.join(', ')}`
-      : ''
-    super({
-      message: `Table "${table}" not found${available}`,
-      positionStart,
-      positionEnd,
-    })
-  }
-}
-
-/**
- * Error for missing column references.
- */
-export class ColumnNotFoundError extends ExecutionError {
-  /**
-   * @param {Object} options
-   * @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({ missingColumn, availableColumns, positionStart, positionEnd, rowIndex }) {
-    const available = availableColumns.length > 0
-      ? `. Available columns: ${availableColumns.join(', ')}`
-      : ''
-    super({
-      message: `Column "${missingColumn}" not found${available}`,
-      positionStart,
-      positionEnd,
-      rowIndex,
-    })
-  }
-}