squirreling 0.10.2 → 0.11.0

package/src/parse/functions.js

@@ -1,5 +1,5 @@
-import { isAggregateFunc, validateFunctionArgCount } from '../validation/functions.js'
-import { ParseError, syntaxError } from '../validation/parseErrors.js'
+import { isAggregateFunc, isKnownFunction, niladicFuncs, validateFunctionArgs } from '../validation/functions.js'
+import { ParseError, UnknownFunctionError } from '../validation/parseErrors.js'
 import { parseExpression } from './expression.js'
 import { consume, current, expect, match } from './state.js'
 
@@ -8,17 +8,33 @@ import { consume, current, expect, match } from './state.js'
  */
 
 /**
- * Parses a function call after the function name has been identified.
- * Expects the current token to be '('.
- *
  * @param {ParserState} state
- * @param {string} funcName - The function name
- * @param {number} positionStart - Start position of the function name
+ * @param {number} positionStart
  * @returns {ExprNode}
  */
-export function parseFunctionCall(state, funcName, positionStart) {
+export function parseFunctionCall(state, positionStart) {
+  const funcTok = consume(state)
+  const funcName = funcTok.originalValue ?? funcTok.value
   const funcNameUpper = funcName.toUpperCase()
-  consume(state) // '(' checked by caller
+
+  // Validate function existence early for better error messages
+  if (!isKnownFunction(funcNameUpper, state.functions)) {
+    throw new UnknownFunctionError({ funcName, ...funcTok })
+  }
+
+  // Niladic datetime functions (no parentheses required per ANSI SQL)
+  const parens = current(state)
+  if (niladicFuncs.includes(funcNameUpper) && parens.type !== 'paren' || parens.value !== '(') {
+    return {
+      type: 'function',
+      funcName,
+      args: [],
+      positionStart,
+      positionEnd: state.lastPos,
+    }
+  }
+
+  expect(state, 'paren', '(')
 
   /** @type {ExprNode[]} */
   const args = []
@@ -26,51 +42,30 @@ export function parseFunctionCall(state, funcName, positionStart) {
   let distinct
 
   // Check for DISTINCT or ALL keyword (for aggregate functions like COUNT(DISTINCT x))
-  if (current(state).type === 'keyword' && current(state).value === 'DISTINCT') {
-    consume(state)
+  if (match(state, 'keyword', 'DISTINCT')) {
     distinct = true
-  } else if (current(state).type === 'keyword' && current(state).value === 'ALL') {
-    consume(state)
+  } else {
+    match(state, 'keyword', 'ALL')
   }
 
-  if (current(state).type !== 'paren' || current(state).value !== ')') {
-    while (true) {
-      // Handle COUNT(*) - treat * as a special identifier
-      if (current(state).type === 'operator' && current(state).value === '*') {
-        const starTok = current(state)
-        consume(state)
-        args.push({
-          type: 'star',
-          positionStart: starTok.positionStart,
-          positionEnd: state.lastPos,
-        })
-      } else {
-        args.push(parseExpression(state))
-      }
-      if (!match(state, 'comma')) break
-    }
-  }
-  expect(state, 'paren', ')')
+  // Parse function arguments
+  while (true) {
+    const next = current(state)
+    if (next.type === 'paren' && next.value === ')') break
 
-  // Check for FILTER clause (only valid for aggregate functions)
-  /** @type {ExprNode | undefined} */
-  let filter
-  if (current(state).type === 'keyword' && current(state).value === 'FILTER') {
-    if (!isAggregateFunc(funcNameUpper)) {
-      throw syntaxError({
-        expected: 'aggregate function for FILTER clause',
-        received: `FILTER on non-aggregate function "${funcName}"`,
-        positionStart: current(state).positionStart,
-        positionEnd: current(state).positionEnd,
+    // Handle COUNT(*) - treat * as a special identifier
+    if (match(state, 'operator', '*')) {
+      args.push({
+        type: 'star',
+        positionStart: next.positionStart,
+        positionEnd: state.lastPos,
       })
+    } else {
+      args.push(parseExpression(state))
     }
-    consume(state) // FILTER
-    expect(state, 'paren', '(')
-    expect(state, 'keyword', 'WHERE')
-    filter = parseExpression(state)
-    expect(state, 'paren', ')')
+    if (!match(state, 'comma')) break
   }
-  const positionEnd = state.lastPos
+  expect(state, 'paren', ')')
 
   // Validate star argument at parse time (only COUNT supports *)
   const hasStar = args.length === 1 && args[0].type === 'star'
@@ -78,19 +73,36 @@ export function parseFunctionCall(state, funcName, positionStart) {
     throw new ParseError({
       message: `${funcName} cannot be applied to "*"`,
       positionStart,
-      positionEnd,
+      positionEnd: state.lastPos,
     })
   }
   if (hasStar && distinct) {
     throw new ParseError({
       message: 'COUNT(DISTINCT *) is not allowed',
       positionStart,
-      positionEnd,
+      positionEnd: state.lastPos,
     })
   }
 
   // Validate argument count at parse time
-  validateFunctionArgCount(funcNameUpper, args.length, positionStart, positionEnd, state.functions)
+  validateFunctionArgs(funcNameUpper, args.length, positionStart, state.lastPos, state.functions)
+
+  // Check for FILTER clause (only valid for aggregate functions)
+  /** @type {ExprNode | undefined} */
+  let filter
+  const filterTok = current(state)
+  if (match(state, 'keyword', 'FILTER')) {
+    if (!isAggregateFunc(funcNameUpper)) {
+      throw new ParseError({
+        message: `FILTER cannot be applied to non-aggregate function "${funcName}"`,
+        ...filterTok,
+      })
+    }
+    expect(state, 'paren', '(')
+    expect(state, 'keyword', 'WHERE')
+    filter = parseExpression(state)
+    expect(state, 'paren', ')')
+  }
 
   return {
     type: 'function',
@@ -99,6 +111,6 @@ export function parseFunctionCall(state, funcName, positionStart) {
     distinct,
     filter,
     positionStart,
-    positionEnd,
+    positionEnd: state.lastPos,
   }
 }

package/src/parse/joins.js

@@ -1,7 +1,7 @@
 import { expectNoAggregate } from '../validation/aggregates.js'
 import { parseExpression } from './expression.js'
 import { parseTableAlias } from './parse.js'
-import { consume, current, expect, expectIdentifier, match } from './state.js'
+import { current, expect, match } from './state.js'
 
 /**
  * @import { ExprNode, JoinClause, JoinType, ParserState } from '../types.js'
@@ -22,45 +22,31 @@ export function parseJoins(state) {
     /** @type {JoinType} */
     let joinType = 'INNER'
 
-    if (tok.type === 'keyword') {
-      if (tok.value === 'INNER') {
-        consume(state)
-        joinType = 'INNER'
-      } else if (tok.value === 'LEFT') {
-        consume(state)
-        match(state, 'keyword', 'OUTER') // LEFT OUTER JOIN
-        joinType = 'LEFT'
-      } else if (tok.value === 'RIGHT') {
-        consume(state)
-        match(state, 'keyword', 'OUTER') // RIGHT OUTER JOIN
-        joinType = 'RIGHT'
-      } else if (tok.value === 'FULL') {
-        consume(state)
-        match(state, 'keyword', 'OUTER') // FULL OUTER JOIN
-        joinType = 'FULL'
-      } else if (tok.value === 'POSITIONAL') {
-        consume(state)
-        joinType = 'POSITIONAL'
-      } else if (tok.value === 'JOIN') {
-        // Just JOIN (defaults to INNER)
-        consume(state)
-      } else {
-        // Not a join keyword, stop parsing joins
-        break
-      }
-
-      // If we consumed a join type keyword (INNER/LEFT/RIGHT/FULL), expect JOIN
-      if (tok.value !== 'JOIN') {
-        expect(state, 'keyword', 'JOIN')
-      }
-    } else {
-      // No more joins
+    if (match(state, 'keyword', 'INNER')) {
+      joinType = 'INNER'
+    } else if (match(state, 'keyword', 'LEFT')) {
+      match(state, 'keyword', 'OUTER') // LEFT OUTER JOIN
+      joinType = 'LEFT'
+    } else if (match(state, 'keyword', 'RIGHT')) {
+      match(state, 'keyword', 'OUTER') // RIGHT OUTER JOIN
+      joinType = 'RIGHT'
+    } else if (match(state, 'keyword', 'FULL')) {
+      match(state, 'keyword', 'OUTER') // FULL OUTER JOIN
+      joinType = 'FULL'
+    } else if (match(state, 'keyword', 'POSITIONAL')) {
+      joinType = 'POSITIONAL'
+    } else if (!match(state, 'keyword', 'JOIN')) {
+      // Not a join keyword, stop parsing joins
       break
     }
 
+    // If we consumed a type keyword, expect JOIN next
+    if (tok.value !== 'JOIN') {
+      expect(state, 'keyword', 'JOIN')
+    }
+
     // Parse table name and optional alias
-    const tableTok = expectIdentifier(state)
-    const tableName = tableTok.value
+    const tableTok = expect(state, 'identifier')
     const tableAlias = parseTableAlias(state)
 
     // Parse ON condition (not for POSITIONAL joins)
@@ -74,10 +60,10 @@ export function parseJoins(state) {
 
     joins.push({
       joinType,
-      table: tableName,
+      table: tableTok.value,
       alias: tableAlias,
       on: condition,
-      positionStart: tableTok.positionStart,
+      positionStart: tok.positionStart,
       positionEnd: tableTok.positionEnd,
     })
   }