squirreling 0.12.13 → 0.12.15

package/README.md

@@ -154,13 +154,13 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 
 ### Functions
 
-- Aggregate: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `MEDIAN`, `PERCENTILE_CONT`, `APPROX_QUANTILE`, `STDDEV_POP`, `STDDEV_SAMP`, `ARRAY_AGG`, `JSON_ARRAYAGG`, `STRING_AGG`
+- Aggregate: `COUNT`, `COUNTIF`, `SUM`, `AVG`, `MIN`, `MAX`, `MEDIAN`, `PERCENTILE_CONT`, `APPROX_QUANTILE`, `STDDEV_POP`, `STDDEV_SAMP`, `ARRAY_AGG`, `JSON_ARRAYAGG`, `STRING_AGG`
 - String: `CONCAT`, `SUBSTRING`, `REPLACE`, `LENGTH`, `UPPER`, `LOWER`, `TRIM`, `LEFT`, `RIGHT`, `INSTR`, `POSITION`, `STRPOS`
 - Math: `ABS`, `SIGN`, `CEIL`, `FLOOR`, `ROUND`, `MOD`, `RAND`, `RANDOM`, `LN`, `LOG10`, `EXP`, `POWER`, `SQRT`
 - Trig: `SIN`, `COS`, `TAN`, `COT`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`, `DEGREES`, `RADIANS`, `PI`
 - Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `DATE_PART`, `DATE_TRUNC`, `EXTRACT`, `INTERVAL`
 - Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_EXTRACT`, `JSON_OBJECT`, `JSON_ARRAY_LENGTH`, `JSON_VALID`, `JSON_TYPE`
-- Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_SORT`, `CARDINALITY`
+- Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_CONTAINS`, `ARRAY_SORT`, `CARDINALITY`, `SIZE`
 - Table functions: `UNNEST`, `EXPLODE`, `JSON_EACH`
 - Regex: `REGEXP_SUBSTR`, `REGEXP_EXTRACT`, `REGEXP_REPLACE`, `REGEXP_MATCHES`
 - Spatial: `ST_GeomFromText`, `ST_MakeEnvelope`, `ST_AsText`, `ST_Intersects`, `ST_Contains`, `ST_ContainsProperly`, `ST_Within`, `ST_Overlaps`, `ST_Touches`, `ST_Equals`, `ST_Crosses`, `ST_Covers`, `ST_CoveredBy`, `ST_DWithin`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.13",
+  "version": "0.12.15",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -41,7 +41,7 @@
   "devDependencies": {
     "@types/node": "25.6.0",
     "@vitest/coverage-v8": "4.1.5",
-    "eslint": "9.39.2",
+    "eslint": "9.39.4",
     "eslint-plugin-jsdoc": "62.9.0",
     "typescript": "6.0.3",
     "vitest": "4.1.5"

package/src/expression/evaluate.js

@@ -62,6 +62,14 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       if (context.outerRow && context.outerAliases?.has(node.prefix) && node.name in context.outerRow.cells) {
         return context.outerRow.cells[node.name]()
       }
+      // Standalone `FROM UNNEST(...) AS alias` row has a single bare column;
+      // `alias.field` should struct-access that column's element.
+      if (context.scope?.includes(node.prefix) && row.columns.length === 1) {
+        const value = await row.cells[row.columns[0]]()
+        if (isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, node.name)) {
+          return value[node.name]
+        }
+      }
       // Fall back to just the column part
       if (node.name in row.cells) {
         return row.cells[node.name]()
@@ -200,6 +208,17 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         return count
       }
 
+      if (funcName === 'COUNTIF') {
+        const values = await Promise.all(filteredRows.map(row =>
+          evaluateExpr({ node: argNode, row, context })
+        ))
+        let count = 0
+        for (const v of values) {
+          if (v) count++
+        }
+        return count
+      }
+
       if (funcName === 'SUM' || funcName === 'AVG' || funcName === 'MIN' || funcName === 'MAX') {
         const rawValues = await Promise.all(filteredRows.map(row =>
           evaluateExpr({ node: argNode, row, context })
@@ -489,7 +508,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return arr.length
     }
 
-    if (funcName === 'ARRAY_LENGTH' || funcName === 'CARDINALITY') {
+    if (funcName === 'ARRAY_LENGTH' || funcName === 'CARDINALITY' || funcName === 'SIZE') {
       const arr = args[0]
       if (!Array.isArray(arr)) return null
       if (funcName === 'ARRAY_LENGTH' && args.length === 2) {
@@ -519,6 +538,12 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return index === -1 ? null : index + 1
     }
 
+    if (funcName === 'ARRAY_CONTAINS') {
+      const [arr, target] = args
+      if (!Array.isArray(arr)) return null
+      return arr.includes(target)
+    }
+
     if (funcName === 'ARRAY_SORT') {
       const arr = args[0]
       if (!Array.isArray(arr)) return null
@@ -650,13 +675,15 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   }
 
   // EXISTS and NOT EXISTS with subqueries
-  if (node.type === 'exists') {
-    const results = await executeStatement({ query: node.subquery, context }).rows().next()
-    return results.done === false
-  }
-  if (node.type === 'not exists') {
-    const results = await executeStatement({ query: node.subquery, context }).rows().next()
-    return results.done === true
+  if (node.type === 'exists' || node.type === 'not exists') {
+    const outerScope = context.scope
+    const subContext = outerScope
+      ? { ...context, outerRow: row, outerAliases: new Set(outerScope) }
+      : context
+    const gen = executeStatement({ query: node.subquery, context: subContext, outerScope }).rows()
+    const results = await gen.next()
+    gen.return(undefined)
+    return node.type === 'exists' ? results.done === false : results.done === true
   }
 
   // CASE expressions

package/src/plan/columns.js

@@ -268,6 +268,11 @@ function collectColumnsFromExpr(expr, columns, aliases) {
       for (const id of inner) {
         if (id.prefix) columns.push(id)
       }
+      // FROM-function args (e.g. UNNEST in the subquery's FROM) are evaluated
+      // against the outer scope — the table function is itself the FROM, so
+      // any identifier inside its args must be correlated. Push them even if
+      // unprefixed so the outer scan reads the columns they reference.
+      collectFromFunctionArgs(sub, columns)
     }
   }
   // No columns: count(*), literal, interval
@@ -309,6 +314,33 @@ function collectColumnsFromStatement(stmt, columns) {
   for (const item of stmt.orderBy) collectColumnsFromExpr(item.expr, columns)
 }
 
+/**
+ * Walks a subquery statement and collects identifiers from FROM-function args
+ * (e.g. UNNEST(col) in FROM). These identifiers are necessarily correlated
+ * outer references because the table function is the only source.
+ *
+ * @param {Statement} stmt
+ * @param {IdentifierNode[]} columns
+ */
+function collectFromFunctionArgs(stmt, columns) {
+  if (stmt.type === 'compound') {
+    collectFromFunctionArgs(stmt.left, columns)
+    collectFromFunctionArgs(stmt.right, columns)
+    return
+  }
+  if (stmt.type === 'with') {
+    collectFromFunctionArgs(stmt.query, columns)
+    return
+  }
+  if (stmt.from?.type === 'function') {
+    for (const arg of stmt.from.args) {
+      collectColumnsFromExpr(arg, columns)
+    }
+  } else if (stmt.from?.type === 'subquery') {
+    collectFromFunctionArgs(stmt.from.query, columns)
+  }
+}
+
 /**
  * Infers output columns for set-operation validation.
  *

package/src/plan/plan.js

@@ -343,7 +343,7 @@ function planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope }) {
     return { type: 'Scan', table: select.from.table, hints }
   } else if (select.from.type === 'function') {
     for (const arg of select.from.args) {
-      validateNoIdentifiers(arg, select.from.funcName)
+      validateNoIdentifiers(arg, select.from.funcName, outerScope)
     }
     return planTableFunction(select.from)
   } else {

package/src/types.d.ts

@@ -129,7 +129,7 @@ export interface UserDefinedFunction {
   arguments: FunctionSignature
 }
 
-export type AggregateFunc = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'ARRAY_AGG' | 'JSON_ARRAYAGG' | 'STDDEV_SAMP' | 'STDDEV_POP' | 'MEDIAN' | 'PERCENTILE_CONT' | 'APPROX_QUANTILE' | 'STRING_AGG'
+export type AggregateFunc = 'COUNT' | 'COUNTIF' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'ARRAY_AGG' | 'JSON_ARRAYAGG' | 'STDDEV_SAMP' | 'STDDEV_POP' | 'MEDIAN' | 'PERCENTILE_CONT' | 'APPROX_QUANTILE' | 'STRING_AGG'
 
 export type RegExpFunction = 'REGEXP_SUBSTR' | 'REGEXP_EXTRACT' | 'REGEXP_REPLACE' | 'REGEXP_MATCHES'
 

package/src/validation/functions.js

@@ -11,7 +11,7 @@ export const niladicFuncs = ['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP'
  * @returns {name is AggregateFunc}
  */
 export function isAggregateFunc(name) {
-  return ['COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'ARRAY_AGG', 'JSON_ARRAYAGG', 'STDDEV_SAMP', 'STDDEV_POP', 'MEDIAN', 'PERCENTILE_CONT', 'APPROX_QUANTILE', 'STRING_AGG'].includes(name)
+  return ['COUNT', 'COUNTIF', 'SUM', 'AVG', 'MIN', 'MAX', 'ARRAY_AGG', 'JSON_ARRAYAGG', 'STDDEV_SAMP', 'STDDEV_POP', 'MEDIAN', 'PERCENTILE_CONT', 'APPROX_QUANTILE', 'STRING_AGG'].includes(name)
 }
 
 /**
@@ -182,8 +182,10 @@ export const FUNCTION_SIGNATURES = {
   // Array functions
   ARRAY_LENGTH: { min: 1, max: 2, signature: 'array[, dimension]' },
   ARRAY_POSITION: { min: 2, max: 2, signature: 'array, element' },
+  ARRAY_CONTAINS: { min: 2, max: 2, signature: 'array, element' },
   ARRAY_SORT: { min: 1, max: 1, signature: 'array' },
   CARDINALITY: { min: 1, max: 1, signature: 'array' },
+  SIZE: { min: 1, max: 1, signature: 'array' },
 
   // Table functions (used in FROM clause)
   UNNEST: { min: 1, max: 1, signature: 'array' },
@@ -198,6 +200,7 @@ export const FUNCTION_SIGNATURES = {
 
   // Aggregate functions
   COUNT: { min: 1, max: 1, signature: 'expression' },
+  COUNTIF: { min: 1, max: 1, signature: 'condition' },
   SUM: { min: 1, max: 1, signature: 'expression' },
   AVG: { min: 1, max: 1, signature: 'expression' },
   MIN: { min: 1, max: 1, signature: 'expression' },

package/src/validation/tables.js

@@ -48,13 +48,22 @@ export function validateScan({ table, hints, tables, positionStart, positionEnd
 /**
  * Throws if the expression references any column identifier. Used for
  * expressions that have no row scope (e.g. table function arguments in FROM).
+ * When `outerScope` is provided, identifiers that resolve to an outer query's
+ * alias (correlated reference) are allowed — they will be evaluated against
+ * the outer row at runtime.
  *
  * @param {ExprNode} expr
  * @param {string} context - context for the error message (e.g. function name)
+ * @param {string[]} [outerScope] - aliases of outer queries
  */
-export function validateNoIdentifiers(expr, context) {
+export function validateNoIdentifiers(expr, context, outerScope) {
   if (!expr) return
   if (expr.type === 'identifier') {
+    if (outerScope?.length) {
+      // Correlated reference: prefix matches an outer alias, or unqualified
+      // (resolved against the outer row at runtime).
+      if (!expr.prefix || outerScope.includes(expr.prefix)) return
+    }
     const name = expr.prefix ? `${expr.prefix}.${expr.name}` : expr.name
     throw new ExecutionError({
       message: `${context} argument cannot reference column "${name}" — use JOIN ${context}(...) to reference columns from another table`,
@@ -63,31 +72,31 @@ export function validateNoIdentifiers(expr, context) {
     })
   }
   if (expr.type === 'binary') {
-    validateNoIdentifiers(expr.left, context)
-    validateNoIdentifiers(expr.right, context)
+    validateNoIdentifiers(expr.left, context, outerScope)
+    validateNoIdentifiers(expr.right, context, outerScope)
   } else if (expr.type === 'unary') {
-    validateNoIdentifiers(expr.argument, context)
+    validateNoIdentifiers(expr.argument, context, outerScope)
   } else if (expr.type === 'function') {
     for (const arg of expr.args) {
-      validateNoIdentifiers(arg, context)
+      validateNoIdentifiers(arg, context, outerScope)
     }
   } else if (expr.type === 'cast') {
-    validateNoIdentifiers(expr.expr, context)
+    validateNoIdentifiers(expr.expr, context, outerScope)
   } else if (expr.type === 'in valuelist') {
-    validateNoIdentifiers(expr.expr, context)
+    validateNoIdentifiers(expr.expr, context, outerScope)
     for (const val of expr.values) {
-      validateNoIdentifiers(val, context)
+      validateNoIdentifiers(val, context, outerScope)
     }
   } else if (expr.type === 'in') {
     // LHS is in our scope; subquery is self-contained and planned separately.
-    validateNoIdentifiers(expr.expr, context)
+    validateNoIdentifiers(expr.expr, context, outerScope)
   } else if (expr.type === 'case') {
-    validateNoIdentifiers(expr.caseExpr, context)
+    validateNoIdentifiers(expr.caseExpr, context, outerScope)
     for (const w of expr.whenClauses) {
-      validateNoIdentifiers(w.condition, context)
-      validateNoIdentifiers(w.result, context)
+      validateNoIdentifiers(w.condition, context, outerScope)
+      validateNoIdentifiers(w.result, context, outerScope)
     }
-    validateNoIdentifiers(expr.elseResult, context)
+    validateNoIdentifiers(expr.elseResult, context, outerScope)
   }
   // subquery / exists / not exists are self-contained — their identifiers
   // resolve to their own FROM and are validated when the subquery is planned.