squirreling 0.10.2 → 0.11.0

package/README.md

@@ -137,6 +137,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - Subqueries in `SELECT`, `FROM`, and `WHERE` clauses
 - `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`, `CROSS JOIN`, `POSITIONAL JOIN`
 - `GROUP BY` and `HAVING` clauses
+- Set operations: `UNION`, `UNION ALL`, `INTERSECT`, `INTERSECT ALL`, `EXCEPT`, `EXCEPT ALL`
 - Expressions: `CASE`, `CAST`, `BETWEEN`, `IN`, `LIKE`, `IS NULL`, `IS NOT NULL`
 
 ### Quoting
@@ -147,14 +148,14 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 
 ### Functions
 
-- Aggregate: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `STDDEV_POP`, `STDDEV_SAMP`, `JSON_ARRAYAGG`
-- String: `CONCAT`, `SUBSTRING`, `REPLACE`, `LENGTH`, `UPPER`, `LOWER`, `TRIM`, `LEFT`, `RIGHT`, `INSTR`
+- Aggregate: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `MEDIAN`, `PERCENTILE_CONT`, `APPROX_QUANTILE`, `STDDEV_POP`, `STDDEV_SAMP`, `JSON_ARRAYAGG`
+- 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_OBJECT`
+- Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_EXTRACT`, `JSON_OBJECT`
 - Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_SORT`, `CARDINALITY`
-- Regex: `REGEXP_SUBSTR`, `REGEXP_REPLACE`
+- Regex: `REGEXP_SUBSTR`, `REGEXP_EXTRACT`, `REGEXP_REPLACE`
 - 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`
 - Conditional: `COALESCE`, `NULLIF`
 - User-defined functions (UDFs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -40,10 +40,10 @@
   },
   "devDependencies": {
     "@types/node": "25.5.0",
-    "@vitest/coverage-v8": "4.1.0",
+    "@vitest/coverage-v8": "4.1.2",
     "eslint": "9.39.2",
-    "eslint-plugin-jsdoc": "62.8.0",
-    "typescript": "5.9.3",
-    "vitest": "4.1.0"
+    "eslint-plugin-jsdoc": "62.8.1",
+    "typescript": "6.0.2",
+    "vitest": "4.1.2"
   }
 }

package/src/ast.d.ts

@@ -8,8 +8,8 @@ export type SqlPrimitive =
   | SqlPrimitive[]
   | Record<string, any>
 
-export interface SelectStatement {
-  with?: WithClause
+export interface SelectStatement extends AstBase {
+  type: 'select'
   distinct: boolean
   columns: SelectColumn[]
   from: FromTable | FromSubquery
@@ -22,25 +22,42 @@ export interface SelectStatement {
   offset?: number
 }
 
-export interface WithClause {
+export type SetOperator = 'UNION' | 'INTERSECT' | 'EXCEPT'
+
+export interface SetOperationStatement extends AstBase {
+  type: 'compound'
+  operator: SetOperator
+  all: boolean
+  left: Statement
+  right: Statement
+  orderBy: OrderByItem[]
+  limit?: number
+  offset?: number
+}
+
+export interface WithStatement extends AstBase {
+  type: 'with'
   ctes: CTEDefinition[]
+  query: Statement
 }
 
-export interface CTEDefinition {
+export type Statement = SelectStatement | SetOperationStatement | WithStatement
+
+export interface CTEDefinition extends AstBase {
   name: string
-  query: SelectStatement
+  query: Statement
 }
 
 export interface FromTable extends AstBase {
-  kind: 'table'
+  type: 'table'
   table: string
   alias?: string
 }
 
-export interface FromSubquery {
-  kind: 'subquery'
-  query: SelectStatement
-  alias: string
+export interface FromSubquery extends AstBase {
+  type: 'subquery'
+  query: Statement
+  alias?: string
 }
 
 export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
@@ -91,7 +108,7 @@ export interface CastNode extends AstBase {
 export interface InSubqueryNode extends AstBase {
   type: 'in'
   expr: ExprNode
-  subquery: SelectStatement
+  subquery: Statement
 }
 
 export interface InValuesNode extends AstBase {
@@ -102,7 +119,7 @@ export interface InValuesNode extends AstBase {
 
 export interface ExistsNode extends AstBase {
   type: 'exists' | 'not exists'
-  subquery: SelectStatement
+  subquery: Statement
 }
 
 export interface WhenClause extends AstBase {
@@ -119,7 +136,7 @@ export interface CaseNode extends AstBase {
 
 export interface SubqueryNode extends AstBase {
   type: 'subquery'
-  subquery: SelectStatement
+  subquery: Statement
 }
 
 export type IntervalUnit = 'DAY' | 'MONTH' | 'YEAR' | 'HOUR' | 'MINUTE' | 'SECOND'
@@ -150,12 +167,12 @@ export type ExprNode =
   | StarNode
 
 export interface StarColumn {
-  kind: 'star'
+  type: 'star'
   table?: string
 }
 
 export interface DerivedColumn {
-  kind: 'derived'
+  type: 'derived'
   expr: ExprNode
   alias?: string
 }

package/src/backend/dataSource.js

@@ -32,19 +32,20 @@ export function memorySource({ data, columns }) {
     if (!data.length) {
       throw new Error('Unknown columns: data is empty and no columns provided')
     }
-    columns = Object.keys(data[0])
+    const firstColumns = Object.keys(data[0])
     // Check first 1000 rows for consistent columns
     for (let i = 1; i < data.length && i < 1000; i++) {
       const rowColumns = Object.keys(data[i])
-      const missing = columns.find(col => !rowColumns.includes(col))
+      const missing = firstColumns.find(col => !rowColumns.includes(col))
       if (missing) {
         throw new Error(`Inconsistent data, column "${missing}" not found in row ${i}`)
       }
-      const extra = rowColumns.find(col => !columns.includes(col))
+      const extra = rowColumns.find(col => !firstColumns.includes(col))
       if (extra) {
         throw new Error(`Inconsistent data, unexpected column "${extra}" found in row ${i}`)
       }
     }
+    columns = firstColumns
   }
   return {
     numRows: data.length,

package/src/execute/aggregates.js

@@ -1,10 +1,10 @@
 import { derivedAlias } from '../expression/alias.js'
 import { evaluateExpr } from '../expression/evaluate.js'
 import { executePlan } from './execute.js'
-import { stringify } from './utils.js'
+import { keyify } from './utils.js'
 
 /**
- * @import { AsyncCells, AsyncRow, ExecuteContext, SelectColumn } from '../types.js'
+ * @import { AsyncCells, AsyncDataSource, AsyncRow, DerivedColumn, ExecuteContext, SelectColumn, SqlPrimitive } from '../types.js'
  * @import { HashAggregateNode, ScalarAggregateNode } from '../plan/types.js'
  */
 
@@ -23,7 +23,7 @@ function projectAggregateColumns(selectColumns, group, context) {
   const cells = {}
 
   for (const col of selectColumns) {
-    if (col.kind === 'star') {
+    if (col.type === 'star') {
       const firstRow = group[0]
       if (firstRow) {
         for (const key of firstRow.columns) {
@@ -31,7 +31,7 @@ function projectAggregateColumns(selectColumns, group, context) {
           cells[key] = firstRow.cells[key]
         }
       }
-    } else if (col.kind === 'derived') {
+    } else {
       const alias = col.alias ?? derivedAlias(col.expr)
       columns.push(alias)
       cells[alias] = () => evaluateExpr({
@@ -63,30 +63,21 @@ export async function* executeHashAggregate(plan, context) {
   }
 
   // Group rows by GROUP BY keys
-  /** @type {Map<string, AsyncRow[]>} */
-  const groupMap = new Map()
-  /** @type {AsyncRow[][]} */
-  const groups = []
+  /** @type {Map<any, AsyncRow[]>} */
+  const groups = new Map()
 
   for (const row of allRows) {
-    /** @type {string[]} */
-    const keyParts = []
-    for (const expr of plan.groupBy) {
-      const v = await evaluateExpr({ node: expr, row, context })
-      keyParts.push(stringify(v))
-    }
-    const key = keyParts.join('|')
-    let group = groupMap.get(key)
+    const key = keyify(...await Promise.all(plan.groupBy.map(expr => evaluateExpr({ node: expr, row, context }))))
+    let group = groups.get(key)
     if (!group) {
       group = []
-      groupMap.set(key, group)
-      groups.push(group)
+      groups.set(key, group)
     }
     group.push(row)
   }
 
   // Yield one row per group
-  for (const group of groups) {
+  for (const group of groups.values()) {
     const asyncRow = projectAggregateColumns(plan.columns, group, context)
 
     // Apply HAVING filter
@@ -117,6 +108,13 @@ export async function* executeHashAggregate(plan, context) {
  * @yields {AsyncRow}
  */
 export async function* executeScalarAggregate(plan, context) {
+  // Fast path: use scanColumn when available
+  const fast = tryColumnScanAggregate(plan, context)
+  if (fast) {
+    yield* fast
+    return
+  }
+
   // Collect all rows into single group
   /** @type {AsyncRow[]} */
   const group = []
@@ -145,3 +143,146 @@ export async function* executeScalarAggregate(plan, context) {
 
   yield asyncRow
 }
+
+/**
+ * @typedef {{
+ *   funcName: string,
+ *   column: string,
+ *   alias: string,
+ *   distinct?: boolean,
+ * }} ColumnAggSpec
+ */
+
+/**
+ * Checks if a scalar aggregate can use the scanColumn fast path.
+ * Returns an async generator if so, undefined otherwise.
+ *
+ * @param {ScalarAggregateNode} plan
+ * @param {ExecuteContext} context
+ * @returns {AsyncGenerator<AsyncRow> | undefined}
+ */
+function tryColumnScanAggregate(plan, context) {
+  // No HAVING support in fast path
+  if (plan.having) return
+  // Child must be a direct table scan
+  if (plan.child.type !== 'Scan') return
+  const scanNode = plan.child
+  // No WHERE in scan (scanColumn doesn't support filtering)
+  if (scanNode.hints.where) return
+
+  const table = context.tables[scanNode.table]
+  if (!table?.scanColumn) return
+
+  // All columns must be simple aggregates on plain identifiers
+  /** @type {ColumnAggSpec[]} */
+  const specs = []
+  for (const col of plan.columns) {
+    if (col.type !== 'derived') return
+    const spec = extractColumnAggSpec(col)
+    if (!spec) return
+    specs.push(spec)
+  }
+
+  return (async function* () {
+    /** @type {string[]} */
+    const columns = []
+    /** @type {AsyncCells} */
+    const cells = {}
+
+    for (const spec of specs) {
+      const value = await scanColumnAggregate(table, spec, context.signal)
+      columns.push(spec.alias)
+      cells[spec.alias] = () => Promise.resolve(value)
+    }
+
+    yield { columns, cells }
+  })()
+}
+
+/**
+ * Extracts aggregate spec from a simple aggregate expression node.
+ * Returns undefined if the expression is not a supported simple aggregate.
+ *
+ * @param {DerivedColumn} col
+ * @returns {ColumnAggSpec | undefined}
+ */
+function extractColumnAggSpec({ expr, alias }) {
+  if (expr.type !== 'function') return
+  if (expr.filter) return // FILTER not supported in fast path
+  const funcName = expr.funcName.toUpperCase()
+  if (!['COUNT', 'SUM', 'AVG', 'MIN', 'MAX'].includes(funcName)) return
+
+  // Argument must be a plain column identifier
+  const arg = expr.args[0]
+  if (arg.type !== 'identifier') return
+  return {
+    funcName,
+    column: derivedAlias(arg),
+    alias: alias ?? derivedAlias(expr),
+    distinct: expr.distinct,
+  }
+}
+
+/**
+ * Scans a single column and computes an aggregate value.
+ *
+ * @param {AsyncDataSource} table
+ * @param {ColumnAggSpec} spec
+ * @param {AbortSignal} [signal]
+ * @returns {Promise<SqlPrimitive>}
+ */
+async function scanColumnAggregate(table, spec, signal) {
+  const values = table.scanColumn({ column: spec.column, signal })
+
+  if (spec.funcName === 'COUNT' && spec.distinct) {
+    const seen = new Set()
+    for await (const chunk of values) {
+      if (signal?.aborted) return null
+      for (let i = 0; i < chunk.length; i++) {
+        const v = chunk[i]
+        if (v == null) continue
+        seen.add(keyify(v))
+      }
+    }
+    return seen.size
+  }
+
+  if (spec.funcName === 'COUNT') {
+    let count = 0
+    for await (const chunk of values) {
+      if (signal?.aborted) return null
+      for (let i = 0; i < chunk.length; i++) {
+        if (chunk[i] != null) count++
+      }
+    }
+    return count
+  }
+
+  // SUM, AVG, MIN, MAX
+  let sum = 0
+  let count = 0
+  /** @type {SqlPrimitive} */
+  let min = null
+  /** @type {SqlPrimitive} */
+  let max = null
+
+  for await (const chunk of values) {
+    if (signal?.aborted) return null
+    for (let i = 0; i < chunk.length; i++) {
+      const v = chunk[i]
+      if (v == null) continue
+      if (min === null || v < min) min = v
+      if (max === null || v > max) max = v
+      const num = Number(v)
+      if (!Number.isFinite(num)) continue
+      sum += num
+      count++
+    }
+  }
+
+  if (spec.funcName === 'SUM') return count === 0 ? null : sum
+  if (spec.funcName === 'AVG') return count === 0 ? null : sum / count
+  if (spec.funcName === 'MIN') return min
+  if (spec.funcName === 'MAX') return max
+  return null
+}

package/src/execute/execute.js

@@ -3,15 +3,15 @@ import { derivedAlias } from '../expression/alias.js'
 import { evaluateExpr } from '../expression/evaluate.js'
 import { parseSql } from '../parse/parse.js'
 import { planSql } from '../plan/plan.js'
-import { tableNotFoundError } from '../validation/planErrors.js'
+import { TableNotFoundError } from '../validation/planErrors.js'
 import { executeHashAggregate, executeScalarAggregate } from './aggregates.js'
 import { executeHashJoin, executeNestedLoopJoin, executePositionalJoin } from './join.js'
 import { executeSort } from './sort.js'
 import { stableRowKey } from './utils.js'
 
 /**
- * @import { AsyncCells, AsyncDataSource, AsyncRow, ExecuteContext, ExecuteSqlOptions, ExprNode, SelectStatement } from '../types.js'
- * @import { CountNode, DistinctNode, FilterNode, LimitNode, ProjectNode, QueryPlan, ScanNode } from '../plan/types.js'
+ * @import { AsyncCells, AsyncDataSource, AsyncRow, ExecuteContext, ExecuteSqlOptions, ExprNode, Statement } from '../types.js'
+ * @import { CountNode, DistinctNode, FilterNode, LimitNode, ProjectNode, QueryPlan, ScanNode, SetOperationNode } from '../plan/types.js'
  */
 
 /**
@@ -21,7 +21,7 @@ import { stableRowKey } from './utils.js'
  * @yields {AsyncRow}
  */
 export async function* executeSql({ tables, query, functions, signal }) {
-  const select = typeof query === 'string' ? parseSql({ query, functions }) : query
+  const parsed = typeof query === 'string' ? parseSql({ query, functions }) : query
 
   // Normalize tables: convert arrays to AsyncDataSource
   /** @type {Record<string, AsyncDataSource>} */
@@ -34,19 +34,19 @@ export async function* executeSql({ tables, query, functions, signal }) {
     }
   }
 
-  yield* executeSelect({ select, context: { tables: normalizedTables, functions, signal } })
+  yield* executeStatement({ query: parsed, context: { tables: normalizedTables, functions, signal } })
 }
 
 /**
- * Executes a SELECT query against the provided tables
+ * Executes a statement against the provided tables
  *
  * @param {Object} options
- * @param {SelectStatement} options.select
+ * @param {Statement} options.query
  * @param {ExecuteContext} options.context
  * @yields {AsyncRow}
  */
-export async function* executeSelect({ select, context }) {
-  const plan = planSql({ query: select, functions: context.functions, tables: context.tables })
+export async function* executeStatement({ query, context }) {
+  const plan = planSql({ query, functions: context.functions, tables: context.tables })
   yield* executePlan({ plan, context })
 }
 
@@ -83,12 +83,12 @@ export async function* executePlan({ plan, context }) {
     yield* executeDistinct(plan, context)
   } else if (plan.type === 'Limit') {
     yield* executeLimit(plan, context)
+  } else if (plan.type === 'SetOperation') {
+    yield* executeSetOperation(plan, context)
   }
 }
 
 /**
- * Executes a table scan
- *
  * @param {ScanNode} plan
  * @param {ExecuteContext} context
  * @yields {AsyncRow}
@@ -98,7 +98,7 @@ async function* executeScan(plan, context) {
   // check table
   const table = tables[plan.table]
   if (!table) {
-    throw tableNotFoundError({ table: plan.table, tables })
+    throw new TableNotFoundError({ table: plan.table, tables })
   }
   // check columns
   const missingColumn = plan.hints.columns?.find(col => !table.columns.includes(col))
@@ -140,12 +140,12 @@ async function* executeScan(plan, context) {
 async function* executeCount(plan, { tables, signal }) {
   const table = tables[plan.table]
   if (!table) {
-    throw tableNotFoundError({ table: plan.table, tables })
+    throw new TableNotFoundError({ table: plan.table, tables })
   }
 
   // Use source numRows if available
   let count = table.numRows
-  if (table.numRows === undefined) {
+  if (count === undefined) {
     // Fall back to counting rows via scan
     count = 0
     const { rows } = table.scan({ signal })
@@ -272,12 +272,12 @@ async function* executeProject(plan, context) {
     const cells = {}
 
     for (const col of plan.columns) {
-      if (col.kind === 'star') {
+      if (col.type === 'star') {
         for (const key of row.columns) {
           columns.push(key)
           cells[key] = row.cells[key]
         }
-      } else if (col.kind === 'derived') {
+      } else {
         const alias = col.alias ?? derivedAlias(col.expr)
         columns.push(alias)
         cells[alias] = () => evaluateExpr({
@@ -304,7 +304,6 @@ async function* executeDistinct(plan, context) {
   const { signal } = context
   const MAX_CHUNK = 256
 
-  /** @type {Set<string>} */
   const seen = new Set()
 
   /** @type {AsyncRow[]} */
@@ -315,10 +314,11 @@ async function* executeDistinct(plan, context) {
     buffer.push(row)
 
     if (buffer.length >= MAX_CHUNK) {
-      const keys = await Promise.all(buffer.map(r => stableRowKey(r.cells)))
+      const keys = buffer.map(stableRowKey)
       for (let i = 0; i < buffer.length; i++) {
-        if (!seen.has(keys[i])) {
-          seen.add(keys[i])
+        const key = await keys[i]
+        if (!seen.has(key)) {
+          seen.add(key)
           yield buffer[i]
         }
       }
@@ -328,10 +328,11 @@ async function* executeDistinct(plan, context) {
 
   // Flush remaining
   if (buffer.length > 0) {
-    const keys = await Promise.all(buffer.map(r => stableRowKey(r.cells)))
+    const keys = buffer.map(stableRowKey)
     for (let i = 0; i < buffer.length; i++) {
-      if (!seen.has(keys[i])) {
-        seen.add(keys[i])
+      const key = await keys[i]
+      if (!seen.has(key)) {
+        seen.add(key)
         yield buffer[i]
       }
     }
@@ -348,3 +349,108 @@ async function* executeDistinct(plan, context) {
 async function* executeLimit(plan, context) {
   yield* limitRows(executePlan({ plan: plan.child, context }), plan.limit, plan.offset, context.signal)
 }
+
+/**
+ * Executes a set operation (UNION, INTERSECT, EXCEPT)
+ *
+ * @param {SetOperationNode} plan
+ * @param {ExecuteContext} context
+ * @yields {AsyncRow}
+ */
+async function* executeSetOperation(plan, context) {
+  const { signal } = context
+
+  if (plan.operator === 'UNION') {
+    if (plan.all) {
+      // UNION ALL: yield all rows from both sides
+      yield* executePlan({ plan: plan.left, context })
+      yield* executePlan({ plan: plan.right, context })
+    } else {
+      // UNION: yield deduplicated rows from both sides
+      const seen = new Set()
+      for await (const row of executePlan({ plan: plan.left, context })) {
+        if (signal?.aborted) return
+        const key = await stableRowKey(row)
+        if (!seen.has(key)) {
+          seen.add(key)
+          yield row
+        }
+      }
+      for await (const row of executePlan({ plan: plan.right, context })) {
+        if (signal?.aborted) return
+        const key = await stableRowKey(row)
+        if (!seen.has(key)) {
+          seen.add(key)
+          yield row
+        }
+      }
+    }
+  } else if (plan.operator === 'INTERSECT') {
+    // Materialize right side keys
+    /** @type {Map<any, number>} */
+    const rightKeys = new Map()
+    for await (const row of executePlan({ plan: plan.right, context })) {
+      if (signal?.aborted) return
+      const key = await stableRowKey(row)
+      rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
+    }
+
+    if (plan.all) {
+      // INTERSECT ALL: yield each left row that matches, consuming right counts
+      for await (const row of executePlan({ plan: plan.left, context })) {
+        if (signal?.aborted) return
+        const key = await stableRowKey(row)
+        const count = rightKeys.get(key)
+        if (count) {
+          rightKeys.set(key, count - 1)
+          yield row
+        }
+      }
+    } else {
+      // INTERSECT: yield deduplicated rows present in both
+      const seen = new Set()
+      for await (const row of executePlan({ plan: plan.left, context })) {
+        if (signal?.aborted) return
+        const key = await stableRowKey(row)
+        if (rightKeys.has(key) && !seen.has(key)) {
+          seen.add(key)
+          yield row
+        }
+      }
+    }
+  } else if (plan.operator === 'EXCEPT') {
+    // Materialize right side keys
+    /** @type {Map<any, number>} */
+    const rightKeys = new Map()
+    for await (const row of executePlan({ plan: plan.right, context })) {
+      if (signal?.aborted) return
+      const key = await stableRowKey(row)
+      rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
+    }
+
+    if (plan.all) {
+      // EXCEPT ALL: yield left rows, consuming right counts
+      for await (const row of executePlan({ plan: plan.left, context })) {
+        if (signal?.aborted) return
+        const key = await stableRowKey(row)
+        const count = rightKeys.get(key)
+        if (count) {
+          rightKeys.set(key, count - 1)
+        } else {
+          yield row
+        }
+      }
+    } else {
+      // EXCEPT: yield deduplicated left rows not in right
+      const seen = new Set()
+      for await (const row of executePlan({ plan: plan.left, context })) {
+        if (signal?.aborted) return
+        const key = await stableRowKey(row)
+        if (!rightKeys.has(key) && !seen.has(key)) {
+          seen.add(key)
+          yield row
+        }
+      }
+    }
+  }
+}