squirreling 0.7.9 → 0.8.0

package/src/execute/having.js

@@ -1,202 +0,0 @@
-import { unknownFunctionError } from '../parseErrors.js'
-import { isAggregateFunc } from '../validation.js'
-import { evaluateExpr } from './expression.js'
-import { applyBinaryOp } from './utils.js'
-
-/**
- * @import { AggregateFunc, AsyncDataSource, ExprNode, AsyncRow, SqlPrimitive, UserDefinedFunction } from '../types.js'
- */
-
-/**
- * Evaluates a HAVING expression with support for aggregate functions
- *
- * @param {Object} options
- * @param {ExprNode} options.expr - the HAVING expression
- * @param {AsyncRow} options.row - the aggregated result row
- * @param {AsyncRow[]} options.group - the group of rows for re-evaluating aggregates
- * @param {Record<string, AsyncDataSource>} options.tables
- * @param {Record<string, UserDefinedFunction>} [options.functions]
- * @returns {Promise<boolean>} whether the HAVING condition is satisfied
- */
-export async function evaluateHavingExpr({ expr, row, group, tables, functions }) {
-  // Having context
-  const context = { ...group[0], ...row }
-
-  // For HAVING, we need special handling of aggregate functions
-  // They need to be re-evaluated against the group
-  if (expr.type === 'function') {
-    const funcName = expr.name.toUpperCase()
-    if (isAggregateFunc(funcName)) {
-      // Evaluate aggregate function on the group
-      return Boolean(await evaluateAggregateFunction({ funcName, args: expr.args, filter: expr.filter, group, tables, functions }))
-    }
-  }
-
-  if (expr.type === 'binary') {
-    const left = await evaluateHavingValue({ expr: expr.left, context, group, tables, functions })
-
-    // Short-circuit evaluation for AND and OR
-    if (expr.op === 'AND') {
-      if (!left) return false
-    }
-    if (expr.op === 'OR') {
-      if (left) return true
-    }
-
-    const right = await evaluateHavingValue({ expr: expr.right, context, group, tables, functions })
-    return Boolean(applyBinaryOp(expr.op, left, right))
-  }
-
-  if (expr.type === 'unary') {
-    if (expr.op === 'NOT') {
-      return !await evaluateHavingExpr({ expr: expr.argument, row: context, group, tables, functions })
-    }
-    if (expr.op === 'IS NULL') {
-      return await evaluateHavingValue({ expr: expr.argument, context, group, tables, functions }) == null
-    }
-    if (expr.op === 'IS NOT NULL') {
-      return await evaluateHavingValue({ expr: expr.argument, context, group, tables, functions }) != null
-    }
-  }
-
-  // For other expression types, use the context row
-  return Boolean(await evaluateExpr({ node: expr, row: context, tables, functions }))
-}
-
-/**
- * Evaluates a value in a HAVING expression
- *
- * @param {Object} options
- * @param {ExprNode} options.expr
- * @param {AsyncRow} options.context - the context row
- * @param {AsyncRow[]} options.group - the group of rows
- * @param {Record<string, AsyncDataSource>} options.tables
- * @param {Record<string, UserDefinedFunction>} [options.functions]
- * @returns {Promise<SqlPrimitive>} the evaluated value
- */
-function evaluateHavingValue({ expr, context, group, tables, functions }) {
-  if (expr.type === 'function') {
-    const funcName = expr.name.toUpperCase()
-    if (isAggregateFunc(funcName)) {
-      return evaluateAggregateFunction({ funcName, args: expr.args, filter: expr.filter, group, tables, functions })
-    }
-  }
-
-  // For binary expressions, we need to use evaluateHavingExpr to properly handle aggregates
-  if (expr.type === 'binary' || expr.type === 'unary') {
-    return evaluateHavingExpr({ expr, row: context, group, tables, functions })
-  }
-
-  return evaluateExpr({ node: expr, row: context, tables, functions })
-}
-
-/**
- * Evaluates an aggregate function on a group
- *
- * @param {Object} options
- * @param {AggregateFunc} options.funcName - aggregate function name
- * @param {ExprNode[]} options.args - function arguments
- * @param {ExprNode} [options.filter] - optional FILTER clause expression
- * @param {AsyncRow[]} options.group - the group of rows
- * @param {Record<string, AsyncDataSource>} options.tables
- * @param {Record<string, UserDefinedFunction>} [options.functions]
- * @returns {Promise<SqlPrimitive>} the aggregate result
- */
-async function evaluateAggregateFunction({ funcName, args, filter, group, tables, functions }) {
-  // Apply FILTER clause if present
-  let filteredGroup = group
-  if (filter) {
-    filteredGroup = []
-    for (const row of group) {
-      const passes = await evaluateExpr({ node: filter, row, tables, functions })
-      if (passes) filteredGroup.push(row)
-    }
-  }
-
-  if (funcName === 'COUNT') {
-    if (args.length === 1 && args[0].type === 'identifier' && args[0].name === '*') {
-      return filteredGroup.length
-    }
-    // COUNT(column) - count non-null values
-    let count = 0
-    for (const row of filteredGroup) {
-      const val = await evaluateExpr({ node: args[0], row, tables, functions })
-      if (val != null) count++
-    }
-    return count
-  }
-
-  if (funcName === 'SUM') {
-    let sum = 0
-    let hasValue = false
-    for (const row of filteredGroup) {
-      const val = await evaluateExpr({ node: args[0], row, tables, functions })
-      if (val != null) {
-        sum += Number(val)
-        hasValue = true
-      }
-    }
-    return hasValue ? sum : null
-  }
-
-  if (funcName === 'AVG') {
-    let sum = 0
-    let count = 0
-    for (const row of filteredGroup) {
-      const val = await evaluateExpr({ node: args[0], row, tables, functions })
-      if (val != null) {
-        sum += Number(val)
-        count++
-      }
-    }
-    return count > 0 ? sum / count : null
-  }
-
-  if (funcName === 'MIN') {
-    let min = null
-    for (const row of filteredGroup) {
-      const val = await evaluateExpr({ node: args[0], row, tables, functions })
-      if (val != null && (min == null || val < min)) {
-        min = val
-      }
-    }
-    return min
-  }
-
-  if (funcName === 'MAX') {
-    let max = null
-    for (const row of filteredGroup) {
-      const val = await evaluateExpr({ node: args[0], row, tables, functions })
-      if (val != null && (max == null || val > max)) {
-        max = val
-      }
-    }
-    return max
-  }
-
-  if (funcName === 'STDDEV_SAMP' || funcName === 'STDDEV_POP') {
-    const values = []
-    for (const row of filteredGroup) {
-      const val = await evaluateExpr({ node: args[0], row, tables, functions })
-      if (val == null) continue
-      const num = Number(val)
-      if (!Number.isFinite(num)) continue
-      values.push(num)
-    }
-    const n = values.length
-    if (n === 0) return null
-    if (funcName === 'STDDEV_SAMP' && n === 1) return null
-
-    const mean = values.reduce((a, b) => a + b, 0) / n
-    const squaredDiffs = values.reduce((acc, val) => acc + (val - mean) ** 2, 0)
-    const divisor = funcName === 'STDDEV_SAMP' ? n - 1 : n
-    return Math.sqrt(squaredDiffs / divisor)
-  }
-
-  throw unknownFunctionError({
-    funcName,
-    positionStart: 0,
-    positionEnd: 0,
-    validFunctions: 'COUNT, SUM, AVG, MIN, MAX, STDDEV_SAMP, STDDEV_POP',
-  })
-}

package/src/execute/tableSource.js

@@ -1,63 +0,0 @@
-import { tableNotFoundError } from '../executionErrors.js'
-import { generatorSource } from '../backend/dataSource.js'
-
-/**
- * @import { AsyncDataSource, CTEDefinition, UserDefinedFunction, WithClause } from '../types.js'
- */
-
-/**
- * Gets CTEs defined before the target CTE (excluding the target itself).
- * Enforces SQL scoping rules: each CTE can only reference CTEs defined before it.
- *
- * @param {CTEDefinition[]} allCtes - all CTE definitions in order
- * @param {string} targetCteName - the CTE name (case-insensitive)
- * @returns {WithClause} CTEs available to the target
- */
-export function getCtesDefinedBefore(allCtes, targetCteName) {
-  const available = []
-  for (const cte of allCtes) {
-    if (cte.name.toLowerCase() === targetCteName) break
-    available.push(cte)
-  }
-  return { ctes: available }
-}
-
-/**
- * Resolves a table name to an AsyncDataSource, checking CTEs first
- *
- * @param {string} tableName - the table name to resolve
- * @param {Record<string, AsyncDataSource>} tables - regular tables
- * @param {import('../types.js').WithClause} [withClause] - WITH clause containing CTE definitions
- * @param {Function} [executeSelectFn] - function to execute SELECT for CTEs
- * @param {Record<string, UserDefinedFunction>} [functions]
- * @param {AbortSignal} [signal]
- * @returns {AsyncDataSource}
- */
-export function resolveTableSource(tableName, tables, withClause, executeSelectFn, functions, signal) {
-  // Check CTEs first (case-insensitive) - only build map when CTE is actually found
-  if (withClause && executeSelectFn) {
-    const lowerName = tableName.toLowerCase()
-    const cte = withClause.ctes.find(c => c.name.toLowerCase() === lowerName)
-
-    if (cte) {
-      // CTE reference: wrap in generatorSource, re-execute each time (streaming)
-      // Pass only CTEs defined before this one to prevent self-reference
-      const availableCtes = getCtesDefinedBefore(withClause.ctes, lowerName)
-
-      return generatorSource(executeSelectFn({
-        select: cte.query,
-        tables,
-        withClause: availableCtes,
-        functions,
-        signal,
-      }))
-    }
-  }
-
-  // Regular table lookup
-  const tableSource = tables[tableName]
-  if (tableSource === undefined) {
-    throw tableNotFoundError({ tableName })
-  }
-  return tableSource
-}