@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

package/out/zql/src/ivm/join-index-tap.js

@@ -0,0 +1,70 @@
+import { unreachable } from "../../../shared/src/asserts.js";
+import { throwOutput } from "./operator.js";
+//#region ../zql/src/ivm/join-index-tap.ts
+/**
+* Keeps the parent indexes of a pipeline's EXISTS joins equal to the rows
+* the pipeline emits: rows it yields on fetch or adds on push are indexed,
+* and rows it removes are dropped.
+*
+* An EXISTS join sits upstream of the conditions and the limit, so it sees
+* every parent the pipeline scans, including those a condition rejects or the
+* limit never keeps. Indexing them there would grow with the scan (the whole
+* table for an unlimited or selective EXISTS). This operator is placed after
+* the limit instead, where a row is only seen once it is part of the result,
+* and a row the limit evicts arrives as a remove.
+*
+* It cannot live in the Exists filter: an OR does not evaluate the branches
+* after the first that passes, but every branch's relationship is still
+* synced for the emitted row.
+*/
+var JoinIndexTap = class {
+	#input;
+	#indexes;
+	#output = throwOutput;
+	constructor(input, indexes) {
+		this.#input = input;
+		this.#indexes = indexes;
+		input.setOutput(this);
+	}
+	setOutput(output) {
+		this.#output = output;
+	}
+	getSchema() {
+		return this.#input.getSchema();
+	}
+	destroy() {
+		this.#input.destroy();
+	}
+	*fetch(req) {
+		for (const node of this.#input.fetch(req)) {
+			if (node !== "yield") for (const index of this.#indexes) index.add(node.row);
+			yield node;
+		}
+	}
+	push(change) {
+		switch (change[0]) {
+			case 0:
+				for (const index of this.#indexes) index.add(change[1].row);
+				break;
+			case 1:
+				for (const index of this.#indexes) index.remove(change[1].row);
+				break;
+			case 2:
+				for (const index of this.#indexes) {
+					index.remove(change[2].row);
+					index.add(change[1].row);
+				}
+				break;
+			case 3: break;
+			default: unreachable(change);
+		}
+		return this.#output.push(change, this);
+	}
+	*reconcile(_pusher) {
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
+	}
+};
+//#endregion
+export { JoinIndexTap };
+
+//# sourceMappingURL=join-index-tap.js.map

package/out/zql/src/ivm/join-index-tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-index-tap.js","names":["#input","#indexes","#output"],"sources":["../../../../../zql/src/ivm/join-index-tap.ts"],"sourcesContent":["import {unreachable} from '../../../shared/src/asserts.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {JoinIndex} from './join-index.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * Keeps the parent indexes of a pipeline's EXISTS joins equal to the rows\n * the pipeline emits: rows it yields on fetch or adds on push are indexed,\n * and rows it removes are dropped.\n *\n * An EXISTS join sits upstream of the conditions and the limit, so it sees\n * every parent the pipeline scans, including those a condition rejects or the\n * limit never keeps. Indexing them there would grow with the scan (the whole\n * table for an unlimited or selective EXISTS). This operator is placed after\n * the limit instead, where a row is only seen once it is part of the result,\n * and a row the limit evicts arrives as a remove.\n *\n * It cannot live in the Exists filter: an OR does not evaluate the branches\n * after the first that passes, but every branch's relationship is still\n * synced for the emitted row.\n */\nexport class JoinIndexTap implements Operator {\n  readonly #input: Input;\n  readonly #indexes: readonly JoinIndex[];\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, indexes: readonly JoinIndex[]) {\n    this.#input = input;\n    this.#indexes = indexes;\n    input.setOutput(this);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    for (const node of this.#input.fetch(req)) {\n      if (node !== 'yield') {\n        for (const index of this.#indexes) {\n          index.add(node.row);\n        }\n      }\n      yield node;\n    }\n  }\n\n  push(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        for (const index of this.#indexes) {\n          index.add(change[ChangeIndex.NODE].row);\n        }\n        break;\n      case ChangeType.REMOVE:\n        for (const index of this.#indexes) {\n          index.remove(change[ChangeIndex.NODE].row);\n        }\n        break;\n      case ChangeType.EDIT:\n        for (const index of this.#indexes) {\n          index.remove(change[ChangeIndex.OLD_NODE].row);\n          index.add(change[ChangeIndex.NODE].row);\n        }\n        break;\n      case ChangeType.CHILD:\n        break;\n      default:\n        unreachable(change);\n    }\n    return this.#output.push(change, this);\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiCA,IAAa,eAAb,MAA8C;CAC5C;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,SAA+B;EACvD,KAAKA,SAAS;EACd,KAAKC,WAAW;EAChB,MAAM,UAAU,IAAI;CACtB;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;CACjB;CAEA,YAA0B;EACxB,OAAO,KAAKF,OAAO,UAAU;CAC/B;CAEA,UAAgB;EACd,KAAKA,OAAO,QAAQ;CACtB;CAEA,CAAC,MAAM,KAA2C;EAChD,KAAK,MAAM,QAAQ,KAAKA,OAAO,MAAM,GAAG,GAAG;GACzC,IAAI,SAAS,SACX,KAAK,MAAM,SAAS,KAAKC,UACvB,MAAM,IAAI,KAAK,GAAG;GAGtB,MAAM;EACR;CACF;CAEA,KAAK,QAAiC;EACpC,QAAQ,OAAO,IAAf;GACE,KAAK;IACH,KAAK,MAAM,SAAS,KAAKA,UACvB,MAAM,IAAI,OAAO,GAAkB,GAAG;IAExC;GACF,KAAK;IACH,KAAK,MAAM,SAAS,KAAKA,UACvB,MAAM,OAAO,OAAO,GAAkB,GAAG;IAE3C;GACF,KAAK;IACH,KAAK,MAAM,SAAS,KAAKA,UAAU;KACjC,MAAM,OAAO,OAAO,GAAsB,GAAG;KAC7C,MAAM,IAAI,OAAO,GAAkB,GAAG;IACxC;IACA;GACF,KAAK,GACH;GACF,SACE,YAAY,MAAM;EACtB;EACA,OAAO,KAAKC,QAAQ,KAAK,QAAQ,IAAI;CACvC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAKA,QAAQ,WACf,OAAO,KAAKA,QAAQ,UAAU,IAAI;CAEtC;AACF"}

package/out/zql/src/ivm/join-index.d.ts

@@ -0,0 +1,35 @@
+import type { CompoundKey } from '../../../zero-protocol/src/ast.ts';
+import type { Row, Value } from '../../../zero-protocol/src/data.ts';
+/**
+ * The partitions of the indexed parents that share a join key, as fetch
+ * constraints. An unpartitioned index reports a single `undefined`.
+ */
+export type ParentPartitions = readonly (Record<string, Value> | undefined)[];
+/**
+ * An in-memory index from a join key to the parent rows that have it. Join
+ * and FlippedJoin look up a child change's join key here to skip the parent
+ * fetch when no indexed parent can see the change.
+ *
+ * Parents are tracked by primary key so that adding or removing a row twice
+ * is harmless. Lookups only report whether any parent has the key and, when
+ * the index is partitioned, in which partitions.
+ */
+export declare class JoinIndex {
+    #private;
+    constructor(parentKey: CompoundKey, primaryKey: CompoundKey, partitionKey?: CompoundKey | undefined);
+    /** The number of parent rows in the index. */
+    get size(): number;
+    add(row: Row): void;
+    remove(row: Row): void;
+    /**
+     * The partitions of the indexed parents whose join key matches `childRow`
+     * over `childKey`, or `undefined` if there are none.
+     */
+    lookup(childRow: Row, childKey: CompoundKey): ParentPartitions | undefined;
+    /**
+     * The index as the operator storage entries it replaced, keyed
+     * `j\0<joinKey>\0[<partitionKey>\0]<primaryKey>`. For tests.
+     */
+    entriesForTest(): Record<string, 1>;
+}
+//# sourceMappingURL=join-index.d.ts.map

package/out/zql/src/ivm/join-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-index.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/join-index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AAGnE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;AAS9E;;;;;;;;GAQG;AACH,qBAAa,SAAS;;IAUpB,YACE,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,YAAY,CAAC,EAAE,WAAW,GAAG,SAAS,EAQvC;IAED,8CAA8C;IAC9C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAuClB;IAED,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAuCrB;IAED;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,GAAG,gBAAgB,GAAG,SAAS,CAazE;IAED;;;OAGG;IACH,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAiBlC;CAKF"}

package/out/zql/src/ivm/join-index.js

@@ -0,0 +1,141 @@
+import { must } from "../../../shared/src/must.js";
+import { canonicalKey } from "./join-utils.js";
+//#region ../zql/src/ivm/join-index.ts
+var UNPARTITIONED = [void 0];
+/**
+* An in-memory index from a join key to the parent rows that have it. Join
+* and FlippedJoin look up a child change's join key here to skip the parent
+* fetch when no indexed parent can see the change.
+*
+* Parents are tracked by primary key so that adding or removing a row twice
+* is harmless. Lookups only report whether any parent has the key and, when
+* the index is partitioned, in which partitions.
+*/
+var JoinIndex = class {
+	#parentKey;
+	#primaryKey;
+	/** The join key is the primary key, so one string serves as both. */
+	#joinKeyIsPK;
+	#partitionKey;
+	#unpartitioned = /* @__PURE__ */ new Map();
+	#partitioned = /* @__PURE__ */ new Map();
+	#size = 0;
+	constructor(parentKey, primaryKey, partitionKey) {
+		this.#parentKey = parentKey;
+		this.#primaryKey = primaryKey;
+		this.#joinKeyIsPK = parentKey.length === primaryKey.length && parentKey.every((k, i) => k === primaryKey[i]);
+		this.#partitionKey = partitionKey;
+	}
+	/** The number of parent rows in the index. */
+	get size() {
+		return this.#size;
+	}
+	add(row) {
+		const joinKey = joinKeyOf(row, this.#parentKey);
+		if (joinKey === void 0) return;
+		const pk = this.#pkOf(row, joinKey);
+		const partitionKey = this.#partitionKey;
+		if (partitionKey === void 0) {
+			let pks = this.#unpartitioned.get(joinKey);
+			if (pks === void 0) {
+				pks = /* @__PURE__ */ new Set();
+				this.#unpartitioned.set(joinKey, pks);
+			}
+			if (!pks.has(pk)) {
+				pks.add(pk);
+				this.#size++;
+			}
+			return;
+		}
+		const partKey = canonicalKey(row, partitionKey);
+		let partitions = this.#partitioned.get(joinKey);
+		if (partitions === void 0) {
+			partitions = /* @__PURE__ */ new Map();
+			this.#partitioned.set(joinKey, partitions);
+		}
+		let partition = partitions.get(partKey);
+		if (partition === void 0) {
+			const constraint = {};
+			for (const key of partitionKey) constraint[key] = row[key];
+			partition = {
+				constraint,
+				pks: /* @__PURE__ */ new Set()
+			};
+			partitions.set(partKey, partition);
+		}
+		if (!partition.pks.has(pk)) {
+			partition.pks.add(pk);
+			this.#size++;
+		}
+	}
+	remove(row) {
+		const joinKey = joinKeyOf(row, this.#parentKey);
+		if (joinKey === void 0) return;
+		const pk = this.#pkOf(row, joinKey);
+		const partitionKey = this.#partitionKey;
+		if (partitionKey === void 0) {
+			const pks = this.#unpartitioned.get(joinKey);
+			if (pks === void 0) return;
+			if (pks.delete(pk)) {
+				this.#size--;
+				if (pks.size === 0) this.#unpartitioned.delete(joinKey);
+			}
+			return;
+		}
+		const partitions = this.#partitioned.get(joinKey);
+		if (partitions === void 0) return;
+		const partKey = canonicalKey(row, partitionKey);
+		const partition = partitions.get(partKey);
+		if (partition === void 0) return;
+		if (partition.pks.delete(pk)) {
+			this.#size--;
+			if (partition.pks.size === 0) {
+				partitions.delete(partKey);
+				if (partitions.size === 0) this.#partitioned.delete(joinKey);
+			}
+		}
+	}
+	/**
+	* The partitions of the indexed parents whose join key matches `childRow`
+	* over `childKey`, or `undefined` if there are none.
+	*/
+	lookup(childRow, childKey) {
+		const joinKey = joinKeyOf(childRow, childKey);
+		if (joinKey === void 0) return;
+		if (this.#partitionKey === void 0) return this.#unpartitioned.has(joinKey) ? UNPARTITIONED : void 0;
+		const partitions = this.#partitioned.get(joinKey);
+		if (partitions === void 0) return;
+		return Array.from(partitions.values(), (p) => p.constraint);
+	}
+	/**
+	* The index as the operator storage entries it replaced, keyed
+	* `j\0<joinKey>\0[<partitionKey>\0]<primaryKey>`. For tests.
+	*/
+	entriesForTest() {
+		const entries = {};
+		for (const [joinKey, pks] of this.#unpartitioned) for (const pk of pks) entries[`j\x00${joinKey}\x00${pk}`] = 1;
+		for (const [joinKey, partitions] of this.#partitioned) {
+			const partitionKey = must(this.#partitionKey);
+			for (const { constraint, pks } of partitions.values()) {
+				const partKey = canonicalKey(constraint, partitionKey);
+				for (const pk of pks) entries[`j\x00${joinKey}\x00${partKey}\x00${pk}`] = 1;
+			}
+		}
+		return entries;
+	}
+	#pkOf(row, joinKey) {
+		return this.#joinKeyIsPK ? joinKey : canonicalKey(row, this.#primaryKey);
+	}
+};
+/**
+* The canonical join key of `row`, or `undefined` if any part of it is null:
+* a null key cannot match anything.
+*/
+function joinKeyOf(row, key) {
+	for (const k of key) if (row[k] === null) return;
+	return canonicalKey(row, key);
+}
+//#endregion
+export { JoinIndex };
+
+//# sourceMappingURL=join-index.js.map

package/out/zql/src/ivm/join-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-index.js","names":["#parentKey","#primaryKey","#joinKeyIsPK","#partitionKey","#unpartitioned","#partitioned","#size","#pkOf"],"sources":["../../../../../zql/src/ivm/join-index.ts"],"sourcesContent":["import {must} from '../../../shared/src/must.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {canonicalKey} from './join-utils.ts';\n\n/**\n * The partitions of the indexed parents that share a join key, as fetch\n * constraints. An unpartitioned index reports a single `undefined`.\n */\nexport type ParentPartitions = readonly (Record<string, Value> | undefined)[];\n\nconst UNPARTITIONED: ParentPartitions = [undefined];\n\ntype Partition = {\n  readonly constraint: Record<string, Value>;\n  readonly pks: Set<string>;\n};\n\n/**\n * An in-memory index from a join key to the parent rows that have it. Join\n * and FlippedJoin look up a child change's join key here to skip the parent\n * fetch when no indexed parent can see the change.\n *\n * Parents are tracked by primary key so that adding or removing a row twice\n * is harmless. Lookups only report whether any parent has the key and, when\n * the index is partitioned, in which partitions.\n */\nexport class JoinIndex {\n  readonly #parentKey: CompoundKey;\n  readonly #primaryKey: CompoundKey;\n  /** The join key is the primary key, so one string serves as both. */\n  readonly #joinKeyIsPK: boolean;\n  readonly #partitionKey: CompoundKey | undefined;\n  readonly #unpartitioned = new Map<string, Set<string>>();\n  readonly #partitioned = new Map<string, Map<string, Partition>>();\n  #size = 0;\n\n  constructor(\n    parentKey: CompoundKey,\n    primaryKey: CompoundKey,\n    partitionKey?: CompoundKey | undefined,\n  ) {\n    this.#parentKey = parentKey;\n    this.#primaryKey = primaryKey;\n    this.#joinKeyIsPK =\n      parentKey.length === primaryKey.length &&\n      parentKey.every((k, i) => k === primaryKey[i]);\n    this.#partitionKey = partitionKey;\n  }\n\n  /** The number of parent rows in the index. */\n  get size(): number {\n    return this.#size;\n  }\n\n  add(row: Row): void {\n    const joinKey = joinKeyOf(row, this.#parentKey);\n    if (joinKey === undefined) {\n      return;\n    }\n    const pk = this.#pkOf(row, joinKey);\n    const partitionKey = this.#partitionKey;\n    if (partitionKey === undefined) {\n      let pks = this.#unpartitioned.get(joinKey);\n      if (pks === undefined) {\n        pks = new Set();\n        this.#unpartitioned.set(joinKey, pks);\n      }\n      if (!pks.has(pk)) {\n        pks.add(pk);\n        this.#size++;\n      }\n      return;\n    }\n\n    const partKey = canonicalKey(row, partitionKey);\n    let partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      partitions = new Map();\n      this.#partitioned.set(joinKey, partitions);\n    }\n    let partition = partitions.get(partKey);\n    if (partition === undefined) {\n      const constraint: Record<string, Value> = {};\n      for (const key of partitionKey) {\n        constraint[key] = row[key];\n      }\n      partition = {constraint, pks: new Set()};\n      partitions.set(partKey, partition);\n    }\n    if (!partition.pks.has(pk)) {\n      partition.pks.add(pk);\n      this.#size++;\n    }\n  }\n\n  remove(row: Row): void {\n    const joinKey = joinKeyOf(row, this.#parentKey);\n    if (joinKey === undefined) {\n      return;\n    }\n    const pk = this.#pkOf(row, joinKey);\n    const partitionKey = this.#partitionKey;\n    if (partitionKey === undefined) {\n      const pks = this.#unpartitioned.get(joinKey);\n      if (pks === undefined) {\n        return;\n      }\n      if (pks.delete(pk)) {\n        this.#size--;\n        if (pks.size === 0) {\n          this.#unpartitioned.delete(joinKey);\n        }\n      }\n      return;\n    }\n\n    const partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      return;\n    }\n    const partKey = canonicalKey(row, partitionKey);\n    const partition = partitions.get(partKey);\n    if (partition === undefined) {\n      return;\n    }\n    if (partition.pks.delete(pk)) {\n      this.#size--;\n      if (partition.pks.size === 0) {\n        partitions.delete(partKey);\n        if (partitions.size === 0) {\n          this.#partitioned.delete(joinKey);\n        }\n      }\n    }\n  }\n\n  /**\n   * The partitions of the indexed parents whose join key matches `childRow`\n   * over `childKey`, or `undefined` if there are none.\n   */\n  lookup(childRow: Row, childKey: CompoundKey): ParentPartitions | undefined {\n    const joinKey = joinKeyOf(childRow, childKey);\n    if (joinKey === undefined) {\n      return undefined;\n    }\n    if (this.#partitionKey === undefined) {\n      return this.#unpartitioned.has(joinKey) ? UNPARTITIONED : undefined;\n    }\n    const partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      return undefined;\n    }\n    return Array.from(partitions.values(), p => p.constraint);\n  }\n\n  /**\n   * The index as the operator storage entries it replaced, keyed\n   * `j\\0<joinKey>\\0[<partitionKey>\\0]<primaryKey>`. For tests.\n   */\n  entriesForTest(): Record<string, 1> {\n    const entries: Record<string, 1> = {};\n    for (const [joinKey, pks] of this.#unpartitioned) {\n      for (const pk of pks) {\n        entries[`j\\x00${joinKey}\\x00${pk}`] = 1;\n      }\n    }\n    for (const [joinKey, partitions] of this.#partitioned) {\n      const partitionKey = must(this.#partitionKey);\n      for (const {constraint, pks} of partitions.values()) {\n        const partKey = canonicalKey(constraint, partitionKey);\n        for (const pk of pks) {\n          entries[`j\\x00${joinKey}\\x00${partKey}\\x00${pk}`] = 1;\n        }\n      }\n    }\n    return entries;\n  }\n\n  #pkOf(row: Row, joinKey: string): string {\n    return this.#joinKeyIsPK ? joinKey : canonicalKey(row, this.#primaryKey);\n  }\n}\n\n/**\n * The canonical join key of `row`, or `undefined` if any part of it is null:\n * a null key cannot match anything.\n */\nfunction joinKeyOf(row: Row, key: CompoundKey): string | undefined {\n  for (const k of key) {\n    if (row[k] === null) {\n      return undefined;\n    }\n  }\n  return canonicalKey(row, key);\n}\n"],"mappings":";;;AAWA,IAAM,gBAAkC,CAAC,KAAA,CAAS;;;;;;;;;;AAgBlD,IAAa,YAAb,MAAuB;CACrB;CACA;;CAEA;CACA;CACA,iCAA0B,IAAI,IAAyB;CACvD,+BAAwB,IAAI,IAAoC;CAChE,QAAQ;CAER,YACE,WACA,YACA,cACA;EACA,KAAKA,aAAa;EAClB,KAAKC,cAAc;EACnB,KAAKC,eACH,UAAU,WAAW,WAAW,UAChC,UAAU,OAAO,GAAG,MAAM,MAAM,WAAW,EAAE;EAC/C,KAAKC,gBAAgB;CACvB;;CAGA,IAAI,OAAe;EACjB,OAAO,KAAKG;CACd;CAEA,IAAI,KAAgB;EAClB,MAAM,UAAU,UAAU,KAAK,KAAKN,UAAU;EAC9C,IAAI,YAAY,KAAA,GACd;EAEF,MAAM,KAAK,KAAKO,MAAM,KAAK,OAAO;EAClC,MAAM,eAAe,KAAKJ;EAC1B,IAAI,iBAAiB,KAAA,GAAW;GAC9B,IAAI,MAAM,KAAKC,eAAe,IAAI,OAAO;GACzC,IAAI,QAAQ,KAAA,GAAW;IACrB,sBAAM,IAAI,IAAI;IACd,KAAKA,eAAe,IAAI,SAAS,GAAG;GACtC;GACA,IAAI,CAAC,IAAI,IAAI,EAAE,GAAG;IAChB,IAAI,IAAI,EAAE;IACV,KAAKE;GACP;GACA;EACF;EAEA,MAAM,UAAU,aAAa,KAAK,YAAY;EAC9C,IAAI,aAAa,KAAKD,aAAa,IAAI,OAAO;EAC9C,IAAI,eAAe,KAAA,GAAW;GAC5B,6BAAa,IAAI,IAAI;GACrB,KAAKA,aAAa,IAAI,SAAS,UAAU;EAC3C;EACA,IAAI,YAAY,WAAW,IAAI,OAAO;EACtC,IAAI,cAAc,KAAA,GAAW;GAC3B,MAAM,aAAoC,CAAC;GAC3C,KAAK,MAAM,OAAO,cAChB,WAAW,OAAO,IAAI;GAExB,YAAY;IAAC;IAAY,qBAAK,IAAI,IAAI;GAAC;GACvC,WAAW,IAAI,SAAS,SAAS;EACnC;EACA,IAAI,CAAC,UAAU,IAAI,IAAI,EAAE,GAAG;GAC1B,UAAU,IAAI,IAAI,EAAE;GACpB,KAAKC;EACP;CACF;CAEA,OAAO,KAAgB;EACrB,MAAM,UAAU,UAAU,KAAK,KAAKN,UAAU;EAC9C,IAAI,YAAY,KAAA,GACd;EAEF,MAAM,KAAK,KAAKO,MAAM,KAAK,OAAO;EAClC,MAAM,eAAe,KAAKJ;EAC1B,IAAI,iBAAiB,KAAA,GAAW;GAC9B,MAAM,MAAM,KAAKC,eAAe,IAAI,OAAO;GAC3C,IAAI,QAAQ,KAAA,GACV;GAEF,IAAI,IAAI,OAAO,EAAE,GAAG;IAClB,KAAKE;IACL,IAAI,IAAI,SAAS,GACf,KAAKF,eAAe,OAAO,OAAO;GAEtC;GACA;EACF;EAEA,MAAM,aAAa,KAAKC,aAAa,IAAI,OAAO;EAChD,IAAI,eAAe,KAAA,GACjB;EAEF,MAAM,UAAU,aAAa,KAAK,YAAY;EAC9C,MAAM,YAAY,WAAW,IAAI,OAAO;EACxC,IAAI,cAAc,KAAA,GAChB;EAEF,IAAI,UAAU,IAAI,OAAO,EAAE,GAAG;GAC5B,KAAKC;GACL,IAAI,UAAU,IAAI,SAAS,GAAG;IAC5B,WAAW,OAAO,OAAO;IACzB,IAAI,WAAW,SAAS,GACtB,KAAKD,aAAa,OAAO,OAAO;GAEpC;EACF;CACF;;;;;CAMA,OAAO,UAAe,UAAqD;EACzE,MAAM,UAAU,UAAU,UAAU,QAAQ;EAC5C,IAAI,YAAY,KAAA,GACd;EAEF,IAAI,KAAKF,kBAAkB,KAAA,GACzB,OAAO,KAAKC,eAAe,IAAI,OAAO,IAAI,gBAAgB,KAAA;EAE5D,MAAM,aAAa,KAAKC,aAAa,IAAI,OAAO;EAChD,IAAI,eAAe,KAAA,GACjB;EAEF,OAAO,MAAM,KAAK,WAAW,OAAO,IAAG,MAAK,EAAE,UAAU;CAC1D;;;;;CAMA,iBAAoC;EAClC,MAAM,UAA6B,CAAC;EACpC,KAAK,MAAM,CAAC,SAAS,QAAQ,KAAKD,gBAChC,KAAK,MAAM,MAAM,KACf,QAAQ,QAAQ,QAAQ,MAAM,QAAQ;EAG1C,KAAK,MAAM,CAAC,SAAS,eAAe,KAAKC,cAAc;GACrD,MAAM,eAAe,KAAK,KAAKF,aAAa;GAC5C,KAAK,MAAM,EAAC,YAAY,SAAQ,WAAW,OAAO,GAAG;IACnD,MAAM,UAAU,aAAa,YAAY,YAAY;IACrD,KAAK,MAAM,MAAM,KACf,QAAQ,QAAQ,QAAQ,MAAM,QAAQ,MAAM,QAAQ;GAExD;EACF;EACA,OAAO;CACT;CAEA,MAAM,KAAU,SAAyB;EACvC,OAAO,KAAKD,eAAe,UAAU,aAAa,KAAK,KAAKD,WAAW;CACzE;AACF;;;;;AAMA,SAAS,UAAU,KAAU,KAAsC;CACjE,KAAK,MAAM,KAAK,KACd,IAAI,IAAI,OAAO,MACb;CAGJ,OAAO,aAAa,KAAK,GAAG;AAC9B"}

package/out/zql/src/ivm/join-utils.d.ts

@@ -16,4 +16,10 @@ export declare function isJoinMatch(parent: Row, parentKey: CompoundKey, child:
  * since null foreign keys cannot match any rows.
  */
 export declare function buildJoinConstraint(sourceRow: Row, sourceKey: CompoundKey, targetKey: CompoundKey): Record<string, Value> | undefined;
+export declare function canonicalKeyForTest(record: Record<string, Value | undefined>, keys: CompoundKey): string;
+/**
+ * Canonical string key over `keys` of `record`. Tags values by type
+ * so distinct types (e.g. 1 and "1") do not collide.
+ */
+export declare function canonicalKey(record: Record<string, Value | undefined>, keys: CompoundKey): string;
 //# sourceMappingURL=join-utils.d.ts.map

package/out/zql/src/ivm/join-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"join-utils.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/join-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AAGnE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAA6B,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,CAAC,CAEd;AAED,wBAAiB,mBAAmB,CAClC,MAAM,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,EAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAqGxB;AAED,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,CAAC,CAEd;AAED,wBAAiB,4BAA4B,CAC3C,MAAM,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,EAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAkExB;AAED,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,GAAG,EACN,CAAC,EAAE,GAAG,EACN,GAAG,EAAE,WAAW,GACf,OAAO,CAOT;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,GAAG,EACX,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,GAAG,EACV,QAAQ,EAAE,WAAW,WAQtB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,WAAW,GACrB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,SAAS,CAUnC"}
+{"version":3,"file":"join-utils.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/join-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AAGnE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAA6B,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,CAAC,CAEd;AAED,wBAAiB,mBAAmB,CAClC,MAAM,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,EAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAqGxB;AAED,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,CAAC,CAEd;AAED,wBAAiB,4BAA4B,CAC3C,MAAM,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,EAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAkExB;AAED,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,GAAG,EACN,CAAC,EAAE,GAAG,EACN,GAAG,EAAE,WAAW,GACf,OAAO,CAOT;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,GAAG,EACX,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,GAAG,EACV,QAAQ,EAAE,WAAW,WAQtB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,WAAW,GACrB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,SAAS,CAUnC;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,SAAS,CAAC,EACzC,IAAI,EAAE,WAAW,GAChB,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,SAAS,CAAC,EACzC,IAAI,EAAE,WAAW,GAChB,MAAM,CAUR"}

package/out/zql/src/ivm/join-utils.js

@@ -124,7 +124,28 @@ function buildJoinConstraint(sourceRow, sourceKey, targetKey) {
 	}
 	return constraint;
 }
+/**
+* Canonical string key over `keys` of `record`. Tags values by type
+* so distinct types (e.g. 1 and "1") do not collide.
+*/
+function canonicalKey(record, keys) {
+	if (keys.length === 1) return canonicalValue(record[keys[0]]);
+	let s = "";
+	for (let i = 0; i < keys.length; i++) {
+		if (i > 0) s += "\0";
+		s += canonicalValue(record[keys[i]]);
+	}
+	return s;
+}
+function canonicalValue(v) {
+	if (v === null || v === void 0) return "n";
+	const t = typeof v;
+	if (t === "string") return "s" + v;
+	if (t === "number") return "d" + v;
+	if (t === "boolean") return v ? "t" : "f";
+	return "j" + JSON.stringify(v);
+}
 //#endregion
-export { buildJoinConstraint, generateWithOverlay, generateWithOverlayNoYield, generateWithOverlayUnordered, isJoinMatch, rowEqualsForCompoundKey };
+export { buildJoinConstraint, canonicalKey, generateWithOverlay, generateWithOverlayNoYield, generateWithOverlayUnordered, isJoinMatch, rowEqualsForCompoundKey };
 
 //# sourceMappingURL=join-utils.js.map

package/out/zql/src/ivm/join-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"join-utils.js","names":[],"sources":["../../../../../zql/src/ivm/join-utils.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {compareValues, valuesEqual, type Node} from './data.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport function generateWithOverlayNoYield(\n  stream: Stream<Node>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node> {\n  return generateWithOverlay(stream, overlay, schema) as Stream<Node>;\n}\n\nexport function* generateWithOverlay(\n  stream: Stream<Node | 'yield'>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node | 'yield'> {\n  let applied = false;\n  let editOldApplied = false;\n  let editNewApplied = false;\n  for (const node of stream) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    let yieldNode = true;\n    if (!applied) {\n      switch (overlay[ChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          if (\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            applied = true;\n            yieldNode = false;\n          }\n          break;\n        }\n        case ChangeType.REMOVE: {\n          if (schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) < 0) {\n            applied = true;\n            yield overlay[ChangeIndex.NODE];\n          }\n          break;\n        }\n        case ChangeType.EDIT: {\n          if (\n            !editOldApplied &&\n            schema.compareRows(overlay[ChangeIndex.OLD_NODE].row, node.row) < 0\n          ) {\n            editOldApplied = true;\n            if (editNewApplied) {\n              applied = true;\n            }\n            yield overlay[ChangeIndex.OLD_NODE];\n          }\n          if (\n            !editNewApplied &&\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            editNewApplied = true;\n            if (editOldApplied) {\n              applied = true;\n            }\n            yieldNode = false;\n          }\n          break;\n        }\n        case ChangeType.CHILD: {\n          if (\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            applied = true;\n            yield {\n              row: node.row,\n              relationships: {\n                ...node.relationships,\n                [overlay[ChangeIndex.CHILD_DATA].relationshipName]: () =>\n                  generateWithOverlay(\n                    node.relationships[\n                      overlay[ChangeIndex.CHILD_DATA].relationshipName\n                    ](),\n                    overlay[ChangeIndex.CHILD_DATA].change,\n                    schema.relationships[\n                      overlay[ChangeIndex.CHILD_DATA].relationshipName\n                    ],\n                  ),\n              },\n            };\n            yieldNode = false;\n          }\n          break;\n        }\n      }\n    }\n    if (yieldNode) {\n      yield node;\n    }\n  }\n  if (!applied) {\n    if (overlay[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      applied = true;\n      yield overlay[ChangeIndex.NODE];\n    } else if (overlay[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      assert(\n        editNewApplied,\n        'edit overlay: new node must be applied before old node',\n      );\n      editOldApplied = true;\n      applied = true;\n      yield overlay[ChangeIndex.OLD_NODE];\n    }\n  }\n\n  assert(\n    applied,\n    'overlayGenerator: overlay was never applied to any fetched node',\n  );\n}\n\nexport function generateWithOverlayNoYieldUnordered(\n  stream: Stream<Node>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node> {\n  return generateWithOverlayUnordered(stream, overlay, schema) as Stream<Node>;\n}\n\nexport function* generateWithOverlayUnordered(\n  stream: Stream<Node | 'yield'>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node | 'yield'> {\n  // Eager inject\n  if (overlay[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n    yield overlay[ChangeIndex.NODE];\n  } else if (overlay[ChangeIndex.TYPE] === ChangeType.EDIT) {\n    yield overlay[ChangeIndex.OLD_NODE];\n  }\n\n  // Stream with inline suppress\n  let suppressed = false;\n  for (const node of stream) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!suppressed) {\n      if (\n        overlay[ChangeIndex.TYPE] === ChangeType.ADD ||\n        overlay[ChangeIndex.TYPE] === ChangeType.EDIT\n      ) {\n        if (\n          rowEqualsForCompoundKey(\n            overlay[ChangeIndex.NODE].row,\n            node.row,\n            schema.primaryKey,\n          )\n        ) {\n          suppressed = true;\n          continue;\n        }\n      }\n      if (overlay[ChangeIndex.TYPE] === ChangeType.CHILD) {\n        if (\n          rowEqualsForCompoundKey(\n            overlay[ChangeIndex.NODE].row,\n            node.row,\n            schema.primaryKey,\n          )\n        ) {\n          suppressed = true;\n          yield {\n            row: node.row,\n            relationships: {\n              ...node.relationships,\n              [overlay[ChangeIndex.CHILD_DATA].relationshipName]: () =>\n                generateWithOverlay(\n                  node.relationships[\n                    overlay[ChangeIndex.CHILD_DATA].relationshipName\n                  ](),\n                  overlay[ChangeIndex.CHILD_DATA].change,\n                  schema.relationships[\n                    overlay[ChangeIndex.CHILD_DATA].relationshipName\n                  ],\n                ),\n            },\n          };\n          continue;\n        }\n      }\n    }\n    yield node;\n  }\n  assert(\n    suppressed || overlay[ChangeIndex.TYPE] === ChangeType.REMOVE,\n    'overlayGenerator: overlay was never applied to any fetched node',\n  );\n}\n\nexport function rowEqualsForCompoundKey(\n  a: Row,\n  b: Row,\n  key: CompoundKey,\n): boolean {\n  for (let i = 0; i < key.length; i++) {\n    if (compareValues(a[key[i]], b[key[i]]) !== 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isJoinMatch(\n  parent: Row,\n  parentKey: CompoundKey,\n  child: Row,\n  childKey: CompoundKey,\n) {\n  for (let i = 0; i < parentKey.length; i++) {\n    if (!valuesEqual(parent[parentKey[i]], child[childKey[i]])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Builds a constraint object by mapping values from `sourceRow` using `sourceKey`\n * to keys specified by `targetKey`. Returns `undefined` if any source value is `null`,\n * since null foreign keys cannot match any rows.\n */\nexport function buildJoinConstraint(\n  sourceRow: Row,\n  sourceKey: CompoundKey,\n  targetKey: CompoundKey,\n): Record<string, Value> | undefined {\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < targetKey.length; i++) {\n    const value = sourceRow[sourceKey[i]];\n    if (value === null) {\n      return undefined;\n    }\n    constraint[targetKey[i]] = value;\n  }\n  return constraint;\n}\n"],"mappings":"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"}
+{"version":3,"file":"join-utils.js","names":[],"sources":["../../../../../zql/src/ivm/join-utils.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {compareValues, valuesEqual, type Node} from './data.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport function generateWithOverlayNoYield(\n  stream: Stream<Node>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node> {\n  return generateWithOverlay(stream, overlay, schema) as Stream<Node>;\n}\n\nexport function* generateWithOverlay(\n  stream: Stream<Node | 'yield'>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node | 'yield'> {\n  let applied = false;\n  let editOldApplied = false;\n  let editNewApplied = false;\n  for (const node of stream) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    let yieldNode = true;\n    if (!applied) {\n      switch (overlay[ChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          if (\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            applied = true;\n            yieldNode = false;\n          }\n          break;\n        }\n        case ChangeType.REMOVE: {\n          if (schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) < 0) {\n            applied = true;\n            yield overlay[ChangeIndex.NODE];\n          }\n          break;\n        }\n        case ChangeType.EDIT: {\n          if (\n            !editOldApplied &&\n            schema.compareRows(overlay[ChangeIndex.OLD_NODE].row, node.row) < 0\n          ) {\n            editOldApplied = true;\n            if (editNewApplied) {\n              applied = true;\n            }\n            yield overlay[ChangeIndex.OLD_NODE];\n          }\n          if (\n            !editNewApplied &&\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            editNewApplied = true;\n            if (editOldApplied) {\n              applied = true;\n            }\n            yieldNode = false;\n          }\n          break;\n        }\n        case ChangeType.CHILD: {\n          if (\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            applied = true;\n            yield {\n              row: node.row,\n              relationships: {\n                ...node.relationships,\n                [overlay[ChangeIndex.CHILD_DATA].relationshipName]: () =>\n                  generateWithOverlay(\n                    node.relationships[\n                      overlay[ChangeIndex.CHILD_DATA].relationshipName\n                    ](),\n                    overlay[ChangeIndex.CHILD_DATA].change,\n                    schema.relationships[\n                      overlay[ChangeIndex.CHILD_DATA].relationshipName\n                    ],\n                  ),\n              },\n            };\n            yieldNode = false;\n          }\n          break;\n        }\n      }\n    }\n    if (yieldNode) {\n      yield node;\n    }\n  }\n  if (!applied) {\n    if (overlay[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      applied = true;\n      yield overlay[ChangeIndex.NODE];\n    } else if (overlay[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      assert(\n        editNewApplied,\n        'edit overlay: new node must be applied before old node',\n      );\n      editOldApplied = true;\n      applied = true;\n      yield overlay[ChangeIndex.OLD_NODE];\n    }\n  }\n\n  assert(\n    applied,\n    'overlayGenerator: overlay was never applied to any fetched node',\n  );\n}\n\nexport function generateWithOverlayNoYieldUnordered(\n  stream: Stream<Node>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node> {\n  return generateWithOverlayUnordered(stream, overlay, schema) as Stream<Node>;\n}\n\nexport function* generateWithOverlayUnordered(\n  stream: Stream<Node | 'yield'>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node | 'yield'> {\n  // Eager inject\n  if (overlay[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n    yield overlay[ChangeIndex.NODE];\n  } else if (overlay[ChangeIndex.TYPE] === ChangeType.EDIT) {\n    yield overlay[ChangeIndex.OLD_NODE];\n  }\n\n  // Stream with inline suppress\n  let suppressed = false;\n  for (const node of stream) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!suppressed) {\n      if (\n        overlay[ChangeIndex.TYPE] === ChangeType.ADD ||\n        overlay[ChangeIndex.TYPE] === ChangeType.EDIT\n      ) {\n        if (\n          rowEqualsForCompoundKey(\n            overlay[ChangeIndex.NODE].row,\n            node.row,\n            schema.primaryKey,\n          )\n        ) {\n          suppressed = true;\n          continue;\n        }\n      }\n      if (overlay[ChangeIndex.TYPE] === ChangeType.CHILD) {\n        if (\n          rowEqualsForCompoundKey(\n            overlay[ChangeIndex.NODE].row,\n            node.row,\n            schema.primaryKey,\n          )\n        ) {\n          suppressed = true;\n          yield {\n            row: node.row,\n            relationships: {\n              ...node.relationships,\n              [overlay[ChangeIndex.CHILD_DATA].relationshipName]: () =>\n                generateWithOverlay(\n                  node.relationships[\n                    overlay[ChangeIndex.CHILD_DATA].relationshipName\n                  ](),\n                  overlay[ChangeIndex.CHILD_DATA].change,\n                  schema.relationships[\n                    overlay[ChangeIndex.CHILD_DATA].relationshipName\n                  ],\n                ),\n            },\n          };\n          continue;\n        }\n      }\n    }\n    yield node;\n  }\n  assert(\n    suppressed || overlay[ChangeIndex.TYPE] === ChangeType.REMOVE,\n    'overlayGenerator: overlay was never applied to any fetched node',\n  );\n}\n\nexport function rowEqualsForCompoundKey(\n  a: Row,\n  b: Row,\n  key: CompoundKey,\n): boolean {\n  for (let i = 0; i < key.length; i++) {\n    if (compareValues(a[key[i]], b[key[i]]) !== 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isJoinMatch(\n  parent: Row,\n  parentKey: CompoundKey,\n  child: Row,\n  childKey: CompoundKey,\n) {\n  for (let i = 0; i < parentKey.length; i++) {\n    if (!valuesEqual(parent[parentKey[i]], child[childKey[i]])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Builds a constraint object by mapping values from `sourceRow` using `sourceKey`\n * to keys specified by `targetKey`. Returns `undefined` if any source value is `null`,\n * since null foreign keys cannot match any rows.\n */\nexport function buildJoinConstraint(\n  sourceRow: Row,\n  sourceKey: CompoundKey,\n  targetKey: CompoundKey,\n): Record<string, Value> | undefined {\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < targetKey.length; i++) {\n    const value = sourceRow[sourceKey[i]];\n    if (value === null) {\n      return undefined;\n    }\n    constraint[targetKey[i]] = value;\n  }\n  return constraint;\n}\n\nexport function canonicalKeyForTest(\n  record: Record<string, Value | undefined>,\n  keys: CompoundKey,\n): string {\n  return canonicalKey(record, keys);\n}\n\n/**\n * Canonical string key over `keys` of `record`. Tags values by type\n * so distinct types (e.g. 1 and \"1\") do not collide.\n */\nexport function canonicalKey(\n  record: Record<string, Value | undefined>,\n  keys: CompoundKey,\n): string {\n  if (keys.length === 1) {\n    return canonicalValue(record[keys[0]]);\n  }\n  let s = '';\n  for (let i = 0; i < keys.length; i++) {\n    if (i > 0) s += '\\x00';\n    s += canonicalValue(record[keys[i]]);\n  }\n  return s;\n}\n\nfunction canonicalValue(v: Value): string {\n  // Tag by type so we don't conflate e.g. `1` (number) with `\"1\"` (string).\n  if (v === null || v === undefined) return 'n';\n  const t = typeof v;\n  if (t === 'string') return 's' + (v as string);\n  if (t === 'number') return 'd' + (v as number);\n  if (t === 'boolean') return v ? 't' : 'f';\n  return 'j' + JSON.stringify(v);\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/join.d.ts

@@ -1,8 +1,10 @@
 import type { CompoundKey, System } from '../../../zero-protocol/src/ast.ts';
 import type { Node } from './data.ts';
+import { JoinIndex } from './join-index.ts';
 import { type FetchRequest, type Input, type Output } from './operator.ts';
 import type { SourceSchema } from './schema.ts';
 import { type Stream } from './stream.ts';
+import { type TakeBoundProvider } from './take-gate.ts';
 type Args = {
     parent: Input;
     child: Input;
@@ -11,6 +13,21 @@ type Args = {
     relationshipName: string;
     hidden: boolean;
     system: System;
+    parentPartitionKey?: CompoundKey | undefined;
+    boundProvider?: TakeBoundProvider | undefined;
+    /**
+     * Set when this join feeds an EXISTS or NOT EXISTS condition. Its parent
+     * index is then kept by a JoinIndexTap at the end of the pipeline, so it
+     * only holds the parents the pipeline emits, not every parent this join
+     * sees. A child change that misses the index is dropped unless it could
+     * make a parent pass the condition: an add for EXISTS, a remove for NOT
+     * EXISTS. Those still fetch the parents.
+     */
+    exists?: ExistsJoin | undefined;
+};
+export type ExistsJoin = {
+    readonly op: 'EXISTS' | 'NOT EXISTS';
+    readonly parentIndex: JoinIndex;
 };
 /**
  * The Join operator joins the output from two upstream inputs. Zero's join
@@ -24,8 +41,9 @@ type Args = {
  */
 export declare class Join implements Input {
     #private;
-    constructor({ parent, child, parentKey, childKey, relationshipName, hidden, system, }: Args);
+    constructor({ parent, child, parentKey, childKey, relationshipName, hidden, system, parentPartitionKey, boundProvider, exists, }: Args);
     destroy(): void;
+    get parentIndexForTest(): JoinIndex;
     setOutput(output: Output): void;
     getSchema(): SourceSchema;
     fetch(req: FetchRequest): Stream<Node | 'yield'>;

package/out/zql/src/ivm/join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/join.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAE,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAW3E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAQpC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IAEb,SAAS,EAAE,WAAW,CAAC;IACvB,QAAQ,EAAE,WAAW,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,IAAK,YAAW,KAAK;;IAahC,YAAY,EACV,MAAM,EACN,KAAK,EACL,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,MAAM,EACN,MAAM,GACP,EAAE,IAAI,EAgCN;IAED,OAAO,IAAI,IAAI,CAGd;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAQhD;CAgLF"}
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/join.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAE,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAW3E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAU1C,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,gBAAgB,CAAC;AAExB,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IAEb,SAAS,EAAE,WAAW,CAAC;IACvB,QAAQ,EAAE,WAAW,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC7C,aAAa,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC9C;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,EAAE,EAAE,QAAQ,GAAG,YAAY,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,IAAK,YAAW,KAAK;;IAkChC,YAAY,EACV,MAAM,EACN,KAAK,EACL,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,MAAM,EACN,MAAM,EACN,kBAAkB,EAClB,aAAa,EACb,MAAM,GACP,EAAE,IAAI,EAkDN;IAQD,OAAO,IAAI,IAAI,CAGd;IAED,IAAI,kBAAkB,IAAI,SAAS,CAElC;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAShD;CA0QF"}

package/out/zql/src/ivm/join.js

@@ -1,7 +1,10 @@
 import { assert, unreachable } from "../../../shared/src/asserts.js";
 import { throwOutput } from "./operator.js";
 import { makeAddChange, makeChildChange, makeEditChange, makeRemoveChange } from "./change.js";
-import { buildJoinConstraint, generateWithOverlay, generateWithOverlayUnordered, isJoinMatch, rowEqualsForCompoundKey } from "./join-utils.js";
+import { buildJoinConstraint, canonicalKey, generateWithOverlay, generateWithOverlayUnordered, isJoinMatch, rowEqualsForCompoundKey } from "./join-utils.js";
+import { JoinIndex } from "./join-index.js";
+import { mergeSortedStreams } from "./memory-source.js";
+import { isInParentFetch, readParentFetchBounds } from "./take-gate.js";
 //#region ../zql/src/ivm/join.ts
 /**
 * The Join operator joins the output from two upstream inputs. Zero's join
@@ -20,17 +23,49 @@ var Join = class {
 	#childKey;
 	#relationshipName;
 	#schema;
+	#parentIndex;
+	/**
+	* Whether this join adds and removes parents in #parentIndex itself. Not
+	* so for EXISTS joins, see Args.exists.
+	*/
+	#indexesParents;
+	/**
+	* The child change type that is still pushed to the parents when no
+	* indexed parent has its join key. See Args.exists.
+	*/
+	#qualifyingChildChange;
+	#boundProvider;
 	#output = throwOutput;
 	#inprogressChildChange;
 	#inprogressChildChangePosition;
-	constructor({ parent, child, parentKey, childKey, relationshipName, hidden, system }) {
+	/**
+	* Primary keys of the parents #inprogressChildChange has reached so far,
+	* kept only when the parent input is unordered. An unordered stream is not
+	* in `compareRows` order (SQLite returns it in whatever order its plan
+	* visits, e.g. rowid order), so whether a parent is still in the push queue
+	* cannot be decided by comparing it to #inprogressChildChangePosition.
+	*/
+	#inprogressReachedParents;
+	#inprogressParentFetchBounds;
+	constructor({ parent, child, parentKey, childKey, relationshipName, hidden, system, parentPartitionKey, boundProvider, exists }) {
 		assert(parent !== child, "Parent and child must be different operators");
 		assert(parentKey.length === childKey.length, "The parentKey and childKey keys must have same length");
+		assert(!exists || !parentPartitionKey, "EXISTS joins are not partitioned");
 		this.#parent = parent;
 		this.#child = child;
 		this.#parentKey = parentKey;
 		this.#childKey = childKey;
 		this.#relationshipName = relationshipName;
+		if (exists) {
+			this.#parentIndex = exists.parentIndex;
+			this.#indexesParents = false;
+			this.#qualifyingChildChange = exists.op === "EXISTS" ? 0 : 1;
+		} else {
+			this.#parentIndex = new JoinIndex(parentKey, parent.getSchema().primaryKey, parentPartitionKey);
+			this.#indexesParents = true;
+			this.#qualifyingChildChange = void 0;
+		}
+		this.#boundProvider = boundProvider;
 		const parentSchema = parent.getSchema();
 		const childSchema = child.getSchema();
 		this.#schema = {
@@ -44,13 +79,25 @@ var Join = class {
 				}
 			}
 		};
-		parent.setOutput({ push: (change) => this.#pushParent(change) });
-		child.setOutput({ push: (change) => this.#pushChild(change) });
+		parent.setOutput({
+			push: (change) => this.#pushParent(change),
+			reconcile: () => this.#reconcile()
+		});
+		child.setOutput({
+			push: (change) => this.#pushChild(change),
+			reconcile: () => this.#reconcile()
+		});
+	}
+	*#reconcile() {
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
 	}
 	destroy() {
 		this.#parent.destroy();
 		this.#child.destroy();
 	}
+	get parentIndexForTest() {
+		return this.#parentIndex;
+	}
 	setOutput(output) {
 		this.#output = output;
 	}
@@ -63,15 +110,18 @@ var Join = class {
 				yield parentNode;
 				continue;
 			}
+			this.#indexParentRow(parentNode.row);
 			yield this.#processParentNode(parentNode.row, parentNode.relationships);
 		}
 	}
 	*#pushParent(change) {
 		switch (change[0]) {
 			case 0:
+				this.#indexParentRow(change[1].row);
 				yield* this.#output.push(makeAddChange(this.#processParentNode(change[1].row, change[1].relationships)), this);
 				break;
 			case 1:
+				this.#unindexParentRow(change[1].row);
 				yield* this.#output.push(makeRemoveChange(this.#processParentNode(change[1].row, change[1].relationships)), this);
 				break;
 			case 3:
@@ -79,6 +129,8 @@ var Join = class {
 				break;
 			case 2:
 				assert(rowEqualsForCompoundKey(change[2].row, change[1].row, this.#parentKey), `Parent edit must not change relationship.`);
+				this.#unindexParentRow(change[2].row);
+				this.#indexParentRow(change[1].row);
 				yield* this.#output.push(makeEditChange(this.#processParentNode(change[1].row, change[1].relationships), this.#processParentNode(change[2].row, change[2].relationships)), this);
 				break;
 			default: unreachable(change);
@@ -106,29 +158,69 @@ var Join = class {
 	*#pushChildChange(childRow, change) {
 		this.#inprogressChildChange = change;
 		this.#inprogressChildChangePosition = void 0;
+		this.#inprogressReachedParents = this.#parent.getSchema().sort === void 0 ? /* @__PURE__ */ new Set() : void 0;
 		try {
 			const constraint = buildJoinConstraint(childRow, this.#childKey, this.#parentKey);
-			if (constraint) for (const parentNode of this.#parent.fetch({ constraint })) {
-				if (parentNode === "yield") {
-					yield parentNode;
-					continue;
+			if (constraint) {
+				const partitions = this.#parentIndex.lookup(childRow, this.#childKey);
+				let fetchConstraints;
+				if (partitions) fetchConstraints = partitions.map((partitionConstraint) => partitionConstraint ? {
+					...constraint,
+					...partitionConstraint
+				} : constraint);
+				else if (change[0] === this.#qualifyingChildChange) fetchConstraints = [constraint];
+				else return;
+				if (this.#boundProvider) this.#inprogressParentFetchBounds = readParentFetchBounds(this.#boundProvider, fetchConstraints);
+				let parentNodeStream;
+				if (fetchConstraints.length === 1) parentNodeStream = this.#parent.fetch({ constraint: fetchConstraints[0] });
+				else {
+					const streams = fetchConstraints.map((c) => this.#parent.fetch({ constraint: c }));
+					const compare = (a, b) => this.#schema.compareRows(a.row, b.row);
+					parentNodeStream = mergeSortedStreams(streams, compare);
+				}
+				for (const parentNode of parentNodeStream) {
+					if (parentNode === "yield") {
+						yield parentNode;
+						continue;
+					}
+					this.#inprogressChildChangePosition = parentNode.row;
+					this.#inprogressReachedParents?.add(canonicalKey(parentNode.row, this.#schema.primaryKey));
+					const childChange = makeChildChange(this.#processParentNode(parentNode.row, parentNode.relationships), {
+						relationshipName: this.#relationshipName,
+						change
+					});
+					yield* this.#output.push(childChange, this);
 				}
-				this.#inprogressChildChangePosition = parentNode.row;
-				const childChange = makeChildChange(this.#processParentNode(parentNode.row, parentNode.relationships), {
-					relationshipName: this.#relationshipName,
-					change
-				});
-				yield* this.#output.push(childChange, this);
 			}
 		} finally {
 			this.#inprogressChildChange = void 0;
+			this.#inprogressChildChangePosition = void 0;
+			this.#inprogressReachedParents = void 0;
+			this.#inprogressParentFetchBounds = void 0;
 		}
 	}
+	/**
+	* Whether the in-progress child change has yet to reach `parentNodeRow`,
+	* i.e. the row comes after #inprogressChildChangePosition in the parent
+	* stream.
+	*/
+	#isAfterInprogressPosition(parentNodeRow) {
+		if (this.#inprogressChildChangePosition === void 0) return false;
+		if (this.#inprogressReachedParents) return !this.#inprogressReachedParents.has(canonicalKey(parentNodeRow, this.#schema.primaryKey));
+		return this.#schema.compareRows(parentNodeRow, this.#inprogressChildChangePosition) > 0;
+	}
+	#indexParentRow(row) {
+		if (this.#indexesParents) this.#parentIndex.add(row);
+	}
+	#unindexParentRow(row) {
+		if (this.#indexesParents) this.#parentIndex.remove(row);
+	}
 	#processParentNode(parentNodeRow, parentNodeRelations) {
 		const childStream = () => {
 			const constraint = buildJoinConstraint(parentNodeRow, this.#parentKey, this.#childKey);
 			const stream = constraint ? this.#child.fetch({ constraint }) : [];
-			if (this.#inprogressChildChange && isJoinMatch(parentNodeRow, this.#parentKey, this.#inprogressChildChange[1].row, this.#childKey) && this.#inprogressChildChangePosition && this.#schema.compareRows(parentNodeRow, this.#inprogressChildChangePosition) > 0) {
+			const inPushQueue = this.#isAfterInprogressPosition(parentNodeRow) && (this.#inprogressParentFetchBounds === void 0 || isInParentFetch(this.#inprogressParentFetchBounds, parentNodeRow, this.#schema.compareRows));
+			if (this.#inprogressChildChange && isJoinMatch(parentNodeRow, this.#parentKey, this.#inprogressChildChange[1].row, this.#childKey) && inPushQueue) {
 				const childSchema = this.#child.getSchema();
 				if (childSchema.sort === void 0) return generateWithOverlayUnordered(stream, this.#inprogressChildChange, childSchema);
 				return generateWithOverlay(stream, this.#inprogressChildChange, childSchema);