squirreling 0.16.4 → 0.16.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.16.4",
+  "version": "0.16.6",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -40,12 +40,12 @@
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@types/node": "26.4.1",
-    "@vitest/coverage-v8": "5.0.0",
+    "@types/node": "26.5.0",
+    "@vitest/coverage-v8": "5.0.1",
     "eslint": "10.10.0",
-    "eslint-plugin-jsdoc": "64.3.6",
+    "eslint-plugin-jsdoc": "64.5.2",
     "globals": "17.12.0",
     "typescript": "7.0.2",
-    "vitest": "5.0.0"
+    "vitest": "5.0.1"
   }
 }

package/src/expression/batch.js

@@ -206,6 +206,31 @@ function compileValueKernel(node, state) {
     }
   }
 
+  if (node.type === 'in valuelist') {
+    // Later list entries are conditional reads. Keep those on the row path
+    // until they have a selection-aware evaluator, just like lazy functions.
+    if (node.values.some(readsIdentifier)) return undefined
+    const argument = compileValueKernel(node.expr, state)
+    if (!argument) return undefined
+    /** @type {ValueKernel[]} */
+    const values = []
+    for (const valueNode of node.values) {
+      const value = compileValueKernel(valueNode, state)
+      if (!value) return undefined
+      values.push(value)
+    }
+    return function inValue(vectors, rowIndex, streamRowIndex) {
+      const input = argument(vectors, rowIndex, streamRowIndex)
+      let sawNull = input == null
+      for (const value of values) {
+        const candidate = value(vectors, rowIndex, streamRowIndex)
+        if (candidate == null) sawNull = true
+        else if (input != null && sqlEquals(input, candidate)) return true
+      }
+      return sawNull ? null : false
+    }
+  }
+
   if (node.type === 'cast') {
     const argument = compileValueKernel(node.expr, state)
     if (!argument) return undefined
@@ -652,6 +677,7 @@ function readsIdentifier(node) {
   if (node.type === 'unary') return readsIdentifier(node.argument)
   if (node.type === 'binary') return readsIdentifier(node.left) || readsIdentifier(node.right)
   if (node.type === 'cast') return readsIdentifier(node.expr)
+  if (node.type === 'in valuelist') return readsIdentifier(node.expr) || node.values.some(readsIdentifier)
   if (node.type === 'function') return node.args.some(readsIdentifier)
   return false
 }

package/src/plan/plan.js

@@ -1,3 +1,4 @@
+import { dataSourceColumns } from '../backend/dataSource.js'
 import { derivedAlias } from '../expression/alias.js'
 import { parseSql } from '../parse/parse.js'
 import { findAggregate } from '../validation/aggregates.js'
@@ -238,6 +239,7 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
   /** @type {QueryPlan} */
   let plan = planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope })
   pruneAggregateColumns(plan, subqueryNeeds)
+  const directFrom = plan.type === 'Scan' && plan.hints === hints
 
   // Add JOINs
   if (select.joins.length) {
@@ -248,8 +250,13 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
   const isOwnScan = plan.type === 'Scan' && plan.hints === hints
 
   // Add WHERE filter when the scan didn't receive it
-  if (select.where && !isOwnScan) {
-    plan = { type: 'Filter', condition: select.where, child: plan }
+  let { where } = select
+  if (directFrom && select.joins.length === 1 && !outerScope?.length &&
+      !ctePlans?.has(select.joins[0].table?.toLowerCase())) {
+    where = pushJoinPredicates(plan, where, tables)
+  }
+  if (where && !isOwnScan) {
+    plan = { type: 'Filter', condition: where, child: plan }
   }
 
   if (useGrouping) {
@@ -826,6 +833,109 @@ function collectConjuncts(node, out) {
   out.push(node)
 }
 
+/**
+ * Push total, table-local comparisons into fresh scans of a direct INNER
+ * equijoin. Scan execution already enforces hints a source cannot apply.
+ * Validate ON before moving anything; an unsafe ON also blocks WHERE
+ * pushdown. Safe ON terms can move even when WHERE must remain above the
+ * join, since ON already excludes those pairs before WHERE is evaluated.
+ *
+ * @param {QueryPlan} plan
+ * @param {ExprNode | undefined} where
+ * @param {Record<string, AsyncDataSource>} [tables]
+ * @returns {ExprNode | undefined}
+ */
+function pushJoinPredicates(plan, where, tables) {
+  if (!tables || plan.type !== 'HashJoin' || plan.joinType !== 'INNER' ||
+      plan.left.type !== 'Scan' || plan.right.type !== 'Scan') return where
+  const scans = [plan.left, plan.right]
+  if (scans.some(scan => scan.hints.where || scan.hints.limit !== undefined || scan.hints.offset)) return where
+  const aliases = scans.map(scan => scan.alias ?? scan.table)
+  if (aliases[0] === aliases[1]) return where
+  const columns = scans.map(scan => dataSourceColumns(tables[scan.table]))
+  // A prefix that also names a struct column is not an unambiguous alias.
+  if (columns.some(names => aliases.some(alias => names.includes(alias)))) return where
+
+  /**
+   * @param {ExprNode} expr
+   * @returns {'left' | 'right' | 'literal' | 'unsafe'}
+   */
+  function owner(expr) {
+    if (expr.type === 'literal') return 'literal'
+    if (expr.type !== 'identifier' || !expr.prefix) return 'unsafe'
+    const index = aliases.indexOf(expr.prefix)
+    if (index < 0 || !columns[index].includes(expr.name)) return 'unsafe'
+    return index === 0 ? 'left' : 'right'
+  }
+
+  // Avoid changing the evaluation of unresolved or unqualified ON keys.
+  if (plan.leftKeys.some(key => owner(key) !== 'left') || plan.rightKeys.some(key => owner(key) !== 'right')) return where
+  /**
+   * @param {ExprNode[]} conjuncts
+   * @returns {Array<'left' | 'right' | 'residual'> | undefined}
+   */
+  function classify(conjuncts) {
+    /** @type {Array<'left' | 'right' | 'residual'>} */
+    const targets = []
+    for (const expr of conjuncts) {
+      if (expr.type !== 'binary' || !['=', '==', '!=', '<>', '<', '<=', '>', '>='].includes(expr.op)) return undefined
+      const left = owner(expr.left)
+      const right = owner(expr.right)
+      if (left === 'unsafe' || right === 'unsafe') return undefined
+      // Only column/literal terms move; cross-table comparisons remain residual.
+      targets.push(left !== 'literal' && right === 'literal' ? left : right !== 'literal' && left === 'literal' ? right : 'residual')
+    }
+    return targets
+  }
+
+  /**
+   * @param {ExprNode[]} conjuncts
+   * @param {Array<'left' | 'right' | 'residual'>} targets
+   * @returns {ExprNode | undefined}
+   */
+  function push(conjuncts, targets) {
+    /** @type {ExprNode | undefined} */
+    let residual
+    for (let i = 0; i < conjuncts.length; i++) {
+      const target = targets[i]
+      if (target === 'residual') {
+        residual = andPredicate(residual, conjuncts[i])
+      } else {
+        const scan = target === 'left' ? scans[0] : scans[1]
+        scan.hints = { ...scan.hints, where: andPredicate(scan.hints.where, conjuncts[i]) }
+      }
+    }
+    return residual
+  }
+
+  /** @type {ExprNode[]} */
+  const onConjuncts = []
+  if (plan.residual) collectConjuncts(plan.residual, onConjuncts)
+  const onTargets = classify(onConjuncts)
+  if (!onTargets) return where
+  const onResidual = push(onConjuncts, onTargets)
+  if (onResidual) plan.residual = onResidual
+  else delete plan.residual
+
+  if (!where) return undefined
+  /** @type {ExprNode[]} */
+  const whereConjuncts = []
+  collectConjuncts(where, whereConjuncts)
+  const whereTargets = classify(whereConjuncts)
+  return whereTargets ? push(whereConjuncts, whereTargets) : where
+}
+
+/**
+ * @param {ExprNode | undefined} left
+ * @param {ExprNode} right
+ * @returns {ExprNode}
+ */
+function andPredicate(left, right) {
+  return left
+    ? { type: 'binary', op: 'AND', left, right, positionStart: left.positionStart, positionEnd: right.positionEnd }
+    : right
+}
+
 /**
  * Returns the (leftKey, rightKey) pair for an equi conjunct, oriented so
  * leftKey references the left input and rightKey references the right input.