squirreling 0.8.0 → 0.9.1

package/src/expression/evaluate.js

@@ -2,8 +2,9 @@ import { executeSelect } from '../execute/execute.js'
 import { stringify } from '../execute/utils.js'
 import { columnNotFoundError, invalidContextError } from '../executionErrors.js'
 import { unknownFunctionError } from '../parseErrors.js'
-import { aggregateError, argValueError, castError } from '../validationErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isStringFunc } from '../validation.js'
+import { aggregateError, argValueError, castError } from '../validationErrors.js'
+import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
 import { applyIntervalToDate } from './date.js'
 import { evaluateMathFunc } from './math.js'
@@ -11,24 +12,21 @@ import { evaluateRegexpFunc } from './regexp.js'
 import { evaluateStringFunc } from './strings.js'
 
 /**
- * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, UserDefinedFunction } from '../types.js'
+ * @import { ExprNode, AsyncRow, ExecuteContext, SqlPrimitive } from '../types.js'
  */
 
 /**
- * Evaluates an expression node against a row of data (async version)
+ * Evaluates an expression node against a row of data
  *
- * @param {Object} params
- * @param {ExprNode} params.node - The expression node to evaluate
- * @param {AsyncRow} params.row - The data row to evaluate against
- * @param {Record<string, AsyncDataSource>} params.tables
- * @param {Record<string, UserDefinedFunction>} [params.functions] - User-defined functions
- * @param {number} [params.rowIndex] - 1-based row index for error reporting
- * @param {AsyncRow[]} [params.rows] - Group of rows for aggregate functions
- * @param {Map<string, ExprNode>} [params.aliases] - SELECT column aliases for ORDER BY resolution
- * @param {AbortSignal} [params.signal] - abort signal for cancellation
+ * @param {Object} options
+ * @param {ExprNode} options.node - The expression node to evaluate
+ * @param {AsyncRow} options.row - The data row to evaluate against
+ * @param {number} [options.rowIndex] - 1-based row index for error reporting
+ * @param {AsyncRow[]} [options.rows] - Group of rows for aggregate functions (undefined if not in aggregate context)
+ * @param {ExecuteContext} options.context - execution context (tables, functions, signal)
  * @returns {Promise<SqlPrimitive>} The result of the evaluation
  */
-export async function evaluateExpr({ node, row, tables, functions, rowIndex, rows, aliases, signal }) {
+export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   if (node.type === 'literal') {
     return node.value
   }
@@ -45,10 +43,6 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         return row.cells[colName]()
       }
     }
-    // Check if it's a SELECT alias (for ORDER BY)
-    if (aliases?.has(node.name)) {
-      return evaluateExpr({ node: aliases.get(node.name), row, tables, functions, rowIndex, rows, aliases, signal })
-    }
     // Unknown identifier
     throw columnNotFoundError({
       columnName: node.name,
@@ -61,7 +55,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
-    const gen = executeSelect({ select: node.subquery, tables, functions, signal })
+    const gen = executeSelect({ select: node.subquery, context })
     const { value } = await gen.next() // Start the generator
     gen.return(undefined) // Stop further execution
     if (!value) return null
@@ -70,7 +64,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
   // Unary operators
   if (node.type === 'unary') {
-    const val = await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows, aliases, signal })
+    const val = await evaluateExpr({ node: node.argument, row, rowIndex, rows, context })
     if (node.op === '-') {
       if (val == null) return null
       return -val
@@ -84,21 +78,21 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
   if (node.type === 'binary') {
     // Handle date +/- interval
     if ((node.op === '+' || node.op === '-') && node.right.type === 'interval') {
-      const dateVal = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows, aliases, signal })
+      const dateVal = await evaluateExpr({ node: node.left, row, rowIndex, rows, context })
       return applyIntervalToDate(dateVal, node.right.value, node.right.unit, node.op)
     }
     if (node.op === '+' && node.left.type === 'interval') {
-      const dateVal = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows, aliases, signal })
+      const dateVal = await evaluateExpr({ node: node.right, row, rowIndex, rows, context })
       return applyIntervalToDate(dateVal, node.left.value, node.left.unit, '+')
     }
 
-    const left = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows, aliases, signal })
+    const left = await evaluateExpr({ node: node.left, row, rowIndex, rows, context })
 
     // Short-circuit evaluation for AND and OR
     if (node.op === 'AND' && !left) return false
     if (node.op === 'OR' && left) return true
 
-    const right = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows, aliases, signal })
+    const right = await evaluateExpr({ node: node.right, row, rowIndex, rows, context })
     return applyBinaryOp(node.op, left, right)
   }
 
@@ -109,10 +103,18 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
     // Handle aggregate functions
     if (isAggregateFunc(funcName)) {
       if (!rows) {
-        throw aggregateError({
-          funcName,
-          issue: ' is not allowed outside of aggregate context',
-        })
+        // Aggregate function used outside of aggregate context
+        // This is only allowed if same aggregate was in the SELECT list
+        const alias = derivedAlias(node)
+        if (row.columns.includes(alias)) {
+          return row.cells[alias]()
+        } else {
+          throw aggregateError({
+            funcName,
+            positionStart: node.positionStart,
+            positionEnd: node.positionEnd,
+          })
+        }
       }
 
       // Apply FILTER clause if present
@@ -120,20 +122,14 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       if (node.filter) {
         filteredRows = []
         for (const row of rows) {
-          const passes = await evaluateExpr({ node: node.filter, row, tables, functions, signal })
+          const passes = await evaluateExpr({ node: node.filter, row, context })
           if (passes) filteredRows.push(row)
         }
       }
 
-      // Check for star argument (COUNT(*))
-      if (node.args.length === 1 && node.args[0].type === 'identifier' && node.args[0].name === '*') {
-        if (funcName === 'COUNT') {
-          return filteredRows.length
-        }
-        throw aggregateError({
-          funcName,
-          issue: '(*) is not supported. Only COUNT supports *.',
-        })
+      // Handle COUNT(*) special case
+      if (node.args.length === 1 && node.args[0].type === 'identifier' && funcName === 'COUNT' && node.args[0].name === '*') {
+        return filteredRows.length
       }
 
       const argNode = node.args[0]
@@ -142,14 +138,14 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         if (node.distinct) {
           const seen = new Set()
           for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
+            const v = await evaluateExpr({ node: argNode, row, context })
             if (v != null) seen.add(v)
           }
           return seen.size
         }
         let count = 0
         for (const row of filteredRows) {
-          const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
+          const v = await evaluateExpr({ node: argNode, row, context })
           if (v != null) count++
         }
         return count
@@ -164,7 +160,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         let max = null
 
         for (const row of filteredRows) {
-          const raw = await evaluateExpr({ node: argNode, row, tables, functions, signal })
+          const raw = await evaluateExpr({ node: argNode, row, context })
           if (raw == null) continue
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
@@ -189,7 +185,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       if (funcName === 'STDDEV_SAMP' || funcName === 'STDDEV_POP') {
         const values = []
         for (const row of filteredRows) {
-          const raw = await evaluateExpr({ node: argNode, row, tables, functions, signal })
+          const raw = await evaluateExpr({ node: argNode, row, context })
           if (raw == null) continue
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
@@ -211,7 +207,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         if (node.distinct) {
           const seen = new Set()
           for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
+            const v = await evaluateExpr({ node: argNode, row, context })
             const key = stringify(v)
             if (!seen.has(key)) {
               seen.add(key)
@@ -220,7 +216,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
           }
         } else {
           for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
+            const v = await evaluateExpr({ node: argNode, row, context })
             values.push(v)
           }
         }
@@ -229,7 +225,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
     }
 
     /** @type {SqlPrimitive[]} */
-    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows, aliases, signal })))
+    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, rowIndex, rows, context })))
 
     if (isStringFunc(funcName)) {
       return evaluateStringFunc({
@@ -258,7 +254,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
     if (funcName === 'COALESCE') {
       // Short-circuit: evaluate args one at a time, return first non-null
       for (const arg of node.args) {
-        const val = await evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows, signal })
+        const val = await evaluateExpr({ node: arg, row, rowIndex, rows, context })
         if (val != null) return val
       }
       return null
@@ -266,8 +262,8 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
     if (funcName === 'NULLIF') {
       // NULLIF(a, b) returns null if a = b, otherwise returns a
-      const val1 = await evaluateExpr({ node: node.args[0], row, tables, functions, rowIndex, rows, signal })
-      const val2 = await evaluateExpr({ node: node.args[1], row, tables, functions, rowIndex, rows, signal })
+      const val1 = await evaluateExpr({ node: node.args[0], row, rowIndex, rows, context })
+      const val2 = await evaluateExpr({ node: node.args[1], row, rowIndex, rows, context })
       return val1 == val2 ? null : val1
     }
 
@@ -370,6 +366,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
     }
 
     // Check user-defined functions (case-insensitive lookup)
+    const { functions } = context
     if (functions) {
       const udfName = Object.keys(functions).find(k => k.toUpperCase() === funcName)
       if (udfName) {
@@ -385,7 +382,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
   }
 
   if (node.type === 'cast') {
-    const val = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows, signal })
+    const val = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
     if (val == null) return null
     const toType = node.toType.toUpperCase()
     if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
@@ -428,17 +425,17 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
   // IN and NOT IN with value lists
   if (node.type === 'in valuelist') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows, signal })
+    const exprVal = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
     for (const valueNode of node.values) {
-      const val = await evaluateExpr({ node: valueNode, row, tables, functions, rowIndex, rows, signal })
+      const val = await evaluateExpr({ node: valueNode, row, rowIndex, rows, context })
       if (exprVal == val) return true
     }
     return false
   }
   // IN with subqueries
   if (node.type === 'in') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows, signal })
-    const results = executeSelect({ select: node.subquery, tables, functions, signal })
+    const exprVal = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
+    const results = executeSelect({ select: node.subquery, context })
     for await (const resRow of results) {
       const value = await resRow.cells[resRow.columns[0]]()
       if (exprVal == value) return true
@@ -448,39 +445,39 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
   // EXISTS and NOT EXISTS with subqueries
   if (node.type === 'exists') {
-    const results = await executeSelect({ select: node.subquery, tables, functions, signal }).next()
+    const results = await executeSelect({ select: node.subquery, context }).next()
     return results.done === false
   }
   if (node.type === 'not exists') {
-    const results = await executeSelect({ select: node.subquery, tables, functions, signal }).next()
+    const results = await executeSelect({ select: node.subquery, context }).next()
     return results.done === true
   }
 
   // CASE expressions
   if (node.type === 'case') {
     // For simple CASE: evaluate the case expression once
-    const caseValue = node.caseExpr && await evaluateExpr({ node: node.caseExpr, row, tables, functions, rowIndex, rows, signal })
+    const caseValue = node.caseExpr && await evaluateExpr({ node: node.caseExpr, row, rowIndex, rows, context })
 
     // Iterate through WHEN clauses
     for (const whenClause of node.whenClauses) {
       let conditionResult
       if (caseValue !== undefined) {
         // Simple CASE: compare caseValue with condition
-        const whenValue = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows, signal })
+        const whenValue = await evaluateExpr({ node: whenClause.condition, row, rowIndex, rows, context })
         conditionResult = caseValue == whenValue
       } else {
         // Searched CASE: evaluate condition as boolean
-        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows, signal })
+        conditionResult = await evaluateExpr({ node: whenClause.condition, row, rowIndex, rows, context })
       }
 
       if (conditionResult) {
-        return evaluateExpr({ node: whenClause.result, row, tables, functions, rowIndex, rows, signal })
+        return evaluateExpr({ node: whenClause.result, row, rowIndex, rows, context })
       }
     }
 
     // No WHEN clause matched, return ELSE result or NULL
     if (node.elseResult) {
-      return evaluateExpr({ node: node.elseResult, row, tables, functions, rowIndex, rows, signal })
+      return evaluateExpr({ node: node.elseResult, row, rowIndex, rows, context })
     }
     return null
   }

package/src/index.d.ts

@@ -1,11 +1,13 @@
-import type { AsyncDataSource, AsyncRow, ExecuteSqlOptions, ParseSqlOptions, SelectStatement, SqlPrimitive, Token } from './types.js'
+import type { AsyncDataSource, AsyncRow, ExecuteContext, ExecuteSqlOptions, ExprNode, ParseSqlOptions, PlanSqlOptions, QueryPlan, SelectStatement, SqlPrimitive, Token } from './types.js'
 export type {
   AsyncCells,
   AsyncDataSource,
   AsyncRow,
+  ExecuteContext,
   ExecuteSqlOptions,
   ExprNode,
   ParseSqlOptions,
+  PlanSqlOptions,
   QueryPlan,
   ScanOptions,
   ScanResults,
@@ -16,7 +18,7 @@ export type {
 } from './types.js'
 
 /**
- * Executes a SQL SELECT query against an array of data rows
+ * Executes a SQL SELECT query against tables
  *
  * @param options
  * @param options.tables - source data as a list of objects or an AsyncDataSource
@@ -27,6 +29,16 @@ export type {
  */
 export function executeSql(options: ExecuteSqlOptions): AsyncGenerator<AsyncRow>
 
+/**
+ * Executes a query plan and yields result rows
+ *
+ * @param options
+ * @param options.plan - the query plan to execute
+ * @param options.context - execution context with tables, functions, and signal
+ * @returns async generator yielding result rows
+ */
+export function executePlan(options: { plan: QueryPlan, context: ExecuteContext }): AsyncGenerator<AsyncRow>
+
 /**
  * Parses a SQL query string into an abstract syntax tree
  *
@@ -37,6 +49,16 @@ export function executeSql(options: ExecuteSqlOptions): AsyncGenerator<AsyncRow>
  */
 export function parseSql(options: ParseSqlOptions): SelectStatement
 
+/**
+ * Builds a query plan from a SQL query string or AST
+ *
+ * @param options
+ * @param options.query - SQL query string or parsed SelectStatement
+ * @param options.functions - user-defined functions available in the SQL context
+ * @returns the root of the query plan tree
+ */
+export function planSql(options: PlanSqlOptions): QueryPlan
+
 /**
  * Tokenizes a SQL query string into an array of tokens
  *
@@ -54,3 +76,12 @@ export function tokenizeSql(sql: string): Token[]
 export function collect<T>(asyncGen: AsyncGenerator<AsyncRow>): Promise<Record<string, SqlPrimitive>[]>
 
 export function cachedDataSource(source: AsyncDataSource): AsyncDataSource
+
+/**
+ * Generates a default alias for a derived column expression.
+ * Useful for generating column names pre-execution.
+ *
+ * @param expr - the expression node
+ * @returns the generated alias
+ */
+export function derivedAlias(expr: ExprNode): string

package/src/index.js

@@ -1,6 +1,7 @@
-export { executeSql } from './execute/execute.js'
+export { executePlan, executeSql } from './execute/execute.js'
 export { parseSql } from './parse/parse.js'
+export { planSql } from './plan/plan.js'
 export { tokenizeSql } from './parse/tokenize.js'
 export { collect } from './execute/utils.js'
 export { cachedDataSource } from './backend/dataSource.js'
-export { ParseError } from './parseErrors.js'
+export { derivedAlias } from './expression/alias.js'

package/src/parse/comparison.js

@@ -1,7 +1,7 @@
 import { syntaxError } from '../parseErrors.js'
 import { isBinaryOp } from '../validation.js'
 import { parseAdditive, parseExpression, parseSubquery } from './expression.js'
-import { consume, current, expect, lastPosition, match, peekToken } from './state.js'
+import { consume, current, expect, match, peekToken } from './state.js'
 
 /**
  * @import { ExprNode, ParserState } from '../types.js'
@@ -27,7 +27,7 @@ export function parseComparison(state) {
         op: 'IS NOT NULL',
         argument: left,
         positionStart: left.positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
     expect(state, 'keyword', 'NULL')
@@ -36,7 +36,7 @@ export function parseComparison(state) {
       op: 'IS NULL',
       argument: left,
       positionStart: left.positionStart,
-      positionEnd: lastPosition(state),
+      positionEnd: state.lastPos,
     }
   }
 
@@ -134,7 +134,7 @@ export function parseComparison(state) {
       if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
         // Subquery - let parseSubquery handle the parens
         const subquery = parseSubquery(state)
-        const positionEnd = lastPosition(state)
+        const positionEnd = state.lastPos
         return {
           type: 'unary',
           op: 'NOT',
@@ -158,7 +158,7 @@ export function parseComparison(state) {
           if (!match(state, 'comma')) break
         }
         expect(state, 'paren', ')')
-        const positionEnd = lastPosition(state)
+        const positionEnd = state.lastPos
         return {
           type: 'unary',
           op: 'NOT',
@@ -194,7 +194,7 @@ export function parseComparison(state) {
         expr: left,
         subquery,
         positionStart: left.positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     } else {
       // Parse list of values - we handle the parens
@@ -211,7 +211,7 @@ export function parseComparison(state) {
         expr: left,
         values,
         positionStart: left.positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
   }

package/src/parse/expression.js

@@ -8,7 +8,7 @@ import { isIntervalUnit, isKnownFunction } from '../validation.js'
 import { parseComparison } from './comparison.js'
 import { parseFunctionCall } from './functions.js'
 import { parseSelectInternal } from './parse.js'
-import { consume, current, expect, expectIdentifier, lastPosition, match, peekToken } from './state.js'
+import { consume, current, expect, expectIdentifier, match, peekToken } from './state.js'
 
 /**
  * @import { ExprNode, IntervalNode, ParserState, SelectStatement, WhenClause } from '../types.js'
@@ -40,7 +40,7 @@ export function parsePrimary(state) {
         type: 'subquery',
         subquery,
         positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
     // Regular grouped expression
@@ -66,7 +66,7 @@ export function parsePrimary(state) {
         expr,
         toType: typeTok.value,
         positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
 
@@ -96,7 +96,7 @@ export function parsePrimary(state) {
         name: tok.value,
         args: [],
         positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
 
@@ -114,7 +114,7 @@ export function parsePrimary(state) {
       type: 'identifier',
       name,
       positionStart,
-      positionEnd: lastPosition(state),
+      positionEnd: state.lastPos,
     }
   }
 
@@ -124,7 +124,7 @@ export function parsePrimary(state) {
       type: 'literal',
       value: tok.numericValue ?? null,
       positionStart,
-      positionEnd: lastPosition(state),
+      positionEnd: state.lastPos,
     }
   }
 
@@ -134,7 +134,7 @@ export function parsePrimary(state) {
       type: 'literal',
       value: tok.value,
       positionStart,
-      positionEnd: lastPosition(state),
+      positionEnd: state.lastPos,
     }
   }
 
@@ -148,15 +148,15 @@ export function parsePrimary(state) {
 
     if (tok.value === 'TRUE') {
       consume(state)
-      return { type: 'literal', value: true, positionStart, positionEnd: lastPosition(state) }
+      return { type: 'literal', value: true, positionStart, positionEnd: state.lastPos }
     }
     if (tok.value === 'FALSE') {
       consume(state)
-      return { type: 'literal', value: false, positionStart, positionEnd: lastPosition(state) }
+      return { type: 'literal', value: false, positionStart, positionEnd: state.lastPos }
     }
     if (tok.value === 'NULL') {
       consume(state)
-      return { type: 'literal', value: null, positionStart, positionEnd: lastPosition(state) }
+      return { type: 'literal', value: null, positionStart, positionEnd: state.lastPos }
     }
     if (tok.value === 'EXISTS') {
       consume(state) // EXISTS
@@ -165,7 +165,7 @@ export function parsePrimary(state) {
         type: 'exists',
         subquery,
         positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
     if (tok.value === 'CASE') {
@@ -212,7 +212,7 @@ export function parsePrimary(state) {
         whenClauses,
         elseResult,
         positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
     if (tok.value === 'INTERVAL') {
@@ -293,7 +293,7 @@ function parseNot(state) {
         type: 'not exists',
         subquery,
         positionStart,
-        positionEnd: lastPosition(state),
+        positionEnd: state.lastPos,
       }
     }
     const argument = parseNot(state)
@@ -412,5 +412,5 @@ function parseInterval(state) {
   }
   consume(state)
 
-  return { type: 'interval', value, unit: unitTok.value, positionStart, positionEnd: lastPosition(state) }
+  return { type: 'interval', value, unit: unitTok.value, positionStart, positionEnd: state.lastPos }
 }

package/src/parse/functions.js

@@ -1,7 +1,7 @@
-import { argCountParseError, syntaxError } from '../parseErrors.js'
+import { ParseError, argCountParseError, syntaxError } from '../parseErrors.js'
 import { isAggregateFunc, validateFunctionArgCount } from '../validation.js'
 import { parseExpression } from './expression.js'
-import { consume, current, expect, lastPosition, match } from './state.js'
+import { consume, current, expect, match } from './state.js'
 
 /**
  * @import { ExprNode, ParserState } from '../types.js'
@@ -41,7 +41,7 @@ export function parseFunctionCall(state, funcName, positionStart) {
           type: 'identifier',
           name: '*',
           positionStart: starTok.positionStart,
-          positionEnd: lastPosition(state),
+          positionEnd: state.lastPos,
         })
       } else {
         args.push(parseExpression(state))
@@ -72,8 +72,25 @@ export function parseFunctionCall(state, funcName, positionStart) {
     expect(state, 'paren', ')')
   }
 
-  // Validate argument count at parse time
+  // Validate star argument at parse time (only COUNT supports *)
   const funcNameUpper = funcName.toUpperCase()
+  const hasStar = args.length === 1 && args[0].type === 'identifier' && args[0].name === '*'
+  if (hasStar && isAggregateFunc(funcNameUpper) && funcNameUpper !== 'COUNT') {
+    throw new ParseError({
+      message: `${funcName} cannot be applied to "*"`,
+      positionStart,
+      positionEnd: state.lastPos,
+    })
+  }
+  if (hasStar && distinct) {
+    throw new ParseError({
+      message: 'COUNT(DISTINCT *) is not allowed',
+      positionStart,
+      positionEnd: state.lastPos,
+    })
+  }
+
+  // Validate argument count at parse time
   const validation = validateFunctionArgCount(funcNameUpper, args.length, state.functions)
   if (!validation.valid) {
     throw argCountParseError({
@@ -81,7 +98,7 @@ export function parseFunctionCall(state, funcName, positionStart) {
       expected: validation.expected,
       received: args.length,
       positionStart,
-      positionEnd: lastPosition(state),
+      positionEnd: state.lastPos,
     })
   }
 
@@ -92,6 +109,6 @@ export function parseFunctionCall(state, funcName, positionStart) {
     distinct: distinct || undefined,
     filter,
     positionStart,
-    positionEnd: lastPosition(state),
+    positionEnd: state.lastPos,
   }
 }