squirreling 0.11.4 → 0.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.11.4",
+  "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'
@@ -167,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
@@ -180,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/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'

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}
  */
@@ -246,7 +248,7 @@ export function parsePrimary(state) {
     }
   }
 
-  throw new SyntaxError({ expected: 'expression', ...tok })
+  throw parseError(state, 'expression')
 }
 
 /**
@@ -257,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

@@ -225,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,7 +1,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 { ColumnNotFoundError, TableNotFoundError } from '../validation/tables.js'
 import { validateScan, validateTableRefs } from '../validation/tables.js'
 import { extractColumns, fromAlias, inferStatementColumns } from './columns.js'
 
@@ -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} */

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,13 +53,14 @@ export function validateScan({ table, hints, tables, positionStart, positionEnd
  */
 export function validateTableRefs(expr, tables) {
   if (!expr) return
-  if (expr.type === 'identifier') {
-    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
+  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)
@@ -85,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,
-    })
-  }
-}