@rocicorp/zero 1.6.2 → 1.7.0-canary.1

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

@@ -1,12 +1,15 @@
 import { assert, unreachable } from "../../../shared/src/asserts.js";
 import { binarySearch } from "../../../shared/src/binary-search.js";
-import { must } from "../../../shared/src/must.js";
 import { throwOutput } from "./operator.js";
 import { makeAddChange, makeChildChange, makeEditChange, makeRemoveChange } from "./change.js";
-import { constraintsAreCompatible, keyMatchesPrimaryKey } from "./constraint.js";
+import { constraintsAreCompatible } from "./constraint.js";
 import { buildJoinConstraint, generateWithOverlayNoYield, isJoinMatch, rowEqualsForCompoundKey } from "./join-utils.js";
 import { mergeSortedStreams } from "./memory-source.js";
 //#region ../zql/src/ivm/flipped-join.ts
+var multiConstraintChunkSize = 256;
+function getMultiConstraintChunkSize() {
+	return multiConstraintChunkSize;
+}
 /**
 * An *inner* join which fetches nodes from its child input first and then
 * fetches their related nodes from its parent input.  Output nodes are the
@@ -22,7 +25,6 @@ var FlippedJoin = class {
 	#childKey;
 	#relationshipName;
 	#schema;
-	#parentKeyIsUnique;
 	#output = throwOutput;
 	#inprogressChildChange;
 	#inprogressChildChangePosition;
@@ -36,7 +38,6 @@ var FlippedJoin = class {
 		this.#relationshipName = relationshipName;
 		const parentSchema = parent.getSchema();
 		const childSchema = child.getSchema();
-		this.#parentKeyIsUnique = keyMatchesPrimaryKey(parentKey, parentSchema.primaryKey) || (parentSchema.uniqueIndexes?.some((idx) => keyMatchesPrimaryKey(parentKey, idx)) ?? false);
 		this.#schema = {
 			...parentSchema,
 			relationships: {
@@ -85,79 +86,75 @@ var FlippedJoin = class {
 			const insertPos = binarySearch(childNodes.length, (i) => compare(removedNode.row, childNodes[i].row));
 			childNodes.splice(insertPos, 0, removedNode);
 		}
-		if (this.#parentKeyIsUnique) yield* this.#fetchQuicksort(req, childNodes);
-		else yield* this.#fetchMergeSort(req, childNodes);
+		yield* this.#fetchBatched(req, childNodes);
 	}
-	*#fetchQuicksort(req, childNodes) {
-		const pairs = [];
-		for (const childNode of childNodes) {
-			const constraintFromChild = buildJoinConstraint(childNode.row, this.#childKey, this.#parentKey);
-			if (!constraintFromChild || req.constraint && !constraintsAreCompatible(constraintFromChild, req.constraint)) continue;
-			const stream = this.#parent.fetch({
-				...req,
-				constraint: {
-					...req.constraint,
-					...constraintFromChild
-				}
-			});
-			for (const node of stream) {
-				if (node === "yield") {
-					yield "yield";
-					continue;
-				}
-				pairs.push({
-					childNode,
-					parentNode: node
-				});
-			}
-		}
-		const compareRows = this.#schema.compareRows;
-		const dir = req.reverse ? -1 : 1;
-		pairs.sort((a, b) => compareRows(a.parentNode.row, b.parentNode.row) * dir);
-		let i = 0;
-		while (i < pairs.length) {
-			const minParentNode = pairs[i].parentNode;
-			const relatedChildNodes = [];
-			while (i < pairs.length && compareRows(pairs[i].parentNode.row, minParentNode.row) === 0) {
-				relatedChildNodes.push(pairs[i].childNode);
-				i++;
-			}
-			yield* this.#yieldParentWithOverlay(minParentNode, relatedChildNodes);
-		}
-	}
-	*#fetchMergeSort(req, childNodes) {
+	/**
+	* Fetches parents for `childNodes` in batched calls, using
+	* `multiConstraint` so the source can issue one query per chunk (e.g.
+	* SQL `IN` with index-aware seek) instead of N per-child cursors.
+	*
+	* Multi-constraint values are split into chunks of `CHUNK_SIZE`, so
+	* SQL `IN` lists stay bounded — predictable plans, statement-cache
+	* hits across calls of the same chunk size, well below SQLite's
+	* parameter limit.
+	*
+	* Within each chunk, the source returns parents in `compareRows` order.
+	* Across chunks, we merge with `mergeSortedStreams` so the overall
+	* stream is also in order. Note: the merge primes one row from every
+	* chunk before yielding the first output, so all chunks open their
+	* cursors up front. Early termination downstream then prevents any
+	* further work on un-advanced chunks (cursors get `.return()`'d via
+	* `mergeSortedStreams`'s finally block).
+	*
+	* Replaces the previous split between `#fetchMergeSort` and
+	* `#fetchQuicksort`. The unique-vs-not distinction is no longer needed:
+	* the source handles cardinality (single index seek for each value) and
+	* ordering (SQL `ORDER BY` / index walk).
+	*/
+	*#fetchBatched(req, childNodes) {
+		const parentReqConstraint = req.constraint;
 		const parentKey = this.#parentKey;
-		const computedKeys = [];
+		const childKey = this.#childKey;
+		const computedMulti = [];
 		const childIndexesByKey = /* @__PURE__ */ new Map();
 		for (let i = 0; i < childNodes.length; i++) {
-			const constraintFromChild = buildJoinConstraint(childNodes[i].row, this.#childKey, parentKey);
-			if (!constraintFromChild || req.constraint && !constraintsAreCompatible(constraintFromChild, req.constraint)) continue;
+			const constraintFromChild = buildJoinConstraint(childNodes[i].row, childKey, parentKey);
+			if (!constraintFromChild || parentReqConstraint && !constraintsAreCompatible(constraintFromChild, parentReqConstraint)) continue;
 			const key = canonicalKey(constraintFromChild, parentKey);
 			const existing = childIndexesByKey.get(key);
 			if (existing === void 0) {
 				childIndexesByKey.set(key, [i]);
-				computedKeys.push(constraintFromChild);
+				computedMulti.push(constraintFromChild);
 			} else existing.push(i);
 		}
-		if (computedKeys.length === 0) return;
+		if (computedMulti.length === 0) return;
 		const compareRows = this.#schema.compareRows;
 		const compare = req.reverse ? (a, b) => compareRows(b.row, a.row) : (a, b) => compareRows(a.row, b.row);
-		const streams = computedKeys.map((c) => this.#parent.fetch({
+		const incoming = req.multiConstraints ?? [];
+		const parentStream = computedMulti.length <= multiConstraintChunkSize ? this.#parent.fetch({
 			...req,
-			constraint: req.constraint ? {
-				...req.constraint,
-				...c
-			} : c
-		}));
-		for (const node of mergeSortedStreams(streams, compare)) {
+			multiConstraints: [...incoming, computedMulti]
+		}) : this.#fetchChunked(req, incoming, computedMulti, compare);
+		for (const node of parentStream) {
 			if (node === "yield") {
 				yield "yield";
 				continue;
 			}
-			const relatedChildNodes = must(childIndexesByKey.get(canonicalKey(node.row, parentKey))).map((i) => childNodes[i]);
+			const key = canonicalKey(node.row, parentKey);
+			const idxs = childIndexesByKey.get(key);
+			if (idxs === void 0) continue;
+			const relatedChildNodes = idxs.map((i) => childNodes[i]);
 			yield* this.#yieldParentWithOverlay(node, relatedChildNodes);
 		}
 	}
+	*#fetchChunked(req, incomingMultis, computedMulti, compare) {
+		const chunkStreams = [];
+		for (let i = 0; i < computedMulti.length; i += multiConstraintChunkSize) chunkStreams.push(this.#parent.fetch({
+			...req,
+			multiConstraints: [...incomingMultis, computedMulti.slice(i, i + multiConstraintChunkSize)]
+		}));
+		yield* mergeSortedStreams(chunkStreams, compare);
+	}
 	*#yieldParentWithOverlay(minParentNode, relatedChildNodes) {
 		let overlaidRelatedChildNodes = relatedChildNodes;
 		if (this.#inprogressChildChange && this.#inprogressChildChangePosition && isJoinMatch(this.#inprogressChildChange[1].row, this.#childKey, minParentNode.row, this.#parentKey)) {
@@ -281,11 +278,10 @@ var FlippedJoin = class {
 	}
 };
 /**
-* Canonical string key over `keys` of `record`, used by `#fetchMergeSort`
-* both to dedupe per-child fetches and to map each returned parent row
-* back to the children that referenced its parent-key tuple.
-*
-* Exported for testing.
+* Canonical string key over `keys` of `record`, used by `#fetchBatched`
+* both to dedupe `multiConstraint` entries (record = Constraint) and to
+* map each returned parent row back to the children that referenced its
+* parent-key tuple (record = Row).
 */
 function canonicalKey(record, keys) {
 	if (keys.length === 1) return canonicalValue(record[keys[0]]);
@@ -306,6 +302,6 @@ function canonicalValue(v) {
 	return "j" + JSON.stringify(v);
 }
 //#endregion
-export { FlippedJoin };
+export { FlippedJoin, getMultiConstraintChunkSize };
 
 //# sourceMappingURL=flipped-join.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"flipped-join.js","names":["#parent","#child","#parentKey","#childKey","#relationshipName","#schema","#parentKeyIsUnique","#pushParent","#pushChild","#output","#inprogressChildChange","#fetchQuicksort","#fetchMergeSort","#yieldParentWithOverlay","#inprogressChildChangePosition","#pushChildChange"],"sources":["../../../../../zql/src/ivm/flipped-join.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {binarySearch} from '../../../shared/src/binary-search.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {CompoundKey, System} 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 {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport {\n  constraintsAreCompatible,\n  keyMatchesPrimaryKey,\n  type Constraint,\n} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport {\n  buildJoinConstraint,\n  generateWithOverlayNoYield,\n  isJoinMatch,\n  rowEqualsForCompoundKey,\n} from './join-utils.ts';\nimport {mergeSortedStreams} from './memory-source.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\ntype Args = {\n  parent: Input;\n  child: Input;\n  // The nth key in childKey corresponds to the nth key in parentKey.\n  parentKey: CompoundKey;\n  childKey: CompoundKey;\n\n  relationshipName: string;\n  hidden: boolean;\n  system: System;\n};\n\n/**\n * An *inner* join which fetches nodes from its child input first and then\n * fetches their related nodes from its parent input.  Output nodes are the\n * nodes from parent input (in parent input order), which have at least one\n * related child.  These output nodes have a new relationship added to them,\n * which has the name `relationshipName`. The value of the relationship is a\n * stream of related nodes from the child input (in child input order).\n */\nexport class FlippedJoin implements Input {\n  readonly #parent: Input;\n  readonly #child: Input;\n  readonly #parentKey: CompoundKey;\n  readonly #childKey: CompoundKey;\n  readonly #relationshipName: string;\n  readonly #schema: SourceSchema;\n  readonly #parentKeyIsUnique: boolean;\n\n  #output: Output = throwOutput;\n\n  #inprogressChildChange: Change | undefined;\n  #inprogressChildChangePosition: Row | undefined;\n\n  constructor({\n    parent,\n    child,\n    parentKey,\n    childKey,\n    relationshipName,\n    hidden,\n    system,\n  }: Args) {\n    assert(parent !== child, 'Parent and child must be different operators');\n    assert(\n      parentKey.length === childKey.length,\n      'The parentKey and childKey keys must have same length',\n    );\n    this.#parent = parent;\n    this.#child = child;\n    this.#parentKey = parentKey;\n    this.#childKey = childKey;\n    this.#relationshipName = relationshipName;\n\n    const parentSchema = parent.getSchema();\n    const childSchema = child.getSchema();\n    this.#parentKeyIsUnique =\n      keyMatchesPrimaryKey(parentKey, parentSchema.primaryKey) ||\n      (parentSchema.uniqueIndexes?.some(idx =>\n        keyMatchesPrimaryKey(parentKey, idx),\n      ) ??\n        false);\n    this.#schema = {\n      ...parentSchema,\n      relationships: {\n        ...parentSchema.relationships,\n        [relationshipName]: {\n          ...childSchema,\n          isHidden: hidden,\n          system,\n        },\n      },\n    };\n\n    parent.setOutput({\n      push: (change: Change) => this.#pushParent(change),\n    });\n    child.setOutput({\n      push: (change: Change) => this.#pushChild(change),\n    });\n  }\n\n  destroy(): void {\n    this.#child.destroy();\n    this.#parent.destroy();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    // Translate constraints for the parent on parts of the join key to\n    // constraints for the child.\n    const childConstraint: Record<string, Value> = {};\n    let hasChildConstraint = false;\n    if (req.constraint) {\n      for (const [key, value] of Object.entries(req.constraint)) {\n        const index = this.#parentKey.indexOf(key);\n        if (index !== -1) {\n          hasChildConstraint = true;\n          childConstraint[this.#childKey[index]] = value;\n        }\n      }\n    }\n\n    const childNodes: Node[] = [];\n    for (const node of this.#child.fetch(\n      hasChildConstraint ? {constraint: childConstraint} : {},\n    )) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      childNodes.push(node);\n    }\n\n    // FlippedJoin's split-push change overlay logic is largely\n    // the same as Join's with the exception of remove.  For remove,\n    // the change is undone here, and then re-applied to parents with order\n    // less than or equal to change.position below.  This is necessary\n    // because if the removed node was the last related child, the\n    // related parents with position greater than change.position\n    // (which should not yet have the node removed), would not even\n    // be fetched here, and would be absent from the output all together.\n    if (this.#inprogressChildChange?.[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const removedNode = this.#inprogressChildChange[ChangeIndex.NODE];\n      const compare = this.#child.getSchema().compareRows;\n      const insertPos = binarySearch(childNodes.length, i =>\n        compare(removedNode.row, childNodes[i].row),\n      );\n      childNodes.splice(insertPos, 0, removedNode);\n    }\n\n    if (this.#parentKeyIsUnique) {\n      yield* this.#fetchQuicksort(req, childNodes);\n    } else {\n      yield* this.#fetchMergeSort(req, childNodes);\n    }\n  }\n\n  // When parentKey matches a unique index on the parent (primary or\n  // otherwise) each child -> parent fetch returns at most one row, so the\n  // merge-sort degenerates to N simultaneous prepared-statement iterators\n  // each holding a single-row cursor.  Instead, fetch sequentially (letting\n  // the statement cache reuse a single prepared statement) and sort the\n  // resulting parents into order.\n  *#fetchQuicksort(\n    req: FetchRequest,\n    childNodes: Node[],\n  ): Stream<Node | 'yield'> {\n    const pairs: {childNode: Node; parentNode: Node}[] = [];\n    for (const childNode of childNodes) {\n      const constraintFromChild = buildJoinConstraint(\n        childNode.row,\n        this.#childKey,\n        this.#parentKey,\n      );\n      if (\n        !constraintFromChild ||\n        (req.constraint &&\n          !constraintsAreCompatible(constraintFromChild, req.constraint))\n      ) {\n        continue;\n      }\n      const stream = this.#parent.fetch({\n        ...req,\n        constraint: {\n          ...req.constraint,\n          ...constraintFromChild,\n        },\n      });\n      // parentKey matches a unique index, so this fetch returns at most\n      // one row under the Source contract.  Iterate to completion rather\n      // than breaking to preserve yield propagation and to avoid silently\n      // changing behavior if a source ever returns more.\n      for (const node of stream) {\n        if (node === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        pairs.push({childNode, parentNode: node});\n      }\n    }\n\n    const compareRows = this.#schema.compareRows;\n    const dir = req.reverse ? -1 : 1;\n    pairs.sort((a, b) => compareRows(a.parentNode.row, b.parentNode.row) * dir);\n\n    // Group consecutive pairs with equal parent rows.  Array.sort is stable,\n    // and childNodes was already in child order, so children within each\n    // group retain child order.\n    let i = 0;\n    while (i < pairs.length) {\n      const minParentNode = pairs[i].parentNode;\n      const relatedChildNodes: Node[] = [];\n      while (\n        i < pairs.length &&\n        compareRows(pairs[i].parentNode.row, minParentNode.row) === 0\n      ) {\n        relatedChildNodes.push(pairs[i].childNode);\n        i++;\n      }\n      yield* this.#yieldParentWithOverlay(minParentNode, relatedChildNodes);\n    }\n  }\n\n  *#fetchMergeSort(\n    req: FetchRequest,\n    childNodes: Node[],\n  ): Stream<Node | 'yield'> {\n    // Group children by parent-key value so children sharing a value\n    // share one fetch (and one cursor). Without this, two children with\n    // the same parent-key value would each open their own iterator that\n    // re-fetches the same parent rows — wasted IO.\n    const parentKey = this.#parentKey;\n    const computedKeys: Constraint[] = [];\n    const childIndexesByKey = new Map<string, number[]>();\n    for (let i = 0; i < childNodes.length; i++) {\n      const constraintFromChild = buildJoinConstraint(\n        childNodes[i].row,\n        this.#childKey,\n        parentKey,\n      );\n      if (\n        !constraintFromChild ||\n        (req.constraint &&\n          !constraintsAreCompatible(constraintFromChild, req.constraint))\n      ) {\n        continue;\n      }\n      const key = canonicalKey(constraintFromChild, parentKey);\n      const existing = childIndexesByKey.get(key);\n      if (existing === undefined) {\n        childIndexesByKey.set(key, [i]);\n        computedKeys.push(constraintFromChild);\n      } else {\n        existing.push(i);\n      }\n    }\n\n    if (computedKeys.length === 0) {\n      return;\n    }\n\n    const compareRows = this.#schema.compareRows;\n    const compare: (a: Node, b: Node) => number = req.reverse\n      ? (a, b) => compareRows(b.row, a.row)\n      : (a, b) => compareRows(a.row, b.row);\n\n    // One stream per unique parent-key value. Each stream returns its\n    // matching parent rows in compareRows order; the heap merges them\n    // into a globally ordered stream. Distinct rows can't compare equal\n    // (compareRows includes the primary key), so no tie handling needed\n    // — every emit maps back to exactly one entry in childIndexesByKey.\n    const streams: Stream<Node | 'yield'>[] = computedKeys.map(c =>\n      this.#parent.fetch({\n        ...req,\n        constraint: req.constraint ? {...req.constraint, ...c} : c,\n      }),\n    );\n\n    for (const node of mergeSortedStreams(streams, compare)) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      // Every fetched parent row matches the constraint for one entry\n      // in `computedKeys`, whose canonical key was inserted into the\n      // map — so the lookup is guaranteed to hit. Children retain\n      // their original input order within the group because we\n      // appended to the indexes array in iteration order.\n      const idxs = must(\n        childIndexesByKey.get(canonicalKey(node.row, parentKey)),\n      );\n      const relatedChildNodes: Node[] = idxs.map(i => childNodes[i]);\n      yield* this.#yieldParentWithOverlay(node, relatedChildNodes);\n    }\n  }\n\n  *#yieldParentWithOverlay(\n    minParentNode: Node,\n    relatedChildNodes: Node[],\n  ): Stream<Node> {\n    let overlaidRelatedChildNodes = relatedChildNodes;\n    if (\n      this.#inprogressChildChange &&\n      this.#inprogressChildChangePosition &&\n      isJoinMatch(\n        this.#inprogressChildChange[ChangeIndex.NODE].row,\n        this.#childKey,\n        minParentNode.row,\n        this.#parentKey,\n      )\n    ) {\n      const hasInprogressChildChangeBeenPushedForMinParentNode =\n        this.#parent\n          .getSchema()\n          .compareRows(\n            minParentNode.row,\n            this.#inprogressChildChangePosition,\n          ) <= 0;\n      if (this.#inprogressChildChange[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n        if (hasInprogressChildChangeBeenPushedForMinParentNode) {\n          // Remove from relatedChildNodes since the removed child\n          // was inserted into childNodes above.\n          overlaidRelatedChildNodes = relatedChildNodes.filter(\n            n => n !== this.#inprogressChildChange?.[ChangeIndex.NODE],\n          );\n        }\n      } else if (!hasInprogressChildChangeBeenPushedForMinParentNode) {\n        overlaidRelatedChildNodes = [\n          ...generateWithOverlayNoYield(\n            relatedChildNodes,\n            this.#inprogressChildChange,\n            this.#child.getSchema(),\n          ),\n        ];\n      }\n    }\n\n    // yield node if after the overlay it still has relationship nodes\n    if (overlaidRelatedChildNodes.length > 0) {\n      yield {\n        ...minParentNode,\n        relationships: {\n          ...minParentNode.relationships,\n          [this.#relationshipName]: () => overlaidRelatedChildNodes,\n        },\n      };\n    }\n  }\n\n  *#pushChild(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n      case ChangeType.REMOVE:\n        yield* this.#pushChildChange(change);\n        break;\n      case ChangeType.EDIT: {\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#childKey,\n          ),\n          `Child edit must not change relationship.`,\n        );\n        yield* this.#pushChildChange(change, true);\n        break;\n      }\n      case ChangeType.CHILD:\n        yield* this.#pushChildChange(change, true);\n        break;\n    }\n  }\n\n  *#pushChildChange(change: Change, exists?: boolean): Stream<'yield'> {\n    this.#inprogressChildChange = change;\n    this.#inprogressChildChangePosition = undefined;\n    try {\n      const constraint = buildJoinConstraint(\n        change[ChangeIndex.NODE].row,\n        this.#childKey,\n        this.#parentKey,\n      );\n      const parentNodeStream = constraint\n        ? this.#parent.fetch({constraint})\n        : [];\n      for (const parentNode of parentNodeStream) {\n        if (parentNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        this.#inprogressChildChange = change;\n        this.#inprogressChildChangePosition = parentNode.row;\n        const childNodeStream = () => {\n          const constraint = buildJoinConstraint(\n            parentNode.row,\n            this.#parentKey,\n            this.#childKey,\n          );\n          return constraint ? this.#child.fetch({constraint}) : [];\n        };\n        if (!exists) {\n          for (const childNode of childNodeStream()) {\n            if (childNode === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            if (\n              this.#child\n                .getSchema()\n                .compareRows(childNode.row, change[ChangeIndex.NODE].row) !== 0\n            ) {\n              exists = true;\n              break;\n            }\n          }\n        }\n        if (exists) {\n          yield* this.#output.push(\n            makeChildChange(\n              {\n                ...parentNode,\n                relationships: {\n                  ...parentNode.relationships,\n                  [this.#relationshipName]: childNodeStream,\n                },\n              },\n              {\n                relationshipName: this.#relationshipName,\n                change,\n              },\n            ),\n            this,\n          );\n        } else {\n          const newNode = {\n            ...parentNode,\n            relationships: {\n              ...parentNode.relationships,\n              [this.#relationshipName]: () => [change[ChangeIndex.NODE]],\n            },\n          };\n          yield* this.#output.push(\n            change[ChangeIndex.TYPE] === ChangeType.ADD\n              ? makeAddChange(newNode)\n              : makeRemoveChange(newNode),\n            this,\n          );\n        }\n      }\n    } finally {\n      this.#inprogressChildChange = undefined;\n    }\n  }\n\n  *#pushParent(change: Change): Stream<'yield'> {\n    const childNodeStream = (node: Node) => () => {\n      const constraint = buildJoinConstraint(\n        node.row,\n        this.#parentKey,\n        this.#childKey,\n      );\n      return constraint ? this.#child.fetch({constraint}) : [];\n    };\n\n    const flip = (node: Node) => ({\n      ...node,\n      relationships: {\n        ...node.relationships,\n        [this.#relationshipName]: childNodeStream(node),\n      },\n    });\n\n    // If no related child don't push as this is an inner join.\n    let hasRelatedChild = false;\n    for (const node of childNodeStream(change[ChangeIndex.NODE])()) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      } else {\n        hasRelatedChild = true;\n        break;\n      }\n    }\n    if (!hasRelatedChild) {\n      return;\n    }\n\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        yield* this.#output.push(\n          makeAddChange(flip(change[ChangeIndex.NODE])),\n          this,\n        );\n        break;\n      case ChangeType.REMOVE:\n        yield* this.#output.push(\n          makeRemoveChange(flip(change[ChangeIndex.NODE])),\n          this,\n        );\n        break;\n      case ChangeType.CHILD: {\n        yield* this.#output.push(\n          makeChildChange(\n            flip(change[ChangeIndex.NODE]),\n            change[ChangeIndex.CHILD_DATA],\n          ),\n          this,\n        );\n        break;\n      }\n      case ChangeType.EDIT: {\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#parentKey,\n          ),\n          `Parent edit must not change relationship.`,\n        );\n        yield* this.#output.push(\n          makeEditChange(\n            flip(change[ChangeIndex.NODE]),\n            flip(change[ChangeIndex.OLD_NODE]),\n          ),\n          this,\n        );\n        break;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n}\n\n/**\n * Canonical string key over `keys` of `record`, used by `#fetchMergeSort`\n * both to dedupe per-child fetches and to map each returned parent row\n * back to the children that referenced its parent-key tuple.\n *\n * Exported for testing.\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 | bigint | undefined): string {\n  // Tag by type so we don't conflate e.g. `1` (number) with `\"1\"` (string).\n  // Bigint shows up at runtime when zqlite's safeIntegers is on, even\n  // though the static `Value` type doesn't list it.\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 === 'bigint') return 'b' + (v as bigint).toString();\n  if (t === 'boolean') return v ? 't' : 'f';\n  return 'j' + JSON.stringify(v);\n}\n"],"mappings":"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"}
+{"version":3,"file":"flipped-join.js","names":["#parent","#child","#parentKey","#childKey","#relationshipName","#schema","#pushParent","#pushChild","#output","#inprogressChildChange","#fetchBatched","#fetchChunked","#yieldParentWithOverlay","#inprogressChildChangePosition","#pushChildChange"],"sources":["../../../../../zql/src/ivm/flipped-join.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {binarySearch} from '../../../shared/src/binary-search.ts';\nimport type {CompoundKey, System} 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 {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport {constraintsAreCompatible, type Constraint} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport {\n  buildJoinConstraint,\n  generateWithOverlayNoYield,\n  isJoinMatch,\n  rowEqualsForCompoundKey,\n} from './join-utils.ts';\nimport {mergeSortedStreams} from './memory-source.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type MultiConstraint,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * Maximum number of entries sent in a single batched `parent.fetch`\n * call. Larger child-node sets are split into multiple fetches whose\n * sorted streams are merged in JS.\n *\n * Why bound this:\n *  - **Bounded fetch on early termination.** `mergeSortedStreams` primes\n *    one row from every chunk before yielding the first output, so all\n *    chunks open their cursors up front. Smaller chunks cap the\n *    worst-case overfetch when downstream `Take` consumes only a few\n *    rows — at chunk N, we may waste up to ~N index seeks before\n *    `.return()` propagates.\n *  - **Parameter limit.** Well under SQLite's default\n *    `SQLITE_MAX_VARIABLE_NUMBER` (32766). Compound keys multiply the\n *    parameter count by key length, so we leave headroom.\n *\n * Tested 64/128/256; 256 had the best worst-case across planner suites\n * and perf tests.\n *\n * We should, however, start doing shadow tests of the planner\n * against cloudzero queries.\n */\nconst MULTI_CONSTRAINT_CHUNK_SIZE = 256;\n\n// Mutable test seam — production code reads this via the getter.\nlet multiConstraintChunkSize: number = MULTI_CONSTRAINT_CHUNK_SIZE;\n\nexport function getMultiConstraintChunkSize(): number {\n  return multiConstraintChunkSize;\n}\n\n/** Test only. Returns a restore function. */\nexport function setMultiConstraintChunkSizeForTest(size: number): () => void {\n  const prev = multiConstraintChunkSize;\n  multiConstraintChunkSize = size;\n  return () => {\n    multiConstraintChunkSize = prev;\n  };\n}\n\ntype Args = {\n  parent: Input;\n  child: Input;\n  // The nth key in childKey corresponds to the nth key in parentKey.\n  parentKey: CompoundKey;\n  childKey: CompoundKey;\n\n  relationshipName: string;\n  hidden: boolean;\n  system: System;\n};\n\n/**\n * An *inner* join which fetches nodes from its child input first and then\n * fetches their related nodes from its parent input.  Output nodes are the\n * nodes from parent input (in parent input order), which have at least one\n * related child.  These output nodes have a new relationship added to them,\n * which has the name `relationshipName`. The value of the relationship is a\n * stream of related nodes from the child input (in child input order).\n */\nexport class FlippedJoin implements Input {\n  readonly #parent: Input;\n  readonly #child: Input;\n  readonly #parentKey: CompoundKey;\n  readonly #childKey: CompoundKey;\n  readonly #relationshipName: string;\n  readonly #schema: SourceSchema;\n\n  #output: Output = throwOutput;\n\n  #inprogressChildChange: Change | undefined;\n  #inprogressChildChangePosition: Row | undefined;\n\n  constructor({\n    parent,\n    child,\n    parentKey,\n    childKey,\n    relationshipName,\n    hidden,\n    system,\n  }: Args) {\n    assert(parent !== child, 'Parent and child must be different operators');\n    assert(\n      parentKey.length === childKey.length,\n      'The parentKey and childKey keys must have same length',\n    );\n    this.#parent = parent;\n    this.#child = child;\n    this.#parentKey = parentKey;\n    this.#childKey = childKey;\n    this.#relationshipName = relationshipName;\n\n    const parentSchema = parent.getSchema();\n    const childSchema = child.getSchema();\n    this.#schema = {\n      ...parentSchema,\n      relationships: {\n        ...parentSchema.relationships,\n        [relationshipName]: {\n          ...childSchema,\n          isHidden: hidden,\n          system,\n        },\n      },\n    };\n\n    parent.setOutput({\n      push: (change: Change) => this.#pushParent(change),\n    });\n    child.setOutput({\n      push: (change: Change) => this.#pushChild(change),\n    });\n  }\n\n  destroy(): void {\n    this.#child.destroy();\n    this.#parent.destroy();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    // Translate constraints for the parent on parts of the join key to\n    // constraints for the child.\n    const childConstraint: Record<string, Value> = {};\n    let hasChildConstraint = false;\n    if (req.constraint) {\n      for (const [key, value] of Object.entries(req.constraint)) {\n        const index = this.#parentKey.indexOf(key);\n        if (index !== -1) {\n          hasChildConstraint = true;\n          childConstraint[this.#childKey[index]] = value;\n        }\n      }\n    }\n\n    const childNodes: Node[] = [];\n    for (const node of this.#child.fetch(\n      hasChildConstraint ? {constraint: childConstraint} : {},\n    )) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      childNodes.push(node);\n    }\n\n    // FlippedJoin's split-push change overlay logic is largely\n    // the same as Join's with the exception of remove.  For remove,\n    // the change is undone here, and then re-applied to parents with order\n    // less than or equal to change.position below.  This is necessary\n    // because if the removed node was the last related child, the\n    // related parents with position greater than change.position\n    // (which should not yet have the node removed), would not even\n    // be fetched here, and would be absent from the output all together.\n    if (this.#inprogressChildChange?.[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const removedNode = this.#inprogressChildChange[ChangeIndex.NODE];\n      const compare = this.#child.getSchema().compareRows;\n      const insertPos = binarySearch(childNodes.length, i =>\n        compare(removedNode.row, childNodes[i].row),\n      );\n      childNodes.splice(insertPos, 0, removedNode);\n    }\n\n    yield* this.#fetchBatched(req, childNodes);\n  }\n\n  /**\n   * Fetches parents for `childNodes` in batched calls, using\n   * `multiConstraint` so the source can issue one query per chunk (e.g.\n   * SQL `IN` with index-aware seek) instead of N per-child cursors.\n   *\n   * Multi-constraint values are split into chunks of `CHUNK_SIZE`, so\n   * SQL `IN` lists stay bounded — predictable plans, statement-cache\n   * hits across calls of the same chunk size, well below SQLite's\n   * parameter limit.\n   *\n   * Within each chunk, the source returns parents in `compareRows` order.\n   * Across chunks, we merge with `mergeSortedStreams` so the overall\n   * stream is also in order. Note: the merge primes one row from every\n   * chunk before yielding the first output, so all chunks open their\n   * cursors up front. Early termination downstream then prevents any\n   * further work on un-advanced chunks (cursors get `.return()`'d via\n   * `mergeSortedStreams`'s finally block).\n   *\n   * Replaces the previous split between `#fetchMergeSort` and\n   * `#fetchQuicksort`. The unique-vs-not distinction is no longer needed:\n   * the source handles cardinality (single index seek for each value) and\n   * ordering (SQL `ORDER BY` / index walk).\n   */\n  *#fetchBatched(\n    req: FetchRequest,\n    childNodes: Node[],\n  ): Stream<Node | 'yield'> {\n    const parentReqConstraint = req.constraint;\n    const parentKey = this.#parentKey;\n    const childKey = this.#childKey;\n\n    // Build (deduped) multi-constraint and a key→child-indexes map. Same\n    // parent-key value across multiple children groups them together.\n    const computedMulti: Constraint[] = [];\n    const childIndexesByKey = new Map<string, number[]>();\n    for (let i = 0; i < childNodes.length; i++) {\n      const constraintFromChild = buildJoinConstraint(\n        childNodes[i].row,\n        childKey,\n        parentKey,\n      );\n      if (\n        !constraintFromChild ||\n        (parentReqConstraint &&\n          !constraintsAreCompatible(constraintFromChild, parentReqConstraint))\n      ) {\n        continue;\n      }\n      const key = canonicalKey(constraintFromChild, parentKey);\n      const existing = childIndexesByKey.get(key);\n      if (existing === undefined) {\n        childIndexesByKey.set(key, [i]);\n        computedMulti.push(constraintFromChild);\n      } else {\n        existing.push(i);\n      }\n    }\n\n    if (computedMulti.length === 0) {\n      return;\n    }\n\n    // Source returns parents in compareRows order within each chunk.\n    // Merge across chunks to yield a globally ordered stream.\n    const compareRows = this.#schema.compareRows;\n    const compare: (a: Node, b: Node) => number = req.reverse\n      ? (a, b) => compareRows(b.row, a.row)\n      : (a, b) => compareRows(a.row, b.row);\n\n    // Append our computed multi to whatever req.multiConstraints already\n    // contained — chained FlippedJoins each contribute one entry, so the\n    // source ANDs them all (e.g. `assigneeID IN (…) AND creatorID IN (…)`).\n    const incoming = req.multiConstraints ?? [];\n    const parentStream =\n      computedMulti.length <= multiConstraintChunkSize\n        ? this.#parent.fetch({\n            ...req,\n            multiConstraints: [...incoming, computedMulti],\n          })\n        : this.#fetchChunked(req, incoming, computedMulti, compare);\n\n    for (const node of parentStream) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      const key = canonicalKey(node.row, parentKey);\n      const idxs = childIndexesByKey.get(key);\n      if (idxs === undefined) {\n        // This row's parent-key doesn't match any of our computed\n        // multi-constraint entries. Happens when our parent is an\n        // intermediate operator (e.g. a chained FlippedJoin) that passes\n        // multiConstraints through unchanged instead of filtering — see\n        // FetchRequest.multiConstraints contract. The lookup miss here\n        // performs the required filter, so just skip the row.\n        continue;\n      }\n      // Children retain their original input order within the group\n      // because we appended to `idxs` in iteration order.\n      const relatedChildNodes: Node[] = idxs.map(i => childNodes[i]);\n      yield* this.#yieldParentWithOverlay(node, relatedChildNodes);\n    }\n  }\n\n  *#fetchChunked(\n    req: FetchRequest,\n    incomingMultis: readonly MultiConstraint[],\n    computedMulti: MultiConstraint,\n    compare: (a: Node, b: Node) => number,\n  ): Stream<Node | 'yield'> {\n    const chunkStreams: Stream<Node | 'yield'>[] = [];\n    for (let i = 0; i < computedMulti.length; i += multiConstraintChunkSize) {\n      chunkStreams.push(\n        this.#parent.fetch({\n          ...req,\n          multiConstraints: [\n            ...incomingMultis,\n            computedMulti.slice(i, i + multiConstraintChunkSize),\n          ],\n        }),\n      );\n    }\n    yield* mergeSortedStreams(chunkStreams, compare);\n  }\n\n  *#yieldParentWithOverlay(\n    minParentNode: Node,\n    relatedChildNodes: Node[],\n  ): Stream<Node> {\n    let overlaidRelatedChildNodes = relatedChildNodes;\n    if (\n      this.#inprogressChildChange &&\n      this.#inprogressChildChangePosition &&\n      isJoinMatch(\n        this.#inprogressChildChange[ChangeIndex.NODE].row,\n        this.#childKey,\n        minParentNode.row,\n        this.#parentKey,\n      )\n    ) {\n      const hasInprogressChildChangeBeenPushedForMinParentNode =\n        this.#parent\n          .getSchema()\n          .compareRows(\n            minParentNode.row,\n            this.#inprogressChildChangePosition,\n          ) <= 0;\n      if (this.#inprogressChildChange[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n        if (hasInprogressChildChangeBeenPushedForMinParentNode) {\n          // Remove from relatedChildNodes since the removed child\n          // was inserted into childNodes above.\n          overlaidRelatedChildNodes = relatedChildNodes.filter(\n            n => n !== this.#inprogressChildChange?.[ChangeIndex.NODE],\n          );\n        }\n      } else if (!hasInprogressChildChangeBeenPushedForMinParentNode) {\n        overlaidRelatedChildNodes = [\n          ...generateWithOverlayNoYield(\n            relatedChildNodes,\n            this.#inprogressChildChange,\n            this.#child.getSchema(),\n          ),\n        ];\n      }\n    }\n\n    // yield node if after the overlay it still has relationship nodes\n    if (overlaidRelatedChildNodes.length > 0) {\n      yield {\n        ...minParentNode,\n        relationships: {\n          ...minParentNode.relationships,\n          [this.#relationshipName]: () => overlaidRelatedChildNodes,\n        },\n      };\n    }\n  }\n\n  *#pushChild(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n      case ChangeType.REMOVE:\n        yield* this.#pushChildChange(change);\n        break;\n      case ChangeType.EDIT: {\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#childKey,\n          ),\n          `Child edit must not change relationship.`,\n        );\n        yield* this.#pushChildChange(change, true);\n        break;\n      }\n      case ChangeType.CHILD:\n        yield* this.#pushChildChange(change, true);\n        break;\n    }\n  }\n\n  *#pushChildChange(change: Change, exists?: boolean): Stream<'yield'> {\n    this.#inprogressChildChange = change;\n    this.#inprogressChildChangePosition = undefined;\n    try {\n      const constraint = buildJoinConstraint(\n        change[ChangeIndex.NODE].row,\n        this.#childKey,\n        this.#parentKey,\n      );\n      const parentNodeStream = constraint\n        ? this.#parent.fetch({constraint})\n        : [];\n      for (const parentNode of parentNodeStream) {\n        if (parentNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        this.#inprogressChildChange = change;\n        this.#inprogressChildChangePosition = parentNode.row;\n        const childNodeStream = () => {\n          const constraint = buildJoinConstraint(\n            parentNode.row,\n            this.#parentKey,\n            this.#childKey,\n          );\n          return constraint ? this.#child.fetch({constraint}) : [];\n        };\n        if (!exists) {\n          for (const childNode of childNodeStream()) {\n            if (childNode === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            if (\n              this.#child\n                .getSchema()\n                .compareRows(childNode.row, change[ChangeIndex.NODE].row) !== 0\n            ) {\n              exists = true;\n              break;\n            }\n          }\n        }\n        if (exists) {\n          yield* this.#output.push(\n            makeChildChange(\n              {\n                ...parentNode,\n                relationships: {\n                  ...parentNode.relationships,\n                  [this.#relationshipName]: childNodeStream,\n                },\n              },\n              {\n                relationshipName: this.#relationshipName,\n                change,\n              },\n            ),\n            this,\n          );\n        } else {\n          const newNode = {\n            ...parentNode,\n            relationships: {\n              ...parentNode.relationships,\n              [this.#relationshipName]: () => [change[ChangeIndex.NODE]],\n            },\n          };\n          yield* this.#output.push(\n            change[ChangeIndex.TYPE] === ChangeType.ADD\n              ? makeAddChange(newNode)\n              : makeRemoveChange(newNode),\n            this,\n          );\n        }\n      }\n    } finally {\n      this.#inprogressChildChange = undefined;\n    }\n  }\n\n  *#pushParent(change: Change): Stream<'yield'> {\n    const childNodeStream = (node: Node) => () => {\n      const constraint = buildJoinConstraint(\n        node.row,\n        this.#parentKey,\n        this.#childKey,\n      );\n      return constraint ? this.#child.fetch({constraint}) : [];\n    };\n\n    const flip = (node: Node) => ({\n      ...node,\n      relationships: {\n        ...node.relationships,\n        [this.#relationshipName]: childNodeStream(node),\n      },\n    });\n\n    // If no related child don't push as this is an inner join.\n    let hasRelatedChild = false;\n    for (const node of childNodeStream(change[ChangeIndex.NODE])()) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      } else {\n        hasRelatedChild = true;\n        break;\n      }\n    }\n    if (!hasRelatedChild) {\n      return;\n    }\n\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        yield* this.#output.push(\n          makeAddChange(flip(change[ChangeIndex.NODE])),\n          this,\n        );\n        break;\n      case ChangeType.REMOVE:\n        yield* this.#output.push(\n          makeRemoveChange(flip(change[ChangeIndex.NODE])),\n          this,\n        );\n        break;\n      case ChangeType.CHILD: {\n        yield* this.#output.push(\n          makeChildChange(\n            flip(change[ChangeIndex.NODE]),\n            change[ChangeIndex.CHILD_DATA],\n          ),\n          this,\n        );\n        break;\n      }\n      case ChangeType.EDIT: {\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#parentKey,\n          ),\n          `Parent edit must not change relationship.`,\n        );\n        yield* this.#output.push(\n          makeEditChange(\n            flip(change[ChangeIndex.NODE]),\n            flip(change[ChangeIndex.OLD_NODE]),\n          ),\n          this,\n        );\n        break;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n}\n\n// Test seam with a widened record type — canonicalValue handles bigint\n// at runtime (zqlite's safeIntegers) but `Value` doesn't list it.\nexport function canonicalKeyForTest(\n  record: Record<string, Value | bigint | undefined>,\n  keys: CompoundKey,\n): string {\n  return canonicalKey(record as Record<string, Value | undefined>, keys);\n}\n\n/**\n * Canonical string key over `keys` of `record`, used by `#fetchBatched`\n * both to dedupe `multiConstraint` entries (record = Constraint) and to\n * map each returned parent row back to the children that referenced its\n * parent-key tuple (record = Row).\n */\nfunction 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 | bigint | undefined): string {\n  // Tag by type so we don't conflate e.g. `1` (number) with `\"1\"` (string).\n  // Bigint shows up at runtime when zqlite's safeIntegers is on, even\n  // though the static `Value` type doesn't list it.\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 === 'bigint') return 'b' + (v as bigint).toString();\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-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"],"mappings":";;;AAUA,SAAgB,2BACd,QACA,SACA,QACc;CACd,OAAO,oBAAoB,QAAQ,SAAS,MAAM;AACpD;AAEA,UAAiB,oBACf,QACA,SACA,QACwB;CACxB,IAAI,UAAU;CACd,IAAI,iBAAiB;CACrB,IAAI,iBAAiB;CACrB,KAAK,MAAM,QAAQ,QAAQ;EACzB,IAAI,SAAS,SAAS;GACpB,MAAM;GACN;EACF;EACA,IAAI,YAAY;EAChB,IAAI,CAAC,SACH,QAAQ,QAAQ,IAAhB;GACE,KAAK;IACH,IACE,OAAO,YAAY,QAAQ,GAAkB,KAAK,KAAK,GAAG,MAAM,GAChE;KACA,UAAU;KACV,YAAY;IACd;IACA;GAEF,KAAK;IACH,IAAI,OAAO,YAAY,QAAQ,GAAkB,KAAK,KAAK,GAAG,IAAI,GAAG;KACnE,UAAU;KACV,MAAM,QAAQ;IAChB;IACA;GAEF,KAAK;IACH,IACE,CAAC,kBACD,OAAO,YAAY,QAAQ,GAAsB,KAAK,KAAK,GAAG,IAAI,GAClE;KACA,iBAAiB;KACjB,IAAI,gBACF,UAAU;KAEZ,MAAM,QAAQ;IAChB;IACA,IACE,CAAC,kBACD,OAAO,YAAY,QAAQ,GAAkB,KAAK,KAAK,GAAG,MAAM,GAChE;KACA,iBAAiB;KACjB,IAAI,gBACF,UAAU;KAEZ,YAAY;IACd;IACA;GAEF,KAAK;IACH,IACE,OAAO,YAAY,QAAQ,GAAkB,KAAK,KAAK,GAAG,MAAM,GAChE;KACA,UAAU;KACV,MAAM;MACJ,KAAK,KAAK;MACV,eAAe;OACb,GAAG,KAAK;QACP,QAAQ,GAAwB,yBAC/B,oBACE,KAAK,cACH,QAAQ,GAAwB,kBAChC,GACF,QAAQ,GAAwB,QAChC,OAAO,cACL,QAAQ,GAAwB,iBAEpC;MACJ;KACF;KACA,YAAY;IACd;IACA;EAEJ;EAEF,IAAI,WACF,MAAM;CAEV;CACA,IAAI,CAAC;MACC,QAAQ,OAAsB,GAAmB;GACnD,UAAU;GACV,MAAM,QAAQ;EAChB,OAAO,IAAI,QAAQ,OAAsB,GAAiB;GACxD,OACE,gBACA,wDACF;GACA,iBAAiB;GACjB,UAAU;GACV,MAAM,QAAQ;EAChB;;CAGF,OACE,SACA,iEACF;AACF;AAUA,UAAiB,6BACf,QACA,SACA,QACwB;CAExB,IAAI,QAAQ,OAAsB,GAChC,MAAM,QAAQ;MACT,IAAI,QAAQ,OAAsB,GACvC,MAAM,QAAQ;CAIhB,IAAI,aAAa;CACjB,KAAK,MAAM,QAAQ,QAAQ;EACzB,IAAI,SAAS,SAAS;GACpB,MAAM;GACN;EACF;EACA,IAAI,CAAC,YAAY;GACf,IACE,QAAQ,OAAsB,KAC9B,QAAQ,OAAsB;QAG5B,wBACE,QAAQ,GAAkB,KAC1B,KAAK,KACL,OAAO,UACT,GACA;KACA,aAAa;KACb;IACF;;GAEF,IAAI,QAAQ,OAAsB;QAE9B,wBACE,QAAQ,GAAkB,KAC1B,KAAK,KACL,OAAO,UACT,GACA;KACA,aAAa;KACb,MAAM;MACJ,KAAK,KAAK;MACV,eAAe;OACb,GAAG,KAAK;QACP,QAAQ,GAAwB,yBAC/B,oBACE,KAAK,cACH,QAAQ,GAAwB,kBAChC,GACF,QAAQ,GAAwB,QAChC,OAAO,cACL,QAAQ,GAAwB,iBAEpC;MACJ;KACF;KACA;IACF;;EAEJ;EACA,MAAM;CACR;CACA,OACE,cAAc,QAAQ,OAAsB,GAC5C,iEACF;AACF;AAEA,SAAgB,wBACd,GACA,GACA,KACS;CACT,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAC9B,IAAI,cAAc,EAAE,IAAI,KAAK,EAAE,IAAI,GAAG,MAAM,GAC1C,OAAO;CAGX,OAAO;AACT;AAEA,SAAgB,YACd,QACA,WACA,OACA,UACA;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KACpC,IAAI,CAAC,YAAY,OAAO,UAAU,KAAK,MAAM,SAAS,GAAG,GACvD,OAAO;CAGX,OAAO;AACT;;;;;;AAOA,SAAgB,oBACd,WACA,WACA,WACmC;CACnC,MAAM,aAAoC,CAAC;CAC3C,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,QAAQ,UAAU,UAAU;EAClC,IAAI,UAAU,MACZ;EAEF,WAAW,UAAU,MAAM;CAC7B;CACA,OAAO;AACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"join.js","names":["#parent","#child","#parentKey","#childKey","#relationshipName","#schema","#pushParent","#pushChild","#output","#processParentNode","#pushChildChange","#inprogressChildChange","#inprogressChildChangePosition"],"sources":["../../../../../zql/src/ivm/join.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey, System} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Node} from './data.ts';\nimport {\n  buildJoinConstraint,\n  generateWithOverlay,\n  generateWithOverlayUnordered,\n  isJoinMatch,\n  rowEqualsForCompoundKey,\n} from './join-utils.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\ntype Args = {\n  parent: Input;\n  child: Input;\n  // The nth key in parentKey corresponds to the nth key in childKey.\n  parentKey: CompoundKey;\n  childKey: CompoundKey;\n  relationshipName: string;\n  hidden: boolean;\n  system: System;\n};\n\n/**\n * The Join operator joins the output from two upstream inputs. Zero's join\n * is a little different from SQL's join in that we output hierarchical data,\n * not a flat table. This makes it a lot more useful for UI programming and\n * avoids duplicating tons of data like left join would.\n *\n * The Nodes output from Join have a new relationship added to them, which has\n * the name #relationshipName. The value of the relationship is a stream of\n * child nodes which are the corresponding values from the child source.\n */\nexport class Join implements Input {\n  readonly #parent: Input;\n  readonly #child: Input;\n  readonly #parentKey: CompoundKey;\n  readonly #childKey: CompoundKey;\n  readonly #relationshipName: string;\n  readonly #schema: SourceSchema;\n\n  #output: Output = throwOutput;\n\n  #inprogressChildChange: Change | undefined;\n  #inprogressChildChangePosition: Row | undefined;\n\n  constructor({\n    parent,\n    child,\n    parentKey,\n    childKey,\n    relationshipName,\n    hidden,\n    system,\n  }: Args) {\n    assert(parent !== child, 'Parent and child must be different operators');\n    assert(\n      parentKey.length === childKey.length,\n      'The parentKey and childKey keys must have same length',\n    );\n    this.#parent = parent;\n    this.#child = child;\n    this.#parentKey = parentKey;\n    this.#childKey = childKey;\n    this.#relationshipName = relationshipName;\n\n    const parentSchema = parent.getSchema();\n    const childSchema = child.getSchema();\n    this.#schema = {\n      ...parentSchema,\n      relationships: {\n        ...parentSchema.relationships,\n        [relationshipName]: {\n          ...childSchema,\n          isHidden: hidden,\n          system,\n        },\n      },\n    };\n\n    parent.setOutput({\n      push: (change: Change) => this.#pushParent(change),\n    });\n    child.setOutput({\n      push: (change: Change) => this.#pushChild(change),\n    });\n  }\n\n  destroy(): void {\n    this.#parent.destroy();\n    this.#child.destroy();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    for (const parentNode of this.#parent.fetch(req)) {\n      if (parentNode === 'yield') {\n        yield parentNode;\n        continue;\n      }\n      yield this.#processParentNode(parentNode.row, parentNode.relationships);\n    }\n  }\n\n  *#pushParent(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        yield* this.#output.push(\n          makeAddChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      case ChangeType.REMOVE:\n        yield* this.#output.push(\n          makeRemoveChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      case ChangeType.CHILD:\n        yield* this.#output.push(\n          makeChildChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n            change[ChangeIndex.CHILD_DATA],\n          ),\n          this,\n        );\n        break;\n      case ChangeType.EDIT: {\n        // Assert the edit could not change the relationship.\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#parentKey,\n          ),\n          `Parent edit must not change relationship.`,\n        );\n        yield* this.#output.push(\n          makeEditChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n            this.#processParentNode(\n              change[ChangeIndex.OLD_NODE].row,\n              change[ChangeIndex.OLD_NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n\n  *#pushChild(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n      case ChangeType.REMOVE:\n        yield* this.#pushChildChange(change[ChangeIndex.NODE].row, change);\n        break;\n      case ChangeType.CHILD:\n        yield* this.#pushChildChange(change[ChangeIndex.NODE].row, change);\n        break;\n      case ChangeType.EDIT: {\n        const childRow = change[ChangeIndex.NODE].row;\n        const oldChildRow = change[ChangeIndex.OLD_NODE].row;\n        // Assert the edit could not change the relationship.\n        assert(\n          rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey),\n          'Child edit must not change relationship.',\n        );\n        yield* this.#pushChildChange(childRow, change);\n        break;\n      }\n\n      default:\n        unreachable(change);\n    }\n  }\n\n  *#pushChildChange(childRow: Row, change: Change): Stream<'yield'> {\n    this.#inprogressChildChange = change;\n    this.#inprogressChildChangePosition = undefined;\n    try {\n      const constraint = buildJoinConstraint(\n        childRow,\n        this.#childKey,\n        this.#parentKey,\n      );\n      if (constraint) {\n        for (const parentNode of this.#parent.fetch({constraint})) {\n          if (parentNode === 'yield') {\n            yield parentNode;\n            continue;\n          }\n          this.#inprogressChildChangePosition = parentNode.row;\n          const childChange = makeChildChange(\n            this.#processParentNode(parentNode.row, parentNode.relationships),\n            {\n              relationshipName: this.#relationshipName,\n              change,\n            },\n          );\n          yield* this.#output.push(childChange, this);\n        }\n      }\n    } finally {\n      this.#inprogressChildChange = undefined;\n    }\n  }\n\n  #processParentNode(\n    parentNodeRow: Row,\n    parentNodeRelations: Record<string, () => Stream<Node | 'yield'>>,\n  ): Node {\n    const childStream = () => {\n      const constraint = buildJoinConstraint(\n        parentNodeRow,\n        this.#parentKey,\n        this.#childKey,\n      );\n      const stream = constraint ? this.#child.fetch({constraint}) : [];\n\n      if (\n        this.#inprogressChildChange &&\n        isJoinMatch(\n          parentNodeRow,\n          this.#parentKey,\n          this.#inprogressChildChange[ChangeIndex.NODE].row,\n          this.#childKey,\n        ) &&\n        this.#inprogressChildChangePosition &&\n        this.#schema.compareRows(\n          parentNodeRow,\n          this.#inprogressChildChangePosition,\n        ) > 0\n      ) {\n        const childSchema = this.#child.getSchema();\n        if (childSchema.sort === undefined) {\n          return generateWithOverlayUnordered(\n            stream,\n            this.#inprogressChildChange,\n            childSchema,\n          );\n        }\n        return generateWithOverlay(\n          stream,\n          this.#inprogressChildChange,\n          childSchema,\n        );\n      }\n      return stream;\n    };\n\n    return {\n      row: parentNodeRow,\n      relationships: {\n        ...parentNodeRelations,\n        [this.#relationshipName]: childStream,\n      },\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"join.js","names":["#parent","#child","#parentKey","#childKey","#relationshipName","#schema","#pushParent","#pushChild","#output","#processParentNode","#pushChildChange","#inprogressChildChange","#inprogressChildChangePosition"],"sources":["../../../../../zql/src/ivm/join.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey, System} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Node} from './data.ts';\nimport {\n  buildJoinConstraint,\n  generateWithOverlay,\n  generateWithOverlayUnordered,\n  isJoinMatch,\n  rowEqualsForCompoundKey,\n} from './join-utils.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\ntype Args = {\n  parent: Input;\n  child: Input;\n  // The nth key in parentKey corresponds to the nth key in childKey.\n  parentKey: CompoundKey;\n  childKey: CompoundKey;\n  relationshipName: string;\n  hidden: boolean;\n  system: System;\n};\n\n/**\n * The Join operator joins the output from two upstream inputs. Zero's join\n * is a little different from SQL's join in that we output hierarchical data,\n * not a flat table. This makes it a lot more useful for UI programming and\n * avoids duplicating tons of data like left join would.\n *\n * The Nodes output from Join have a new relationship added to them, which has\n * the name #relationshipName. The value of the relationship is a stream of\n * child nodes which are the corresponding values from the child source.\n */\nexport class Join implements Input {\n  readonly #parent: Input;\n  readonly #child: Input;\n  readonly #parentKey: CompoundKey;\n  readonly #childKey: CompoundKey;\n  readonly #relationshipName: string;\n  readonly #schema: SourceSchema;\n\n  #output: Output = throwOutput;\n\n  #inprogressChildChange: Change | undefined;\n  #inprogressChildChangePosition: Row | undefined;\n\n  constructor({\n    parent,\n    child,\n    parentKey,\n    childKey,\n    relationshipName,\n    hidden,\n    system,\n  }: Args) {\n    assert(parent !== child, 'Parent and child must be different operators');\n    assert(\n      parentKey.length === childKey.length,\n      'The parentKey and childKey keys must have same length',\n    );\n    this.#parent = parent;\n    this.#child = child;\n    this.#parentKey = parentKey;\n    this.#childKey = childKey;\n    this.#relationshipName = relationshipName;\n\n    const parentSchema = parent.getSchema();\n    const childSchema = child.getSchema();\n    this.#schema = {\n      ...parentSchema,\n      relationships: {\n        ...parentSchema.relationships,\n        [relationshipName]: {\n          ...childSchema,\n          isHidden: hidden,\n          system,\n        },\n      },\n    };\n\n    parent.setOutput({\n      push: (change: Change) => this.#pushParent(change),\n    });\n    child.setOutput({\n      push: (change: Change) => this.#pushChild(change),\n    });\n  }\n\n  destroy(): void {\n    this.#parent.destroy();\n    this.#child.destroy();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    for (const parentNode of this.#parent.fetch(req)) {\n      if (parentNode === 'yield') {\n        yield parentNode;\n        continue;\n      }\n      yield this.#processParentNode(parentNode.row, parentNode.relationships);\n    }\n  }\n\n  *#pushParent(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        yield* this.#output.push(\n          makeAddChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      case ChangeType.REMOVE:\n        yield* this.#output.push(\n          makeRemoveChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      case ChangeType.CHILD:\n        yield* this.#output.push(\n          makeChildChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n            change[ChangeIndex.CHILD_DATA],\n          ),\n          this,\n        );\n        break;\n      case ChangeType.EDIT: {\n        // Assert the edit could not change the relationship.\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#parentKey,\n          ),\n          `Parent edit must not change relationship.`,\n        );\n        yield* this.#output.push(\n          makeEditChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n            this.#processParentNode(\n              change[ChangeIndex.OLD_NODE].row,\n              change[ChangeIndex.OLD_NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n\n  *#pushChild(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n      case ChangeType.REMOVE:\n        yield* this.#pushChildChange(change[ChangeIndex.NODE].row, change);\n        break;\n      case ChangeType.CHILD:\n        yield* this.#pushChildChange(change[ChangeIndex.NODE].row, change);\n        break;\n      case ChangeType.EDIT: {\n        const childRow = change[ChangeIndex.NODE].row;\n        const oldChildRow = change[ChangeIndex.OLD_NODE].row;\n        // Assert the edit could not change the relationship.\n        assert(\n          rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey),\n          'Child edit must not change relationship.',\n        );\n        yield* this.#pushChildChange(childRow, change);\n        break;\n      }\n\n      default:\n        unreachable(change);\n    }\n  }\n\n  *#pushChildChange(childRow: Row, change: Change): Stream<'yield'> {\n    this.#inprogressChildChange = change;\n    this.#inprogressChildChangePosition = undefined;\n    try {\n      const constraint = buildJoinConstraint(\n        childRow,\n        this.#childKey,\n        this.#parentKey,\n      );\n      if (constraint) {\n        for (const parentNode of this.#parent.fetch({constraint})) {\n          if (parentNode === 'yield') {\n            yield parentNode;\n            continue;\n          }\n          this.#inprogressChildChangePosition = parentNode.row;\n          const childChange = makeChildChange(\n            this.#processParentNode(parentNode.row, parentNode.relationships),\n            {\n              relationshipName: this.#relationshipName,\n              change,\n            },\n          );\n          yield* this.#output.push(childChange, this);\n        }\n      }\n    } finally {\n      this.#inprogressChildChange = undefined;\n    }\n  }\n\n  #processParentNode(\n    parentNodeRow: Row,\n    parentNodeRelations: Record<string, () => Stream<Node | 'yield'>>,\n  ): Node {\n    const childStream = () => {\n      const constraint = buildJoinConstraint(\n        parentNodeRow,\n        this.#parentKey,\n        this.#childKey,\n      );\n      const stream = constraint ? this.#child.fetch({constraint}) : [];\n\n      if (\n        this.#inprogressChildChange &&\n        isJoinMatch(\n          parentNodeRow,\n          this.#parentKey,\n          this.#inprogressChildChange[ChangeIndex.NODE].row,\n          this.#childKey,\n        ) &&\n        this.#inprogressChildChangePosition &&\n        this.#schema.compareRows(\n          parentNodeRow,\n          this.#inprogressChildChangePosition,\n        ) > 0\n      ) {\n        const childSchema = this.#child.getSchema();\n        if (childSchema.sort === undefined) {\n          return generateWithOverlayUnordered(\n            stream,\n            this.#inprogressChildChange,\n            childSchema,\n          );\n        }\n        return generateWithOverlay(\n          stream,\n          this.#inprogressChildChange,\n          childSchema,\n        );\n      }\n      return stream;\n    };\n\n    return {\n      row: parentNodeRow,\n      relationships: {\n        ...parentNodeRelations,\n        [this.#relationshipName]: childStream,\n      },\n    };\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/maybe-split-and-push-edit-change.js.map

@@ -1 +1 @@
-{"version":3,"file":"maybe-split-and-push-edit-change.js","names":[],"sources":["../../../../../zql/src/ivm/maybe-split-and-push-edit-change.ts"],"sourcesContent":["import type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {makeAddChange, makeRemoveChange, type EditChange} from './change.ts';\nimport type {InputBase, Output} from './operator.ts';\n\n/**\n * This takes an {@linkcode EditChange} and a predicate that determines if a row\n * should be present based on the row's data. It then splits the change and\n * pushes the appropriate changes to the output based on the predicate.\n */\nexport function* maybeSplitAndPushEditChange(\n  change: EditChange,\n  predicate: (row: Row) => boolean,\n  output: Output,\n  pusher: InputBase,\n) {\n  const oldWasPresent = predicate(change[ChangeIndex.OLD_NODE].row);\n  const newIsPresent = predicate(change[ChangeIndex.NODE].row);\n\n  if (oldWasPresent && newIsPresent) {\n    yield* output.push(change, pusher);\n  } else if (oldWasPresent && !newIsPresent) {\n    yield* output.push(makeRemoveChange(change[ChangeIndex.OLD_NODE]), pusher);\n  } else if (!oldWasPresent && newIsPresent) {\n    yield* output.push(makeAddChange(change[ChangeIndex.NODE]), pusher);\n  }\n}\n"],"mappings":";;;;;;;AAUA,UAAiB,4BACf,QACA,WACA,QACA,QACA;CACA,MAAM,gBAAgB,UAAU,OAAO,GAAsB,IAAI;CACjE,MAAM,eAAe,UAAU,OAAO,GAAkB,IAAI;AAE5D,KAAI,iBAAiB,aACnB,QAAO,OAAO,KAAK,QAAQ,OAAO;UACzB,iBAAiB,CAAC,aAC3B,QAAO,OAAO,KAAK,iBAAiB,OAAO,GAAsB,EAAE,OAAO;UACjE,CAAC,iBAAiB,aAC3B,QAAO,OAAO,KAAK,cAAc,OAAO,GAAkB,EAAE,OAAO"}
+{"version":3,"file":"maybe-split-and-push-edit-change.js","names":[],"sources":["../../../../../zql/src/ivm/maybe-split-and-push-edit-change.ts"],"sourcesContent":["import type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {makeAddChange, makeRemoveChange, type EditChange} from './change.ts';\nimport type {InputBase, Output} from './operator.ts';\n\n/**\n * This takes an {@linkcode EditChange} and a predicate that determines if a row\n * should be present based on the row's data. It then splits the change and\n * pushes the appropriate changes to the output based on the predicate.\n */\nexport function* maybeSplitAndPushEditChange(\n  change: EditChange,\n  predicate: (row: Row) => boolean,\n  output: Output,\n  pusher: InputBase,\n) {\n  const oldWasPresent = predicate(change[ChangeIndex.OLD_NODE].row);\n  const newIsPresent = predicate(change[ChangeIndex.NODE].row);\n\n  if (oldWasPresent && newIsPresent) {\n    yield* output.push(change, pusher);\n  } else if (oldWasPresent && !newIsPresent) {\n    yield* output.push(makeRemoveChange(change[ChangeIndex.OLD_NODE]), pusher);\n  } else if (!oldWasPresent && newIsPresent) {\n    yield* output.push(makeAddChange(change[ChangeIndex.NODE]), pusher);\n  }\n}\n"],"mappings":";;;;;;;AAUA,UAAiB,4BACf,QACA,WACA,QACA,QACA;CACA,MAAM,gBAAgB,UAAU,OAAO,GAAsB,GAAG;CAChE,MAAM,eAAe,UAAU,OAAO,GAAkB,GAAG;CAE3D,IAAI,iBAAiB,cACnB,OAAO,OAAO,KAAK,QAAQ,MAAM;MAC5B,IAAI,iBAAiB,CAAC,cAC3B,OAAO,OAAO,KAAK,iBAAiB,OAAO,EAAqB,GAAG,MAAM;MACpE,IAAI,CAAC,iBAAiB,cAC3B,OAAO,OAAO,KAAK,cAAc,OAAO,EAAiB,GAAG,MAAM;AAEtE"}