@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

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

@@ -1,57 +1,70 @@
-import { compareUTF8 } from "compare-utf8";
 import { assertBoolean, assertNumber, assertString } from "../../../shared/src/asserts.js";
+import { compareUTF8 } from "compare-utf8";
+//#region ../zql/src/ivm/data.ts
+/**
+* Compare two values. The values must be of the same type. This function
+* throws at runtime if the types differ.
+*
+* Note, this function considers `null === null` and
+* `undefined === undefined`. This is different than SQL. In join code,
+* null must be treated separately.
+*
+* See: https://github.com/rocicorp/mono/pull/2116/files#r1704811479
+*
+* @returns < 0 if a < b, 0 if a === b, > 0 if a > b
+*/
 function compareValues(a, b) {
-  a = normalizeUndefined(a);
-  b = normalizeUndefined(b);
-  if (a === b) {
-    return 0;
-  }
-  if (a === null) {
-    return -1;
-  }
-  if (b === null) {
-    return 1;
-  }
-  if (typeof a === "boolean") {
-    assertBoolean(b);
-    return a ? 1 : -1;
-  }
-  if (typeof a === "number") {
-    assertNumber(b);
-    return a - b;
-  }
-  if (typeof a === "string") {
-    assertString(b);
-    return compareUTF8(a, b);
-  }
-  throw new Error(`Unsupported type: ${a}`);
+	a = normalizeUndefined(a);
+	b = normalizeUndefined(b);
+	if (a === b) return 0;
+	if (a === null) return -1;
+	if (b === null) return 1;
+	if (typeof a === "boolean") {
+		assertBoolean(b);
+		return a ? 1 : -1;
+	}
+	if (typeof a === "number") {
+		assertNumber(b);
+		return a - b;
+	}
+	if (typeof a === "string") {
+		assertString(b);
+		return compareUTF8(a, b);
+	}
+	throw new Error(`Unsupported type: ${a}`);
 }
+/**
+* We allow undefined to be passed for the convenience of developers, but we
+* treat it equivalently to null. It's better for perf to not create an copy
+* of input values, so we just normalize at use when necessary.
+*/
 function normalizeUndefined(v) {
-  return v ?? null;
+	return v ?? null;
 }
 function makeComparator(order, reverse) {
-  return (a, b) => {
-    for (const ord of order) {
-      const field = ord[0];
-      const comp = compareValues(a[field], b[field]);
-      if (comp !== 0) {
-        const result = ord[1] === "asc" ? comp : -comp;
-        return reverse ? -result : result;
-      }
-    }
-    return 0;
-  };
+	return (a, b) => {
+		for (const ord of order) {
+			const field = ord[0];
+			const comp = compareValues(a[field], b[field]);
+			if (comp !== 0) {
+				const result = ord[1] === "asc" ? comp : -comp;
+				return reverse ? -result : result;
+			}
+		}
+		return 0;
+	};
 }
+/**
+* Determine if two values are equal. Note that unlike compareValues() above,
+* this function treats `null` as unequal to itself (and same for `undefined`).
+* This is required to make joins work correctly, but may not be the right
+* semantic for your application.
+*/
 function valuesEqual(a, b) {
-  if (a == null || b == null) {
-    return false;
-  }
-  return a === b;
+	if (a == null || b == null) return false;
+	return a === b;
 }
-export {
-  compareValues,
-  makeComparator,
-  normalizeUndefined,
-  valuesEqual
-};
-//# sourceMappingURL=data.js.map
+//#endregion
+export { compareValues, makeComparator, normalizeUndefined, valuesEqual };
+
+//# sourceMappingURL=data.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"data.js","sources":["../../../../../zql/src/ivm/data.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {\n  assertBoolean,\n  assertNumber,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport type {Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * A row flowing through the pipeline, plus its relationships.\n * Relationships are generated lazily as read.\n */\nexport type Node = {\n  row: Row;\n  /**\n   * Relationships are generated lazily as read.\n   * The stream may contain 'yield' to indicate the operator has yielded control.\n   * See {@linkcode Operator.fetch} for more details about yields.\n   */\n  relationships: Record<string, () => Stream<Node | 'yield'>>;\n};\n\n/**\n * Compare two values. The values must be of the same type. This function\n * throws at runtime if the types differ.\n *\n * Note, this function considers `null === null` and\n * `undefined === undefined`. This is different than SQL. In join code,\n * null must be treated separately.\n *\n * See: https://github.com/rocicorp/mono/pull/2116/files#r1704811479\n *\n * @returns < 0 if a < b, 0 if a === b, > 0 if a > b\n */\nexport function compareValues(a: Value, b: Value): number {\n  a = normalizeUndefined(a);\n  b = normalizeUndefined(b);\n\n  if (a === b) {\n    return 0;\n  }\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n  if (typeof a === 'boolean') {\n    assertBoolean(b);\n    return a ? 1 : -1;\n  }\n  if (typeof a === 'number') {\n    assertNumber(b);\n    return a - b;\n  }\n  if (typeof a === 'string') {\n    assertString(b);\n    // We compare all strings in Zero as UTF-8. This is the default on SQLite\n    // and we need to match it. See:\n    // https://blog.replicache.dev/blog/replicache-11-adventures-in-text-encoding.\n    //\n    // TODO: We could change this since SQLite supports UTF-16. Microbenchmark\n    // to see if there's a big win.\n    //\n    // https://www.sqlite.org/c3ref/create_collation.html\n    return compareUTF8(a, b);\n  }\n  throw new Error(`Unsupported type: ${a}`);\n}\n\nexport type NormalizedValue = Exclude<Value, undefined>;\n\n/**\n * We allow undefined to be passed for the convenience of developers, but we\n * treat it equivalently to null. It's better for perf to not create an copy\n * of input values, so we just normalize at use when necessary.\n */\nexport function normalizeUndefined(v: Value): NormalizedValue {\n  return v ?? null;\n}\n\nexport type Comparator = (r1: Row, r2: Row) => number;\n\nexport function makeComparator(order: Ordering, reverse?: boolean): Comparator {\n  return (a, b) => {\n    // Skip destructuring here since it is hot code.\n    for (const ord of order) {\n      const field = ord[0];\n      const comp = compareValues(a[field], b[field]);\n      if (comp !== 0) {\n        const result = ord[1] === 'asc' ? comp : -comp;\n        return reverse ? -result : result;\n      }\n    }\n    return 0;\n  };\n}\n\n/**\n * Determine if two values are equal. Note that unlike compareValues() above,\n * this function treats `null` as unequal to itself (and same for `undefined`).\n * This is required to make joins work correctly, but may not be the right\n * semantic for your application.\n */\nexport function valuesEqual(a: Value, b: Value): boolean {\n  // oxlint-disable-next-line eqeqeq\n  if (a == null || b == null) {\n    return false;\n  }\n  return a === b;\n}\n\nexport function drainStreams(node: Node | 'yield') {\n  if (node === 'yield') {\n    return;\n  }\n  for (const stream of Object.values(node.relationships)) {\n    for (const node of stream()) {\n      drainStreams(node);\n    }\n  }\n}\n"],"names":[],"mappings":";;AAoCO,SAAS,cAAc,GAAU,GAAkB;AACxD,MAAI,mBAAmB,CAAC;AACxB,MAAI,mBAAmB,CAAC;AAExB,MAAI,MAAM,GAAG;AACX,WAAO;AAAA,EACT;AACA,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACT;AACA,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACT;AACA,MAAI,OAAO,MAAM,WAAW;AAC1B,kBAAc,CAAC;AACf,WAAO,IAAI,IAAI;AAAA,EACjB;AACA,MAAI,OAAO,MAAM,UAAU;AACzB,iBAAa,CAAC;AACd,WAAO,IAAI;AAAA,EACb;AACA,MAAI,OAAO,MAAM,UAAU;AACzB,iBAAa,CAAC;AASd,WAAO,YAAY,GAAG,CAAC;AAAA,EACzB;AACA,QAAM,IAAI,MAAM,qBAAqB,CAAC,EAAE;AAC1C;AASO,SAAS,mBAAmB,GAA2B;AAC5D,SAAO,KAAK;AACd;AAIO,SAAS,eAAe,OAAiB,SAA+B;AAC7E,SAAO,CAAC,GAAG,MAAM;AAEf,eAAW,OAAO,OAAO;AACvB,YAAM,QAAQ,IAAI,CAAC;AACnB,YAAM,OAAO,cAAc,EAAE,KAAK,GAAG,EAAE,KAAK,CAAC;AAC7C,UAAI,SAAS,GAAG;AACd,cAAM,SAAS,IAAI,CAAC,MAAM,QAAQ,OAAO,CAAC;AAC1C,eAAO,UAAU,CAAC,SAAS;AAAA,MAC7B;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAQO,SAAS,YAAY,GAAU,GAAmB;AAEvD,MAAI,KAAK,QAAQ,KAAK,MAAM;AAC1B,WAAO;AAAA,EACT;AACA,SAAO,MAAM;AACf;"}
+{"version":3,"file":"data.js","names":[],"sources":["../../../../../zql/src/ivm/data.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {\n  assertBoolean,\n  assertNumber,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport type {Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * A row flowing through the pipeline, plus its relationships.\n * Relationships are generated lazily as read.\n */\nexport type Node = {\n  row: Row;\n  /**\n   * Relationships are generated lazily as read.\n   * The stream may contain 'yield' to indicate the operator has yielded control.\n   * See {@linkcode Operator.fetch} for more details about yields.\n   */\n  relationships: Record<string, () => Stream<Node | 'yield'>>;\n};\n\n/**\n * Compare two values. The values must be of the same type. This function\n * throws at runtime if the types differ.\n *\n * Note, this function considers `null === null` and\n * `undefined === undefined`. This is different than SQL. In join code,\n * null must be treated separately.\n *\n * See: https://github.com/rocicorp/mono/pull/2116/files#r1704811479\n *\n * @returns < 0 if a < b, 0 if a === b, > 0 if a > b\n */\nexport function compareValues(a: Value, b: Value): number {\n  a = normalizeUndefined(a);\n  b = normalizeUndefined(b);\n\n  if (a === b) {\n    return 0;\n  }\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n  if (typeof a === 'boolean') {\n    assertBoolean(b);\n    return a ? 1 : -1;\n  }\n  if (typeof a === 'number') {\n    assertNumber(b);\n    return a - b;\n  }\n  if (typeof a === 'string') {\n    assertString(b);\n    // We compare all strings in Zero as UTF-8. This is the default on SQLite\n    // and we need to match it. See:\n    // https://blog.replicache.dev/blog/replicache-11-adventures-in-text-encoding.\n    //\n    // TODO: We could change this since SQLite supports UTF-16. Microbenchmark\n    // to see if there's a big win.\n    //\n    // https://www.sqlite.org/c3ref/create_collation.html\n    return compareUTF8(a, b);\n  }\n  throw new Error(`Unsupported type: ${a}`);\n}\n\nexport type NormalizedValue = Exclude<Value, undefined>;\n\n/**\n * We allow undefined to be passed for the convenience of developers, but we\n * treat it equivalently to null. It's better for perf to not create an copy\n * of input values, so we just normalize at use when necessary.\n */\nexport function normalizeUndefined(v: Value): NormalizedValue {\n  return v ?? null;\n}\n\nexport type Comparator = (r1: Row, r2: Row) => number;\n\nexport function makeComparator(order: Ordering, reverse?: boolean): Comparator {\n  return (a, b) => {\n    // Skip destructuring here since it is hot code.\n    for (const ord of order) {\n      const field = ord[0];\n      const comp = compareValues(a[field], b[field]);\n      if (comp !== 0) {\n        const result = ord[1] === 'asc' ? comp : -comp;\n        return reverse ? -result : result;\n      }\n    }\n    return 0;\n  };\n}\n\n/**\n * Determine if two values are equal. Note that unlike compareValues() above,\n * this function treats `null` as unequal to itself (and same for `undefined`).\n * This is required to make joins work correctly, but may not be the right\n * semantic for your application.\n */\nexport function valuesEqual(a: Value, b: Value): boolean {\n  // oxlint-disable-next-line eqeqeq\n  if (a == null || b == null) {\n    return false;\n  }\n  return a === b;\n}\n\nexport function drainStreams(node: Node | 'yield') {\n  if (node === 'yield') {\n    return;\n  }\n  for (const stream of Object.values(node.relationships)) {\n    for (const node of stream()) {\n      drainStreams(node);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoCA,SAAgB,cAAc,GAAU,GAAkB;AACxD,KAAI,mBAAmB,EAAE;AACzB,KAAI,mBAAmB,EAAE;AAEzB,KAAI,MAAM,EACR,QAAO;AAET,KAAI,MAAM,KACR,QAAO;AAET,KAAI,MAAM,KACR,QAAO;AAET,KAAI,OAAO,MAAM,WAAW;AAC1B,gBAAc,EAAE;AAChB,SAAO,IAAI,IAAI;;AAEjB,KAAI,OAAO,MAAM,UAAU;AACzB,eAAa,EAAE;AACf,SAAO,IAAI;;AAEb,KAAI,OAAO,MAAM,UAAU;AACzB,eAAa,EAAE;AASf,SAAO,YAAY,GAAG,EAAE;;AAE1B,OAAM,IAAI,MAAM,qBAAqB,IAAI;;;;;;;AAU3C,SAAgB,mBAAmB,GAA2B;AAC5D,QAAO,KAAK;;AAKd,SAAgB,eAAe,OAAiB,SAA+B;AAC7E,SAAQ,GAAG,MAAM;AAEf,OAAK,MAAM,OAAO,OAAO;GACvB,MAAM,QAAQ,IAAI;GAClB,MAAM,OAAO,cAAc,EAAE,QAAQ,EAAE,OAAO;AAC9C,OAAI,SAAS,GAAG;IACd,MAAM,SAAS,IAAI,OAAO,QAAQ,OAAO,CAAC;AAC1C,WAAO,UAAU,CAAC,SAAS;;;AAG/B,SAAO;;;;;;;;;AAUX,SAAgB,YAAY,GAAU,GAAmB;AAEvD,KAAI,KAAK,QAAQ,KAAK,KACpB,QAAO;AAET,QAAO,MAAM"}

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

@@ -1,217 +1,168 @@
-import { areEqual } from "../../../shared/src/arrays.js";
 import { assert, unreachable } from "../../../shared/src/asserts.js";
+import { areEqual } from "../../../shared/src/arrays.js";
 import { normalizeUndefined } from "./data.js";
 import { throwFilterOutput } from "./filter-operators.js";
-class Exists {
-  #input;
-  #relationshipName;
-  #not;
-  #parentJoinKey;
-  #noSizeReuse;
-  #cache;
-  #cacheHitCountsForTesting;
-  #output = throwFilterOutput;
-  /**
-   * This instance variable is `true` when this operator is processing a `push`,
-   * and is used to disable reuse of cached sizes across rows with the
-   * same parent join key value.
-   * This is necessary because during a push relationships can be inconsistent
-   * due to push communicating changes (which may change multiple Nodes) one
-   * Node at a time.
-   */
-  #inPush = false;
-  constructor(input, relationshipName, parentJoinKey, type, cacheHitCountsForTesting) {
-    this.#input = input;
-    this.#relationshipName = relationshipName;
-    this.#input.setFilterOutput(this);
-    this.#cache = /* @__PURE__ */ new Map();
-    this.#cacheHitCountsForTesting = cacheHitCountsForTesting;
-    assert(
-      this.#input.getSchema().relationships[relationshipName],
-      `Input schema missing ${relationshipName}`
-    );
-    this.#not = type === "NOT EXISTS";
-    this.#parentJoinKey = parentJoinKey;
-    this.#noSizeReuse = areEqual(
-      parentJoinKey,
-      this.#input.getSchema().primaryKey
-    );
-  }
-  setFilterOutput(output) {
-    this.#output = output;
-  }
-  beginFilter() {
-    this.#output.beginFilter();
-  }
-  endFilter() {
-    this.#cache = /* @__PURE__ */ new Map();
-    this.#output.endFilter();
-  }
-  *filter(node) {
-    let exists;
-    if (!this.#noSizeReuse && !this.#inPush) {
-      const key = this.#getCacheKey(node, this.#parentJoinKey);
-      exists = this.#cache.get(key);
-      if (exists === void 0) {
-        exists = yield* this.#fetchExists(node);
-        this.#cache.set(key, exists);
-      } else if (this.#cacheHitCountsForTesting) {
-        this.#cacheHitCountsForTesting.set(
-          key,
-          (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1
-        );
-      }
-    }
-    const result = (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));
-    return result;
-  }
-  destroy() {
-    this.#input.destroy();
-  }
-  getSchema() {
-    return this.#input.getSchema();
-  }
-  *push(change) {
-    assert(!this.#inPush, "Unexpected re-entrancy");
-    this.#inPush = true;
-    try {
-      switch (change.type) {
-        // add, remove and edit cannot change the size of the
-        // this.#relationshipName relationship, so simply #pushWithFilter
-        case "add":
-        case "edit":
-        case "remove": {
-          yield* this.#pushWithFilter(change);
-          return;
-        }
-        case "child":
-          if (change.child.relationshipName !== this.#relationshipName || change.child.change.type === "edit" || change.child.change.type === "child") {
-            yield* this.#pushWithFilter(change);
-            return;
-          }
-          switch (change.child.change.type) {
-            case "add": {
-              const size = yield* this.#fetchSize(change.node);
-              if (size === 1) {
-                if (this.#not) {
-                  yield* this.#output.push(
-                    {
-                      type: "remove",
-                      node: {
-                        row: change.node.row,
-                        relationships: {
-                          ...change.node.relationships,
-                          [this.#relationshipName]: () => []
-                        }
-                      }
-                    },
-                    this
-                  );
-                } else {
-                  yield* this.#output.push(
-                    {
-                      type: "add",
-                      node: change.node
-                    },
-                    this
-                  );
-                }
-              } else {
-                yield* this.#pushWithFilter(change, size > 0);
-              }
-              return;
-            }
-            case "remove": {
-              const size = yield* this.#fetchSize(change.node);
-              if (size === 0) {
-                if (this.#not) {
-                  yield* this.#output.push(
-                    {
-                      type: "add",
-                      node: change.node
-                    },
-                    this
-                  );
-                } else {
-                  yield* this.#output.push(
-                    {
-                      type: "remove",
-                      node: {
-                        row: change.node.row,
-                        relationships: {
-                          ...change.node.relationships,
-                          [this.#relationshipName]: () => [
-                            change.child.change.node
-                          ]
-                        }
-                      }
-                    },
-                    this
-                  );
-                }
-              } else {
-                yield* this.#pushWithFilter(change, size > 0);
-              }
-              return;
-            }
-          }
-          return;
-        default:
-          unreachable(change);
-      }
-    } finally {
-      this.#inPush = false;
-    }
-  }
-  /**
-   * Returns whether or not the node's this.#relationshipName
-   * relationship passes the exist/not exists filter condition.
-   * If the optional `size` is passed it is used.
-   * Otherwise, if there is a stored size for the row it is used.
-   * Otherwise the size is computed by streaming the node's
-   * relationship with this.#relationshipName (this computed size is also
-   * stored).
-   */
-  *#filter(node, exists) {
-    exists = exists ?? (yield* this.#fetchExists(node));
-    return this.#not ? !exists : exists;
-  }
-  #getCacheKey(node, def) {
-    const values = [];
-    for (const key of def) {
-      values.push(normalizeUndefined(node.row[key]));
-    }
-    return JSON.stringify(values);
-  }
-  /**
-   * Pushes a change if this.#filter is true for its row.
-   */
-  *#pushWithFilter(change, exists) {
-    if (yield* this.#filter(change.node, exists)) {
-      yield* this.#output.push(change, this);
-    }
-  }
-  *#fetchExists(node) {
-    return (yield* this.#fetchSize(node)) > 0;
-  }
-  *#fetchSize(node) {
-    const relationship = node.relationships[this.#relationshipName];
-    assert(
-      relationship,
-      () => `Exists: relationship "${this.#relationshipName}" not found on node`
-    );
-    let size = 0;
-    for (const n of relationship()) {
-      if (n === "yield") {
-        yield "yield";
-      } else {
-        size++;
-      }
-    }
-    return size;
-  }
-}
-export {
-  Exists
+//#region ../zql/src/ivm/exists.ts
+/**
+* The Exists operator filters data based on whether or not a relationship is
+* non-empty.
+*/
+var Exists = class {
+	#input;
+	#relationshipName;
+	#not;
+	#parentJoinKey;
+	#noSizeReuse;
+	#cache;
+	#cacheHitCountsForTesting;
+	#output = throwFilterOutput;
+	/**
+	* This instance variable is `true` when this operator is processing a `push`,
+	* and is used to disable reuse of cached sizes across rows with the
+	* same parent join key value.
+	* This is necessary because during a push relationships can be inconsistent
+	* due to push communicating changes (which may change multiple Nodes) one
+	* Node at a time.
+	*/
+	#inPush = false;
+	constructor(input, relationshipName, parentJoinKey, type, cacheHitCountsForTesting) {
+		this.#input = input;
+		this.#relationshipName = relationshipName;
+		this.#input.setFilterOutput(this);
+		this.#cache = /* @__PURE__ */ new Map();
+		this.#cacheHitCountsForTesting = cacheHitCountsForTesting;
+		assert(this.#input.getSchema().relationships[relationshipName], `Input schema missing ${relationshipName}`);
+		this.#not = type === "NOT EXISTS";
+		this.#parentJoinKey = parentJoinKey;
+		this.#noSizeReuse = areEqual(parentJoinKey, this.#input.getSchema().primaryKey);
+	}
+	setFilterOutput(output) {
+		this.#output = output;
+	}
+	beginFilter() {
+		this.#output.beginFilter();
+	}
+	endFilter() {
+		this.#cache = /* @__PURE__ */ new Map();
+		this.#output.endFilter();
+	}
+	*filter(node) {
+		let exists;
+		if (!this.#noSizeReuse && !this.#inPush) {
+			const key = this.#getCacheKey(node, this.#parentJoinKey);
+			exists = this.#cache.get(key);
+			if (exists === void 0) {
+				exists = yield* this.#fetchExists(node);
+				this.#cache.set(key, exists);
+			} else if (this.#cacheHitCountsForTesting) this.#cacheHitCountsForTesting.set(key, (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1);
+		}
+		return (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));
+	}
+	destroy() {
+		this.#input.destroy();
+	}
+	getSchema() {
+		return this.#input.getSchema();
+	}
+	*push(change) {
+		assert(!this.#inPush, "Unexpected re-entrancy");
+		this.#inPush = true;
+		try {
+			switch (change.type) {
+				case "add":
+				case "edit":
+				case "remove":
+					yield* this.#pushWithFilter(change);
+					return;
+				case "child":
+					if (change.child.relationshipName !== this.#relationshipName || change.child.change.type === "edit" || change.child.change.type === "child") {
+						yield* this.#pushWithFilter(change);
+						return;
+					}
+					switch (change.child.change.type) {
+						case "add": {
+							const size = yield* this.#fetchSize(change.node);
+							if (size === 1) if (this.#not) yield* this.#output.push({
+								type: "remove",
+								node: {
+									row: change.node.row,
+									relationships: {
+										...change.node.relationships,
+										[this.#relationshipName]: () => []
+									}
+								}
+							}, this);
+							else yield* this.#output.push({
+								type: "add",
+								node: change.node
+							}, this);
+							else yield* this.#pushWithFilter(change, size > 0);
+							return;
+						}
+						case "remove": {
+							const size = yield* this.#fetchSize(change.node);
+							if (size === 0) if (this.#not) yield* this.#output.push({
+								type: "add",
+								node: change.node
+							}, this);
+							else yield* this.#output.push({
+								type: "remove",
+								node: {
+									row: change.node.row,
+									relationships: {
+										...change.node.relationships,
+										[this.#relationshipName]: () => [change.child.change.node]
+									}
+								}
+							}, this);
+							else yield* this.#pushWithFilter(change, size > 0);
+							return;
+						}
+					}
+					return;
+				default: unreachable(change);
+			}
+		} finally {
+			this.#inPush = false;
+		}
+	}
+	/**
+	* Returns whether or not the node's this.#relationshipName
+	* relationship passes the exist/not exists filter condition.
+	* If the optional `size` is passed it is used.
+	* Otherwise, if there is a stored size for the row it is used.
+	* Otherwise the size is computed by streaming the node's
+	* relationship with this.#relationshipName (this computed size is also
+	* stored).
+	*/
+	*#filter(node, exists) {
+		exists = exists ?? (yield* this.#fetchExists(node));
+		return this.#not ? !exists : exists;
+	}
+	#getCacheKey(node, def) {
+		const values = [];
+		for (const key of def) values.push(normalizeUndefined(node.row[key]));
+		return JSON.stringify(values);
+	}
+	/**
+	* Pushes a change if this.#filter is true for its row.
+	*/
+	*#pushWithFilter(change, exists) {
+		if (yield* this.#filter(change.node, exists)) yield* this.#output.push(change, this);
+	}
+	*#fetchExists(node) {
+		return (yield* this.#fetchSize(node)) > 0;
+	}
+	*#fetchSize(node) {
+		const relationship = node.relationships[this.#relationshipName];
+		assert(relationship, () => `Exists: relationship "${this.#relationshipName}" not found on node`);
+		let size = 0;
+		for (const n of relationship()) if (n === "yield") yield "yield";
+		else size++;
+		return size;
+	}
 };
-//# sourceMappingURL=exists.js.map
+//#endregion
+export { Exists };
+
+//# sourceMappingURL=exists.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"exists.js","sources":["../../../../../zql/src/ivm/exists.ts"],"sourcesContent":["import {areEqual} from '../../../shared/src/arrays.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport {type Change} from './change.ts';\nimport {normalizeUndefined, type Node, type NormalizedValue} from './data.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The Exists operator filters data based on whether or not a relationship is\n * non-empty.\n */\nexport class Exists implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #relationshipName: string;\n  readonly #not: boolean;\n  readonly #parentJoinKey: CompoundKey;\n  readonly #noSizeReuse: boolean;\n  #cache: Map<string, boolean>;\n  #cacheHitCountsForTesting: Map<string, number> | undefined;\n  #output: FilterOutput = throwFilterOutput;\n\n  /**\n   * This instance variable is `true` when this operator is processing a `push`,\n   * and is used to disable reuse of cached sizes across rows with the\n   * same parent join key value.\n   * This is necessary because during a push relationships can be inconsistent\n   * due to push communicating changes (which may change multiple Nodes) one\n   * Node at a time.\n   */\n  #inPush = false;\n\n  constructor(\n    input: FilterInput,\n    relationshipName: string,\n    parentJoinKey: CompoundKey,\n    type: 'EXISTS' | 'NOT EXISTS',\n    cacheHitCountsForTesting?: Map<string, number>,\n  ) {\n    this.#input = input;\n    this.#relationshipName = relationshipName;\n    this.#input.setFilterOutput(this);\n    this.#cache = new Map();\n    this.#cacheHitCountsForTesting = cacheHitCountsForTesting;\n    assert(\n      this.#input.getSchema().relationships[relationshipName],\n      `Input schema missing ${relationshipName}`,\n    );\n    this.#not = type === 'NOT EXISTS';\n    this.#parentJoinKey = parentJoinKey;\n\n    // If the parentJoinKey is the primary key, no sense in trying to reuse.\n    this.#noSizeReuse = areEqual(\n      parentJoinKey,\n      this.#input.getSchema().primaryKey,\n    );\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#output = output;\n  }\n\n  beginFilter() {\n    this.#output.beginFilter();\n  }\n\n  endFilter() {\n    this.#cache = new Map();\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    let exists: boolean | undefined;\n    if (!this.#noSizeReuse && !this.#inPush) {\n      const key = this.#getCacheKey(node, this.#parentJoinKey);\n      exists = this.#cache.get(key);\n      if (exists === undefined) {\n        exists = yield* this.#fetchExists(node);\n        this.#cache.set(key, exists);\n      } else if (this.#cacheHitCountsForTesting) {\n        this.#cacheHitCountsForTesting.set(\n          key,\n          (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1,\n        );\n      }\n    }\n\n    const result =\n      (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));\n    return result;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    assert(!this.#inPush, 'Unexpected re-entrancy');\n    this.#inPush = true;\n    try {\n      switch (change.type) {\n        // add, remove and edit cannot change the size of the\n        // this.#relationshipName relationship, so simply #pushWithFilter\n        case 'add':\n        case 'edit':\n        case 'remove': {\n          yield* this.#pushWithFilter(change);\n          return;\n        }\n        case 'child':\n          // Only add and remove child changes for the\n          // this.#relationshipName relationship, can change the size\n          // of the this.#relationshipName relationship, for other\n          // child changes simply #pushWithFilter\n          if (\n            change.child.relationshipName !== this.#relationshipName ||\n            change.child.change.type === 'edit' ||\n            change.child.change.type === 'child'\n          ) {\n            yield* this.#pushWithFilter(change);\n            return;\n          }\n          switch (change.child.change.type) {\n            case 'add': {\n              const size = yield* this.#fetchSize(change.node);\n              if (size === 1) {\n                if (this.#not) {\n                  // Since the add child change currently being processed is not\n                  // pushed to output, the added child needs to be excluded from\n                  // the remove being pushed to output (since the child has\n                  // never been added to the output).\n                  yield* this.#output.push(\n                    {\n                      type: 'remove',\n                      node: {\n                        row: change.node.row,\n                        relationships: {\n                          ...change.node.relationships,\n                          [this.#relationshipName]: () => [],\n                        },\n                      },\n                    },\n                    this,\n                  );\n                } else {\n                  yield* this.#output.push(\n                    {\n                      type: 'add',\n                      node: change.node,\n                    },\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n            case 'remove': {\n              const size = yield* this.#fetchSize(change.node);\n              if (size === 0) {\n                if (this.#not) {\n                  yield* this.#output.push(\n                    {\n                      type: 'add',\n                      node: change.node,\n                    },\n                    this,\n                  );\n                } else {\n                  // Since the remove child change currently being processed is\n                  // not pushed to output, the removed child needs to be added to\n                  // the remove being pushed to output.\n                  yield* this.#output.push(\n                    {\n                      type: 'remove',\n                      node: {\n                        row: change.node.row,\n                        relationships: {\n                          ...change.node.relationships,\n                          [this.#relationshipName]: () => [\n                            change.child.change.node,\n                          ],\n                        },\n                      },\n                    },\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n          }\n          return;\n        default:\n          unreachable(change);\n      }\n    } finally {\n      this.#inPush = false;\n    }\n  }\n\n  /**\n   * Returns whether or not the node's this.#relationshipName\n   * relationship passes the exist/not exists filter condition.\n   * If the optional `size` is passed it is used.\n   * Otherwise, if there is a stored size for the row it is used.\n   * Otherwise the size is computed by streaming the node's\n   * relationship with this.#relationshipName (this computed size is also\n   * stored).\n   */\n  *#filter(node: Node, exists?: boolean): Generator<'yield', boolean> {\n    exists = exists ?? (yield* this.#fetchExists(node));\n    return this.#not ? !exists : exists;\n  }\n\n  #getCacheKey(node: Node, def: CompoundKey): string {\n    const values: NormalizedValue[] = [];\n    for (const key of def) {\n      values.push(normalizeUndefined(node.row[key]));\n    }\n    return JSON.stringify(values);\n  }\n\n  /**\n   * Pushes a change if this.#filter is true for its row.\n   */\n  *#pushWithFilter(change: Change, exists?: boolean): Stream<'yield'> {\n    if (yield* this.#filter(change.node, exists)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  *#fetchExists(node: Node): Generator<'yield', boolean> {\n    // While it seems like this should be able to fetch just 1 node\n    // to check for exists, we can't because Take does not support\n    // early return during initial fetch.\n    return (yield* this.#fetchSize(node)) > 0;\n  }\n\n  *#fetchSize(node: Node): Generator<'yield', number> {\n    const relationship = node.relationships[this.#relationshipName];\n    assert(\n      relationship,\n      () =>\n        `Exists: relationship \"${this.#relationshipName}\" not found on node`,\n    );\n    let size = 0;\n    for (const n of relationship()) {\n      if (n === 'yield') {\n        yield 'yield';\n      } else {\n        size++;\n      }\n    }\n    return size;\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"exists.js","names":["#input","#relationshipName","#not","#parentJoinKey","#noSizeReuse","#cache","#cacheHitCountsForTesting","#output","#inPush","#getCacheKey","#fetchExists","#filter","#pushWithFilter","#fetchSize"],"sources":["../../../../../zql/src/ivm/exists.ts"],"sourcesContent":["import {areEqual} from '../../../shared/src/arrays.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport {type Change} from './change.ts';\nimport {normalizeUndefined, type Node, type NormalizedValue} from './data.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The Exists operator filters data based on whether or not a relationship is\n * non-empty.\n */\nexport class Exists implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #relationshipName: string;\n  readonly #not: boolean;\n  readonly #parentJoinKey: CompoundKey;\n  readonly #noSizeReuse: boolean;\n  #cache: Map<string, boolean>;\n  #cacheHitCountsForTesting: Map<string, number> | undefined;\n  #output: FilterOutput = throwFilterOutput;\n\n  /**\n   * This instance variable is `true` when this operator is processing a `push`,\n   * and is used to disable reuse of cached sizes across rows with the\n   * same parent join key value.\n   * This is necessary because during a push relationships can be inconsistent\n   * due to push communicating changes (which may change multiple Nodes) one\n   * Node at a time.\n   */\n  #inPush = false;\n\n  constructor(\n    input: FilterInput,\n    relationshipName: string,\n    parentJoinKey: CompoundKey,\n    type: 'EXISTS' | 'NOT EXISTS',\n    cacheHitCountsForTesting?: Map<string, number>,\n  ) {\n    this.#input = input;\n    this.#relationshipName = relationshipName;\n    this.#input.setFilterOutput(this);\n    this.#cache = new Map();\n    this.#cacheHitCountsForTesting = cacheHitCountsForTesting;\n    assert(\n      this.#input.getSchema().relationships[relationshipName],\n      `Input schema missing ${relationshipName}`,\n    );\n    this.#not = type === 'NOT EXISTS';\n    this.#parentJoinKey = parentJoinKey;\n\n    // If the parentJoinKey is the primary key, no sense in trying to reuse.\n    this.#noSizeReuse = areEqual(\n      parentJoinKey,\n      this.#input.getSchema().primaryKey,\n    );\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#output = output;\n  }\n\n  beginFilter() {\n    this.#output.beginFilter();\n  }\n\n  endFilter() {\n    this.#cache = new Map();\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    let exists: boolean | undefined;\n    if (!this.#noSizeReuse && !this.#inPush) {\n      const key = this.#getCacheKey(node, this.#parentJoinKey);\n      exists = this.#cache.get(key);\n      if (exists === undefined) {\n        exists = yield* this.#fetchExists(node);\n        this.#cache.set(key, exists);\n      } else if (this.#cacheHitCountsForTesting) {\n        this.#cacheHitCountsForTesting.set(\n          key,\n          (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1,\n        );\n      }\n    }\n\n    const result =\n      (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));\n    return result;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    assert(!this.#inPush, 'Unexpected re-entrancy');\n    this.#inPush = true;\n    try {\n      switch (change.type) {\n        // add, remove and edit cannot change the size of the\n        // this.#relationshipName relationship, so simply #pushWithFilter\n        case 'add':\n        case 'edit':\n        case 'remove': {\n          yield* this.#pushWithFilter(change);\n          return;\n        }\n        case 'child':\n          // Only add and remove child changes for the\n          // this.#relationshipName relationship, can change the size\n          // of the this.#relationshipName relationship, for other\n          // child changes simply #pushWithFilter\n          if (\n            change.child.relationshipName !== this.#relationshipName ||\n            change.child.change.type === 'edit' ||\n            change.child.change.type === 'child'\n          ) {\n            yield* this.#pushWithFilter(change);\n            return;\n          }\n          switch (change.child.change.type) {\n            case 'add': {\n              const size = yield* this.#fetchSize(change.node);\n              if (size === 1) {\n                if (this.#not) {\n                  // Since the add child change currently being processed is not\n                  // pushed to output, the added child needs to be excluded from\n                  // the remove being pushed to output (since the child has\n                  // never been added to the output).\n                  yield* this.#output.push(\n                    {\n                      type: 'remove',\n                      node: {\n                        row: change.node.row,\n                        relationships: {\n                          ...change.node.relationships,\n                          [this.#relationshipName]: () => [],\n                        },\n                      },\n                    },\n                    this,\n                  );\n                } else {\n                  yield* this.#output.push(\n                    {\n                      type: 'add',\n                      node: change.node,\n                    },\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n            case 'remove': {\n              const size = yield* this.#fetchSize(change.node);\n              if (size === 0) {\n                if (this.#not) {\n                  yield* this.#output.push(\n                    {\n                      type: 'add',\n                      node: change.node,\n                    },\n                    this,\n                  );\n                } else {\n                  // Since the remove child change currently being processed is\n                  // not pushed to output, the removed child needs to be added to\n                  // the remove being pushed to output.\n                  yield* this.#output.push(\n                    {\n                      type: 'remove',\n                      node: {\n                        row: change.node.row,\n                        relationships: {\n                          ...change.node.relationships,\n                          [this.#relationshipName]: () => [\n                            change.child.change.node,\n                          ],\n                        },\n                      },\n                    },\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n          }\n          return;\n        default:\n          unreachable(change);\n      }\n    } finally {\n      this.#inPush = false;\n    }\n  }\n\n  /**\n   * Returns whether or not the node's this.#relationshipName\n   * relationship passes the exist/not exists filter condition.\n   * If the optional `size` is passed it is used.\n   * Otherwise, if there is a stored size for the row it is used.\n   * Otherwise the size is computed by streaming the node's\n   * relationship with this.#relationshipName (this computed size is also\n   * stored).\n   */\n  *#filter(node: Node, exists?: boolean): Generator<'yield', boolean> {\n    exists = exists ?? (yield* this.#fetchExists(node));\n    return this.#not ? !exists : exists;\n  }\n\n  #getCacheKey(node: Node, def: CompoundKey): string {\n    const values: NormalizedValue[] = [];\n    for (const key of def) {\n      values.push(normalizeUndefined(node.row[key]));\n    }\n    return JSON.stringify(values);\n  }\n\n  /**\n   * Pushes a change if this.#filter is true for its row.\n   */\n  *#pushWithFilter(change: Change, exists?: boolean): Stream<'yield'> {\n    if (yield* this.#filter(change.node, exists)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  *#fetchExists(node: Node): Generator<'yield', boolean> {\n    // While it seems like this should be able to fetch just 1 node\n    // to check for exists, we can't because Take does not support\n    // early return during initial fetch.\n    return (yield* this.#fetchSize(node)) > 0;\n  }\n\n  *#fetchSize(node: Node): Generator<'yield', number> {\n    const relationship = node.relationships[this.#relationshipName];\n    assert(\n      relationship,\n      () =>\n        `Exists: relationship \"${this.#relationshipName}\" not found on node`,\n    );\n    let size = 0;\n    for (const n of relationship()) {\n      if (n === 'yield') {\n        yield 'yield';\n      } else {\n        size++;\n      }\n    }\n    return size;\n  }\n}\n"],"mappings":"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"}