squirreling 0.10.2 → 0.11.0

package/src/parse/parse.js

@@ -1,215 +1,177 @@
 import { expectNoAggregate, findAggregate } from '../validation/aggregates.js'
-import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE } from '../validation/functions.js'
-import { duplicateCTEError } from '../validation/parseErrors.js'
+import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE } from '../validation/keywords.js'
+import { ParseError } from '../validation/parseErrors.js'
 import { parseExpression } from './expression.js'
 import { parseJoins } from './joins.js'
-import { consume, current, expect, expectIdentifier, match, parseError, peekToken } from './state.js'
+import { consume, current, expect, match, parseError, peekToken } from './state.js'
 import { tokenizeSql } from './tokenize.js'
 
 /**
- * @import { CTEDefinition, ExprNode, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectStatement, SelectColumn, WithClause } from '../types.js'
+ * @import { CTEDefinition, ExprNode, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectColumn, SelectStatement, SetOperationStatement, SetOperator, Statement } from '../types.js'
  */
 
 /**
  * @param {ParseSqlOptions} options
- * @returns {SelectStatement}
+ * @returns {Statement}
  */
 export function parseSql({ query, functions }) {
   const tokens = tokenizeSql(query)
   /** @type {ParserState} */
   const state = { tokens, pos: 0, lastPos: 0, functions }
 
-  // Check for WITH clause
-  /** @type {WithClause | undefined} */
-  let withClause
-  if (match(state, 'keyword', 'WITH')) {
-    withClause = parseWithClause(state)
-  }
-
-  const select = parseSelectInternal(state)
-
-  // Attach WITH clause to the select statement
-  if (withClause) {
-    select.with = withClause
-  }
+  // Parse optional WITH clause
+  const stmt = parseStatement(state)
 
   const tok = current(state)
   if (tok.type !== 'eof') {
     throw parseError(state, 'end of query')
   }
 
-  return select
+  return stmt
 }
 
 /**
+ * Parses a WITH clause containing one or more CTEs, or a SELECT with optional set operations.
+ *
  * @param {ParserState} state
- * @returns {SelectColumn[]}
+ * @returns {Statement}
  */
-function parseSelectList(state) {
-  /** @type {SelectColumn[]} */
-  const cols = []
-
-  while (true) {
-    const tok = current(state)
+export function parseStatement(state) {
+  const positionStart = state.lastPos
+  if (match(state, 'keyword', 'WITH')) {
+    /** @type {CTEDefinition[]} */
+    const ctes = []
+    /** @type {Set<string>} */
+    const seenNames = new Set()
 
-    // Check for qualified asterisk (table.*)
-    if (tok.type === 'identifier') {
-      const next = peekToken(state, 1)
-      const nextNext = peekToken(state, 2)
-      if (next.type === 'dot' && nextNext.type === 'operator' && nextNext.value === '*') {
-        const tableTok = consume(state) // consume table name
-        consume(state) // consume dot
-        consume(state) // consume asterisk
-        cols.push({ kind: 'star', table: tableTok.value })
-        if (!match(state, 'comma')) break
-        continue
+    while (true) {
+      // Parse CTE name
+      const nameTok = expect(state, 'identifier')
+      const name = nameTok.value
+      const nameLower = name.toLowerCase()
+
+      // Check for duplicate CTE names
+      if (seenNames.has(nameLower)) {
+        throw new ParseError({
+          message: `CTE "${name}" is defined more than once at position ${positionStart}`,
+          ...nameTok,
+        })
       }
-    }
+      seenNames.add(nameLower)
 
-    // Check for unqualified asterisk (*)
-    if (tok.type === 'operator' && tok.value === '*') {
-      consume(state)
-      cols.push({ kind: 'star' })
+      // Expect AS statement
+      expect(state, 'keyword', 'AS')
+      expect(state, 'paren', '(')
+
+      // Parse the CTE's SELECT statement
+      const query = parseStatement(state)
+
+      expect(state, 'paren', ')')
+
+      ctes.push({ name, query, positionStart: nameTok.positionStart, positionEnd: state.lastPos })
+
+      // Check for comma (more CTEs) or end of WITH clause
       if (!match(state, 'comma')) break
-      continue
     }
 
-    cols.push(parseSelectItem(state))
-    if (!match(state, 'comma')) break
-  }
+    const query = parseSetOperations(state)
 
-  return cols
+    return { type: 'with', ctes, query, positionStart, positionEnd: state.lastPos }
+  } else {
+    return parseSetOperations(state)
+  }
 }
 
 /**
- * Parses a WITH clause containing one or more CTEs
+ * Checks for and parses UNION/INTERSECT/EXCEPT set operations after a SELECT.
+ * Handles chaining (e.g., SELECT ... UNION SELECT ... EXCEPT SELECT ...).
+ * ORDER BY and LIMIT/OFFSET on the last segment apply to the entire compound result.
  *
  * @param {ParserState} state
- * @returns {WithClause}
+ * @returns {SelectStatement | SetOperationStatement}
  */
-function parseWithClause(state) {
-  /** @type {CTEDefinition[]} */
-  const ctes = []
-  /** @type {Set<string>} */
-  const seenNames = new Set()
+function parseSetOperations(state) {
+  let left = parseIntersectOperations(state)
 
   while (true) {
-    // Parse CTE name
-    const nameTok = expectIdentifier(state)
-    const name = nameTok.value
-    const nameLower = name.toLowerCase()
-
-    // Check for duplicate CTE names
-    if (seenNames.has(nameLower)) {
-      throw duplicateCTEError({
-        cteName: name,
-        positionStart: nameTok.positionStart,
-        positionEnd: nameTok.positionEnd,
-      })
+    /** @type {SetOperator | undefined} */
+    let operator
+    if (match(state, 'keyword', 'UNION')) {
+      operator = 'UNION'
+    } else if (match(state, 'keyword', 'EXCEPT')) {
+      operator = 'EXCEPT'
     }
-    seenNames.add(nameLower)
-
-    // Expect AS statement
-    expect(state, 'keyword', 'AS')
-    expect(state, 'paren', '(')
-
-    // Parse the CTE's SELECT statement
-    const query = parseSelectInternal(state)
-
-    expect(state, 'paren', ')')
-
-    ctes.push({ name, query })
-
-    // Check for comma (more CTEs) or end of WITH clause
-    if (!match(state, 'comma')) {
-      break
+    if (!operator) return left
+
+    const all = !!match(state, 'keyword', 'ALL')
+    const right = parseIntersectOperations(state)
+
+    // ORDER BY / LIMIT / OFFSET after a set operation apply to the compound result.
+    // If the right SELECT parsed them, lift them to the compound statement.
+    left = {
+      type: 'compound',
+      operator,
+      all,
+      left,
+      right,
+      orderBy: right.orderBy,
+      limit: right.limit,
+      offset: right.offset,
+      positionStart: left.positionStart,
+      positionEnd: right.positionEnd,
     }
-  }
-
-  return { ctes }
-}
 
-/**
- * @param {ParserState} state
- * @returns {SelectColumn}
- */
-function parseSelectItem(state) {
-  const expr = parseExpression(state)
-  const alias = parseAs(state)
-  return { kind: 'derived', expr, alias }
-}
-
-/**
- * Parses an optional table alias (e.g., "FROM users u" or "FROM users AS u")
- * @param {ParserState} state
- * @returns {string | undefined}
- */
-export function parseTableAlias(state) {
-  // Check for explicit AS keyword
-  if (match(state, 'keyword', 'AS')) {
-    const aliasTok = expectIdentifier(state)
-    return aliasTok.value
-  }
-  // Check for implicit alias (identifier not in reserved list)
-  const maybeAlias = current(state)
-  if (maybeAlias.type === 'identifier' && !RESERVED_AFTER_TABLE.has(maybeAlias.value.toUpperCase())) {
-    consume(state)
-    return maybeAlias.value
+    // Clear lifted clauses from the right SELECT
+    right.orderBy = []
+    right.limit = undefined
+    right.offset = undefined
   }
 }
 
 /**
+ * Parses a left-associative INTERSECT chain, which binds tighter than UNION/EXCEPT.
+ *
  * @param {ParserState} state
- * @returns {string | undefined}
+ * @returns {SelectStatement | SetOperationStatement}
  */
-function parseAs(state) {
-  if (match(state, 'keyword', 'AS')) {
-    // After AS, allow keywords as aliases (except reserved ones)
-    const aliasTok = current(state)
-    if (aliasTok.type === 'identifier') {
-      consume(state)
-      return aliasTok.value
-    } else if (aliasTok.type === 'keyword' && !RESERVED_AFTER_COLUMN.has(aliasTok.value.toUpperCase())) {
-      consume(state)
-      // Use original case for keywords used as aliases
-      return aliasTok.originalValue ?? aliasTok.value
-    } else {
-      throw parseError(state, 'alias')
-    }
-  } else {
-    // Implicit alias SELECT UPPER(name) name_upper
-    const maybeAlias = current(state)
-    if (maybeAlias.type === 'identifier' && !RESERVED_AFTER_COLUMN.has(maybeAlias.value.toUpperCase())) {
-      consume(state)
-      return maybeAlias.value
+function parseIntersectOperations(state) {
+  /** @type {SelectStatement | SetOperationStatement} */
+  let left = parseSelect(state)
+
+  while (match(state, 'keyword', 'INTERSECT')) {
+    const all = !!match(state, 'keyword', 'ALL')
+    const right = parseSelect(state)
+
+    left = {
+      type: 'compound',
+      operator: 'INTERSECT',
+      all,
+      left,
+      right,
+      orderBy: right.orderBy,
+      limit: right.limit,
+      offset: right.offset,
+      positionStart: left.positionStart,
+      positionEnd: right.positionEnd,
     }
+
+    right.orderBy = []
+    right.limit = undefined
+    right.offset = undefined
   }
-}
 
-/**
- * Parses a subquery in parentheses with an alias
- * @param {ParserState} state
- * @returns {FromSubquery}
- */
-function parseFromSubquery(state) {
-  expect(state, 'paren', '(')
-  const query = parseSelectInternal(state)
-  expect(state, 'paren', ')')
-  const alias = parseTableAlias(state)
-  return { kind: 'subquery', query, alias }
+  return left
 }
 
 /**
  * @param {ParserState} state
  * @returns {SelectStatement}
  */
-export function parseSelectInternal(state) {
+function parseSelect(state) {
+  const { positionStart } = current(state)
   expect(state, 'keyword', 'SELECT')
 
-  let distinct = false
-  if (match(state, 'keyword', 'DISTINCT')) {
-    distinct = true
-  }
+  const distinct = match(state, 'keyword', 'DISTINCT')
 
   const columns = parseSelectList(state)
 
@@ -221,12 +183,28 @@ export function parseSelectInternal(state) {
   const tok = current(state)
   if (tok.type === 'paren' && tok.value === '(') {
     // Subquery: SELECT * FROM (SELECT ...) AS alias
-    from = parseFromSubquery(state)
+    expect(state, 'paren', '(')
+    const query = parseStatement(state)
+    expect(state, 'paren', ')')
+    const alias = parseTableAlias(state)
+    from = {
+      type: 'subquery',
+      query,
+      alias,
+      positionStart: tok.positionStart,
+      positionEnd: state.lastPos,
+    }
   } else {
     // Simple table name: SELECT * FROM users
-    const tableTok = expectIdentifier(state)
+    expect(state, 'identifier')
     const alias = parseTableAlias(state)
-    from = { kind: 'table', table: tableTok.value, alias, positionStart: tableTok.positionStart, positionEnd: tableTok.positionEnd }
+    from = {
+      type: 'table',
+      table: tok.value,
+      alias,
+      positionStart: tok.positionStart,
+      positionEnd: state.lastPos,
+    }
   }
 
   // Parse JOIN clauses
@@ -265,7 +243,7 @@ export function parseSelectInternal(state) {
   }
 
   const hasAggregate = groupBy.length > 0 || columns.some(col =>
-    col.kind === 'derived' && findAggregate(col.expr)
+    col.type === 'derived' && findAggregate(col.expr)
   )
 
   if (match(state, 'keyword', 'ORDER')) {
@@ -285,12 +263,11 @@ export function parseSelectInternal(state) {
       /** @type {'FIRST' | 'LAST' | undefined} */
       let nulls
       if (match(state, 'keyword', 'NULLS')) {
-        const tok = current(state)
-        if (tok.type === 'identifier' && tok.value.toUpperCase() === 'FIRST') {
-          consume(state)
+        const tok = consume(state)
+        const upper = tok.value.toUpperCase()
+        if (tok.type === 'identifier' && upper === 'FIRST') {
           nulls = 'FIRST'
-        } else if (tok.type === 'identifier' && tok.value.toUpperCase() === 'LAST') {
-          consume(state)
+        } else if (tok.type === 'identifier' && upper === 'LAST') {
           nulls = 'LAST'
         } else {
           throw parseError(state, 'FIRST or LAST after NULLS')
@@ -306,57 +283,32 @@ export function parseSelectInternal(state) {
   }
 
   if (match(state, 'keyword', 'LIMIT')) {
-    const tok = current(state)
-    if (tok.type !== 'number') {
-      throw parseError(state, 'numeric LIMIT')
-    }
-    consume(state)
-    const n = parseInt(tok.value, 10)
-    if (!Number.isFinite(n)) {
-      throw parseError(state, 'valid LIMIT value')
+    const tok = consume(state)
+    if (tok.type !== 'number' || typeof tok.numericValue !== 'number') {
+      throw parseError(state, 'positive integer LIMIT')
     }
-    if (n < 0) {
-      throw parseError(state, 'non-negative LIMIT value')
+    if (!Number.isInteger(tok.numericValue) || tok.numericValue < 0) {
+      throw parseError(state, 'positive integer LIMIT value')
     }
-    limit = n
+    limit = tok.numericValue
+  }
 
-    if (match(state, 'keyword', 'OFFSET')) {
-      const oTok = current(state)
-      if (oTok.type !== 'number') {
-        throw parseError(state, 'numeric OFFSET')
-      }
-      consume(state)
-      const off = parseInt(oTok.value, 10)
-      if (!Number.isFinite(off)) {
-        throw parseError(state, 'valid OFFSET value')
-      }
-      if (off < 0) {
-        throw parseError(state, 'non-negative OFFSET value')
-      }
-      offset = off
+  if (match(state, 'keyword', 'OFFSET')) {
+    const tok = consume(state)
+    if (tok.type !== 'number' || typeof tok.numericValue !== 'number') {
+      throw parseError(state, 'positive integer OFFSET value')
     }
-  } else if (match(state, 'keyword', 'OFFSET')) {
-    const oTok = current(state)
-    if (oTok.type !== 'number') {
-      throw parseError(state, 'numeric OFFSET')
+    if (!Number.isInteger(tok.numericValue) || tok.numericValue < 0) {
+      throw parseError(state, 'positive integer OFFSET value')
     }
-    consume(state)
-    const off = parseInt(oTok.value, 10)
-    if (!Number.isFinite(off)) {
-      throw parseError(state, 'valid OFFSET value')
-    }
-    if (off < 0) {
-      throw parseError(state, 'non-negative OFFSET value')
-    }
-    offset = off
+    offset = tok.numericValue
   }
 
   // optional trailing semicolon
-  if (current(state).type === 'semicolon') {
-    consume(state)
-  }
+  match(state, 'semicolon')
 
   return {
+    type: 'select',
     distinct,
     columns,
     from,
@@ -367,5 +319,97 @@ export function parseSelectInternal(state) {
     orderBy,
     limit,
     offset,
+    positionStart,
+    positionEnd: state.lastPos,
+  }
+}
+
+/**
+ * @param {ParserState} state
+ * @returns {SelectColumn[]}
+ */
+function parseSelectList(state) {
+  /** @type {SelectColumn[]} */
+  const cols = []
+
+  while (true) {
+    const tok = current(state)
+
+    // Check for qualified asterisk (table.*)
+    if (tok.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 })
+        if (!match(state, 'comma')) break
+        continue
+      }
+    }
+
+    // Check for unqualified asterisk (*)
+    if (match(state, 'operator', '*')) {
+      cols.push({ type: 'star' })
+      if (!match(state, 'comma')) break
+      continue
+    }
+
+    // Parse derived column with optional alias
+    const expr = parseExpression(state)
+    const alias = parseAs(state)
+    cols.push({ type: 'derived', expr, alias })
+
+    if (!match(state, 'comma')) break
+  }
+
+  return cols
+}
+
+/**
+ * Parses an optional table alias (e.g., "FROM users u" or "FROM users AS u")
+ * @param {ParserState} state
+ * @returns {string | undefined}
+ */
+export function parseTableAlias(state) {
+  // Check for explicit AS keyword
+  if (match(state, 'keyword', 'AS')) {
+    const aliasTok = expect(state, 'identifier')
+    return aliasTok.value
+  }
+  // Check for implicit alias (identifier not in reserved list)
+  const maybeAlias = current(state)
+  if (maybeAlias.type === 'identifier' && !RESERVED_AFTER_TABLE.has(maybeAlias.value.toUpperCase())) {
+    consume(state)
+    return maybeAlias.value
+  }
+}
+
+/**
+ * @param {ParserState} state
+ * @returns {string | undefined}
+ */
+function parseAs(state) {
+  if (match(state, 'keyword', 'AS')) {
+    // After AS, allow keywords as aliases (except reserved ones)
+    const aliasTok = current(state)
+    if (aliasTok.type === 'identifier') {
+      consume(state)
+      return aliasTok.value
+    } else if (aliasTok.type === 'keyword' && !RESERVED_AFTER_COLUMN.has(aliasTok.value)) {
+      consume(state)
+      // Use original case for keywords used as aliases
+      return aliasTok.originalValue ?? aliasTok.value
+    } else {
+      throw parseError(state, 'alias')
+    }
+  } else {
+    // Implicit alias SELECT UPPER(name) name_upper
+    const maybeAlias = current(state)
+    if (maybeAlias.type === 'identifier' && !RESERVED_AFTER_COLUMN.has(maybeAlias.value.toUpperCase())) {
+      consume(state)
+      return maybeAlias.value
+    }
   }
 }