@rocicorp/zero 1.12.0-canary.1 → 1.12.0-canary.11

package/out/zql/src/ivm/group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/group-by.ts"],"names":[],"mappings":"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"}

package/out/zql/src/ivm/group-by.js

@@ -0,0 +1,384 @@
+import { assert, unreachable } from "../../../shared/src/asserts.js";
+import { must } from "../../../shared/src/must.js";
+import { assignProperty } from "../../../shared/src/objects.js";
+import { makeAddChange, makeEditChange, makeRemoveChange } from "./change.js";
+import { makeComparator, normalizeUndefined, valueToKey } from "./data.js";
+import { throwOutput } from "./operator.js";
+import { AGGREGATE_KEY_COLUMN, AGGREGATE_ROWS_COLUMN, AGGREGATE_VALUE_COLUMN, aggregateSourceSchema, carriesComponents, isInvertible } from "./aggregate.js";
+import { emptyArray } from "../../../shared/src/sentinels.js";
+import { rowEqualsForCompoundKey } from "./join-utils.js";
+//#region ../zql/src/ivm/group-by.ts
+/**
+* The synthetic schema (columns, primary key and sort) of the rows
+* {@link GroupBy} emits: the group columns, the key of the group (`_0_key`)
+* and the aggregate's payload (`_0_value`, and for sum/avg its components and
+* the group's number of rows, `_0_rows`).
+* Shared by the operator (compute mode) and the client query builder
+* (`aggregatesFromSource` mode) so both agree on the synthetic source's shape.
+*
+* The key is the group's values encoded as one string, rather than the
+* columns themselves, because a synced row key can't hold a `null`, and `null`
+* is a value like any other.
+*/
+function groupSourceSchema(inputColumns, ordering, reducer) {
+	const { columns } = aggregateSourceSchema(inputColumns, ordering.map(([col]) => col), reducer.fn, reducer.field, reducer.path);
+	columns[AGGREGATE_KEY_COLUMN] = { type: "string" };
+	if (carriesComponents(reducer.fn)) columns[AGGREGATE_ROWS_COLUMN] = { type: "number" };
+	return {
+		columns,
+		primaryKey: [AGGREGATE_KEY_COLUMN],
+		sort: [...ordering, [AGGREGATE_KEY_COLUMN, "asc"]]
+	};
+}
+/**
+* The `_0_key` of a group, which also keys its state in the operator's
+* storage: as for Take and Cap, `valueToKey` of the value when there is one
+* column, and otherwise the values in column order, JSON encoded. One query
+* always has the same number of columns, so the two forms never meet.
+*/
+function groupKey(values) {
+	return values.length === 1 ? valueToKey(values[0]) : JSON.stringify(values);
+}
+/** A row's values of the group `columns`, in their order. */
+function groupValues(row, columns) {
+	return columns.map((col) => normalizeUndefined(row[col]));
+}
+/**
+* GroupBy groups its input by `columns` and reduces each group with an
+* aggregate function, as `GROUP BY` does: one row per combination of the
+* columns' values, `{...columns, _0_key, _0_value}`, plus the sum and count
+* components for sum/avg. `null` is a value like any other.
+*
+* A distinct is a GroupBy with a count, whose value a view doesn't show.
+*
+* It sits at the end of a top-level pipeline whose rows are sorted by the
+* group columns first, so the rows of a group are adjacent and a fetch reads
+* them in one pass. It keeps the state of every group, so a push adds a row
+* when a group gets its first input row, removes it when it loses its last,
+* and otherwise edits it when its value changes. Like {@link Aggregate}, a
+* min/max whose extreme a push removes is re-read from the input in
+* {@link reconcile}.
+*/
+var GroupBy = class {
+	#input;
+	#storage;
+	#columns;
+	#reducer;
+	#carriesRows;
+	#schema;
+	#groupSource;
+	#hydrated = false;
+	/**
+	* min/max groups whose extreme a push removed, by storage key, with a row
+	* of the group, to re-read in {@link reconcile}. Until then their storage
+	* keeps the value last sent downstream, with the current count.
+	*/
+	#dirtyGroups = /* @__PURE__ */ new Map();
+	#output = throwOutput;
+	/**
+	* @param ordering The order of the groups, which names each group column
+	*        once. The input must be sorted by it first.
+	*/
+	constructor(input, storage, ordering, tableName, reducer, groupSource) {
+		assert(ordering.length > 0, "GroupBy: needs at least one column");
+		this.#input = input;
+		this.#storage = storage;
+		this.#columns = ordering.map(([col]) => col);
+		this.#reducer = reducer;
+		this.#carriesRows = carriesComponents(reducer.fn);
+		this.#groupSource = reducer.fn === "count" ? groupSource : void 0;
+		input.setOutput(this);
+		const inputSchema = input.getSchema();
+		const inputSort = inputSchema.sort ?? [];
+		assert(ordering.every(([col, dir], i) => inputSort[i]?.[0] === col && inputSort[i][1] === dir), "GroupBy: the input must be sorted by the group columns first");
+		const { columns, primaryKey, sort } = groupSourceSchema(inputSchema.columns, ordering, reducer);
+		this.#schema = {
+			tableName,
+			columns,
+			primaryKey,
+			relationships: {},
+			isHidden: false,
+			isAggregate: true,
+			system: inputSchema.system,
+			sort,
+			compareRows: makeComparator(sort)
+		};
+	}
+	setOutput(output) {
+		this.#output = output;
+	}
+	getSchema() {
+		return this.#schema;
+	}
+	destroy() {
+		this.#input.destroy();
+		this.#storage.destroy();
+	}
+	fetch(req) {
+		assert(req.constraint === void 0 && req.start === void 0 && !req.reverse, "GroupBy: fetch takes no constraint, start or reverse");
+		this.#hydrated = true;
+		const groups = this.#groupSource?.groupCounts?.(this.#columns);
+		if (groups === void 0) return this.#fetchGroups();
+		const nodes = groups.map(({ row, count }) => this.#store(this.#groupValues(row), {
+			...this.#reducer.empty(),
+			count
+		}));
+		nodes.sort((a, b) => this.#schema.compareRows(a.row, b.row));
+		return nodes;
+	}
+	/** Reads the input and folds each run of a group into its row. */
+	*#fetchGroups() {
+		let first;
+		let state;
+		for (const node of this.#input.fetch({})) {
+			if (node === "yield") {
+				yield node;
+				continue;
+			}
+			if (first === void 0 || !rowEqualsForCompoundKey(first, node.row, this.#columns)) {
+				if (first !== void 0) yield this.#store(this.#groupValues(first), must(state));
+				first = node.row;
+				state = this.#reducer.empty();
+			}
+			this.#reducer.contribute(must(state), node.row);
+		}
+		if (first !== void 0) yield this.#store(this.#groupValues(first), must(state));
+	}
+	push(change) {
+		if (!this.#hydrated) return emptyArray;
+		switch (change[0]) {
+			case 0: return this.#add(change[1].row);
+			case 1: return this.#remove(change[1].row);
+			case 2: {
+				const oldRow = change[2].row;
+				const row = change[1].row;
+				return rowEqualsForCompoundKey(oldRow, row, this.#columns) ? this.#update(oldRow, row) : this.#move(oldRow, row);
+			}
+			case 3: return emptyArray;
+			default: unreachable(change);
+		}
+	}
+	/**
+	* Phase 2 of the two-phase push: re-read the min/max groups whose extreme
+	* Phase 1 removed, now that everything upstream has settled, then forward
+	* the signal for operators downstream.
+	*/
+	reconcile(_pusher) {
+		if (this.#dirtyGroups.size > 0) return this.#reconcileDirty();
+		return this.#output.reconcile ? this.#output.reconcile(this) : emptyArray;
+	}
+	*#reconcileDirty() {
+		const dirty = [...this.#dirtyGroups];
+		this.#dirtyGroups.clear();
+		for (const [key, groupRow] of dirty) {
+			const stored = this.#state(key);
+			if (stored === void 0) continue;
+			const state = this.#reducer.empty();
+			for (const node of this.#input.fetch({ constraint: this.#constraint(groupRow) })) {
+				if (node === "yield") {
+					yield node;
+					continue;
+				}
+				if (rowEqualsForCompoundKey(node.row, groupRow, this.#columns)) this.#reducer.contribute(state, node.row);
+			}
+			yield* this.#emitIfChanged(this.#groupValues(groupRow), stored, state);
+		}
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
+	}
+	/** An edit that moves its row from one group to another. */
+	*#move(oldRow, row) {
+		yield* this.#remove(oldRow);
+		yield* this.#add(row);
+	}
+	#add(row) {
+		const values = this.#groupValues(row);
+		const key = groupKey(values);
+		const stored = this.#state(key);
+		if (stored === void 0) {
+			const state = this.#reducer.empty();
+			this.#reducer.contribute(state, row);
+			return this.#output.push(makeAddChange(this.#store(values, state)), this);
+		}
+		const state = { ...stored };
+		if (this.#dirtyGroups.has(key)) {
+			state.count++;
+			this.#storage.set(key, state);
+			return emptyArray;
+		}
+		this.#reducer.contribute(state, row);
+		return this.#emitIfChanged(values, stored, state);
+	}
+	#remove(row) {
+		const values = this.#groupValues(row);
+		const key = groupKey(values);
+		const stored = must(this.#state(key), "GroupBy: removed a row of a group it lacks");
+		if (stored.count === 1) {
+			this.#storage.del(key);
+			this.#dirtyGroups.delete(key);
+			return this.#output.push(makeRemoveChange(this.#makeNode(values, stored)), this);
+		}
+		const state = { ...stored };
+		if (isInvertible(this.#reducer.fn)) this.#reducer.applyInvertible(state, row, -1);
+		else if (this.#dirtyGroups.has(key) || !this.#reducer.pushExtreme(state, makeRemoveChange({
+			row,
+			relationships: {}
+		}))) {
+			this.#dirtyGroups.set(key, row);
+			this.#storage.set(key, {
+				...stored,
+				count: stored.count - 1
+			});
+			return emptyArray;
+		}
+		return this.#emitIfChanged(values, stored, state);
+	}
+	/** An edit within a group. */
+	#update(oldRow, row) {
+		const values = this.#groupValues(row);
+		const key = groupKey(values);
+		const stored = this.#state(key);
+		if (stored === void 0 || this.#dirtyGroups.has(key) || this.#reducer.sameValue(oldRow, row)) return emptyArray;
+		const state = { ...stored };
+		if (!isInvertible(this.#reducer.fn)) {
+			this.#dirtyGroups.set(key, row);
+			return emptyArray;
+		}
+		this.#reducer.applyInvertible(state, oldRow, -1, true);
+		this.#reducer.applyInvertible(state, row, 1, true);
+		return this.#emitIfChanged(values, stored, state);
+	}
+	/** Stores `state` and sends the move from `stored` downstream, if any. */
+	#emitIfChanged(values, stored, state) {
+		this.#storage.set(groupKey(values), state);
+		if (!this.#reducer.changed(stored, state) && !(this.#carriesRows && stored.count !== state.count)) return emptyArray;
+		return this.#output.push(makeEditChange(this.#makeNode(values, state), this.#makeNode(values, stored)), this);
+	}
+	#state(key) {
+		return this.#storage.get(key);
+	}
+	/** Records `state` for the group and returns its row. */
+	#store(values, state) {
+		this.#storage.set(groupKey(values), state);
+		return this.#makeNode(values, state);
+	}
+	#makeNode(values, state) {
+		const row = {};
+		for (let i = 0; i < this.#columns.length; i++) assignProperty(row, this.#columns[i], values[i]);
+		row[AGGREGATE_KEY_COLUMN] = groupKey(values);
+		this.#reducer.writePayload(row, state);
+		if (this.#carriesRows) row[AGGREGATE_ROWS_COLUMN] = state.count;
+		return {
+			row,
+			relationships: {}
+		};
+	}
+	/**
+	* A constraint that reads the rows of `row`'s group. It leaves out the
+	* `null` values, which a constraint never matches, so it can read rows of
+	* other groups too, which the caller skips.
+	*/
+	#constraint(row) {
+		let constraint;
+		for (const col of this.#columns) {
+			const value = normalizeUndefined(row[col]);
+			if (value !== null) assignProperty(constraint ??= {}, col, value);
+		}
+		return constraint;
+	}
+	#groupValues(row) {
+		return groupValues(row, this.#columns);
+	}
+};
+/**
+* Turns the rows of a {@link GroupBy}, or of the synthetic source a synced
+* client reads them from, into the rows a view of the query shows: the group
+* columns under the query's column names, and, for a `groupBy()` with an
+* aggregate, its value under `valueName` (`count`, `sum`, …). A `distinct()`
+* shows no value, so an edit, which only moves its count, doesn't reach the
+* view.
+*/
+var GroupProjection = class {
+	#input;
+	#columns;
+	#valueName;
+	#schema;
+	#output = throwOutput;
+	constructor(input, columns, valueName) {
+		this.#input = input;
+		this.#columns = columns;
+		this.#valueName = valueName;
+		assert(valueName === void 0 || columns.every(([out]) => out !== valueName), () => `groupBy(): the column "${valueName}" has the same name as the ${valueName}() value`);
+		input.setOutput(this);
+		const inputSchema = input.getSchema();
+		const viewName = new Map(columns.map(([out, from]) => [from, out]));
+		const sort = must(inputSchema.sort).filter(([col]) => viewName.has(col)).map(([col, dir]) => [must(viewName.get(col)), dir]);
+		const viewColumns = {};
+		for (const [out, from] of columns) assignProperty(viewColumns, out, must(inputSchema.columns[from]));
+		if (valueName !== void 0) assignProperty(viewColumns, valueName, must(inputSchema.columns[AGGREGATE_VALUE_COLUMN]));
+		this.#schema = {
+			tableName: inputSchema.tableName,
+			columns: viewColumns,
+			primaryKey: columns.map(([out]) => out),
+			relationships: {},
+			isHidden: false,
+			system: inputSchema.system,
+			sort,
+			compareRows: makeComparator(sort)
+		};
+	}
+	setOutput(output) {
+		this.#output = output;
+	}
+	getSchema() {
+		return this.#schema;
+	}
+	destroy() {
+		this.#input.destroy();
+	}
+	*fetch(req) {
+		for (const node of this.#input.fetch(req)) yield node === "yield" ? node : this.#project(node);
+	}
+	push(change) {
+		switch (change[0]) {
+			case 0: return this.#output.push(makeAddChange(this.#project(change[1])), this);
+			case 1: return this.#output.push(makeRemoveChange(this.#project(change[1])), this);
+			case 2: {
+				const node = change[1];
+				const old = change[2];
+				if (this.#valueName === void 0 || node.row["_0_value"] === old.row["_0_value"]) return emptyArray;
+				return this.#output.push(makeEditChange(this.#project(node), this.#project(old)), this);
+			}
+			case 3: return emptyArray;
+			default: unreachable(change);
+		}
+	}
+	reconcile(_pusher) {
+		return this.#output.reconcile ? this.#output.reconcile(this) : emptyArray;
+	}
+	#project(node) {
+		const row = {};
+		for (const [out, from] of this.#columns) assignProperty(row, out, node.row[from]);
+		if (this.#valueName !== void 0) assignProperty(row, this.#valueName, node.row[AGGREGATE_VALUE_COLUMN]);
+		return {
+			row,
+			relationships: {}
+		};
+	}
+};
+/**
+* The order of a grouped query's rows (its `groupBy`, or the columns a count
+* of distinct combinations groups by): its `orderBy`, which names only those
+* columns, then the rest of them ascending. Other columns, such as the
+* primary key a completed ordering ends with, are left out.
+*/
+function groupOrdering(ast) {
+	const columns = must(ast.groupBy ?? ast.aggregate?.distinct);
+	const ordering = [];
+	for (const [col, dir] of ast.orderBy ?? []) if (columns.includes(col) && !ordering.some(([c]) => c === col)) ordering.push([col, dir]);
+	for (const col of columns) if (!ordering.some(([c]) => c === col)) ordering.push([col, "asc"]);
+	return ordering;
+}
+//#endregion
+export { GroupBy, GroupProjection, groupKey, groupOrdering, groupSourceSchema, groupValues };
+
+//# sourceMappingURL=group-by.js.map

package/out/zql/src/ivm/group-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.js","names":[],"sources":["../../../../../zql/src/ivm/group-by.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {assignProperty} from '../../../shared/src/objects.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {\n  AST,\n  CompoundKey,\n  Ordering,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-types/src/schema-value.ts';\nimport {\n  AGGREGATE_KEY_COLUMN,\n  AGGREGATE_ROWS_COLUMN,\n  AGGREGATE_VALUE_COLUMN,\n  aggregateSourceSchema,\n  carriesComponents,\n  isInvertible,\n  type AggState,\n  type AggStorage,\n  type Reducer,\n} from './aggregate.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {\n  makeComparator,\n  normalizeUndefined,\n  valueToKey,\n  type Node,\n  type NormalizedValue,\n} from './data.ts';\nimport {rowEqualsForCompoundKey} from './join-utils.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {SourceInput} from './source.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * The synthetic schema (columns, primary key and sort) of the rows\n * {@link GroupBy} emits: the group columns, the key of the group (`_0_key`)\n * and the aggregate's payload (`_0_value`, and for sum/avg its components and\n * the group's number of rows, `_0_rows`).\n * Shared by the operator (compute mode) and the client query builder\n * (`aggregatesFromSource` mode) so both agree on the synthetic source's shape.\n *\n * The key is the group's values encoded as one string, rather than the\n * columns themselves, because a synced row key can't hold a `null`, and `null`\n * is a value like any other.\n */\nexport function groupSourceSchema(\n  inputColumns: Record<string, SchemaValue>,\n  ordering: Ordering,\n  reducer: Pick<Reducer, 'fn' | 'field' | 'path'>,\n): {\n  columns: Record<string, SchemaValue>;\n  primaryKey: PrimaryKey;\n  sort: Ordering;\n} {\n  const {columns} = aggregateSourceSchema(\n    inputColumns,\n    ordering.map(([col]) => col),\n    reducer.fn,\n    reducer.field,\n    reducer.path,\n  );\n  columns[AGGREGATE_KEY_COLUMN] = {type: 'string'};\n  if (carriesComponents(reducer.fn)) {\n    columns[AGGREGATE_ROWS_COLUMN] = {type: 'number'};\n  }\n  return {\n    columns,\n    primaryKey: [AGGREGATE_KEY_COLUMN],\n    // The key is unique and determined by the columns, so it only makes the\n    // order total.\n    sort: [...ordering, [AGGREGATE_KEY_COLUMN, 'asc']],\n  };\n}\n\n/**\n * The `_0_key` of a group, which also keys its state in the operator's\n * storage: as for Take and Cap, `valueToKey` of the value when there is one\n * column, and otherwise the values in column order, JSON encoded. One query\n * always has the same number of columns, so the two forms never meet.\n */\nexport function groupKey(values: readonly NormalizedValue[]): string {\n  return values.length === 1 ? valueToKey(values[0]) : JSON.stringify(values);\n}\n\n/** A row's values of the group `columns`, in their order. */\nexport function groupValues(\n  row: Row,\n  columns: readonly string[],\n): NormalizedValue[] {\n  return columns.map(col => normalizeUndefined(row[col]));\n}\n\n/**\n * GroupBy groups its input by `columns` and reduces each group with an\n * aggregate function, as `GROUP BY` does: one row per combination of the\n * columns' values, `{...columns, _0_key, _0_value}`, plus the sum and count\n * components for sum/avg. `null` is a value like any other.\n *\n * A distinct is a GroupBy with a count, whose value a view doesn't show.\n *\n * It sits at the end of a top-level pipeline whose rows are sorted by the\n * group columns first, so the rows of a group are adjacent and a fetch reads\n * them in one pass. It keeps the state of every group, so a push adds a row\n * when a group gets its first input row, removes it when it loses its last,\n * and otherwise edits it when its value changes. Like {@link Aggregate}, a\n * min/max whose extreme a push removes is re-read from the input in\n * {@link reconcile}.\n */\nexport class GroupBy implements Operator {\n  readonly #input: Input;\n  readonly #storage: AggStorage;\n  readonly #columns: CompoundKey;\n  readonly #reducer: Reducer;\n  // A sum/avg row also carries its group's row count (`_0_rows`).\n  readonly #carriesRows: boolean;\n  readonly #schema: SourceSchema;\n  // The source connection `input` reads straight from, when nothing between\n  // them drops rows. It can count the groups without the rows being read\n  // (see fetch).\n  readonly #groupSource: SourceInput | undefined;\n  // Set by the first fetch. Until then nothing downstream has the rows, so a\n  // push has nothing to update.\n  #hydrated = false;\n\n  /**\n   * min/max groups whose extreme a push removed, by storage key, with a row\n   * of the group, to re-read in {@link reconcile}. Until then their storage\n   * keeps the value last sent downstream, with the current count.\n   */\n  readonly #dirtyGroups = new Map<string, Row>();\n\n  #output: Output = throwOutput;\n\n  /**\n   * @param ordering The order of the groups, which names each group column\n   *        once. The input must be sorted by it first.\n   */\n  constructor(\n    input: Input,\n    storage: Storage,\n    ordering: Ordering,\n    tableName: string,\n    reducer: Reducer,\n    groupSource?: SourceInput | undefined,\n  ) {\n    assert(ordering.length > 0, 'GroupBy: needs at least one column');\n    this.#input = input;\n    this.#storage = storage as AggStorage;\n    this.#columns = ordering.map(([col]) => col) as unknown as CompoundKey;\n    this.#reducer = reducer;\n    this.#carriesRows = carriesComponents(reducer.fn);\n    this.#groupSource = reducer.fn === 'count' ? groupSource : undefined;\n    input.setOutput(this);\n\n    const inputSchema = input.getSchema();\n    const inputSort = inputSchema.sort ?? [];\n    assert(\n      ordering.every(\n        ([col, dir], i) => inputSort[i]?.[0] === col && inputSort[i][1] === dir,\n      ),\n      'GroupBy: the input must be sorted by the group columns first',\n    );\n    const {columns, primaryKey, sort} = groupSourceSchema(\n      inputSchema.columns,\n      ordering,\n      reducer,\n    );\n    this.#schema = {\n      // The rows are routed (e.g. by the view-syncer streamer) to this\n      // synthetic table, apart from the input table's rows.\n      tableName,\n      columns,\n      primaryKey,\n      relationships: {},\n      isHidden: false,\n      isAggregate: true,\n      system: inputSchema.system,\n      sort,\n      compareRows: makeComparator(sort),\n    };\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    // A top-level query without a bound, so the view reads every row once.\n    assert(\n      req.constraint === undefined && req.start === undefined && !req.reverse,\n      'GroupBy: fetch takes no constraint, start or reverse',\n    );\n    this.#hydrated = true;\n    const groups = this.#groupSource?.groupCounts?.(this.#columns);\n    if (groups === undefined) {\n      return this.#fetchGroups();\n    }\n    const nodes = groups.map(({row, count}) =>\n      this.#store(this.#groupValues(row), {...this.#reducer.empty(), count}),\n    );\n    nodes.sort((a, b) => this.#schema.compareRows(a.row, b.row));\n    return nodes;\n  }\n\n  /** Reads the input and folds each run of a group into its row. */\n  *#fetchGroups(): Stream<Node | 'yield'> {\n    // The first row of the current run, and its group's state.\n    let first: Row | undefined;\n    let state: AggState | undefined;\n    for (const node of this.#input.fetch({})) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (\n        first === undefined ||\n        !rowEqualsForCompoundKey(first, node.row, this.#columns)\n      ) {\n        if (first !== undefined) {\n          yield this.#store(this.#groupValues(first), must(state));\n        }\n        first = node.row;\n        state = this.#reducer.empty();\n      }\n      this.#reducer.contribute(must(state), node.row);\n    }\n    if (first !== undefined) {\n      yield this.#store(this.#groupValues(first), must(state));\n    }\n  }\n\n  push(change: Change): Stream<'yield'> {\n    if (!this.#hydrated) {\n      return emptyArray;\n    }\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        return this.#add(change[ChangeIndex.NODE].row);\n      case ChangeType.REMOVE:\n        return this.#remove(change[ChangeIndex.NODE].row);\n      case ChangeType.EDIT: {\n        const oldRow = change[ChangeIndex.OLD_NODE].row;\n        const row = change[ChangeIndex.NODE].row;\n        return rowEqualsForCompoundKey(oldRow, row, this.#columns)\n          ? this.#update(oldRow, row)\n          : this.#move(oldRow, row);\n      }\n      case ChangeType.CHILD:\n        // The input has no relationships the group rows show.\n        return emptyArray;\n      default:\n        unreachable(change);\n    }\n  }\n\n  /**\n   * Phase 2 of the two-phase push: re-read the min/max groups whose extreme\n   * Phase 1 removed, now that everything upstream has settled, then forward\n   * the signal for operators downstream.\n   */\n  reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#dirtyGroups.size > 0) {\n      return this.#reconcileDirty();\n    }\n    return this.#output.reconcile ? this.#output.reconcile(this) : emptyArray;\n  }\n\n  *#reconcileDirty(): Stream<'yield'> {\n    const dirty = [...this.#dirtyGroups];\n    this.#dirtyGroups.clear();\n    for (const [key, groupRow] of dirty) {\n      const stored = this.#state(key);\n      if (stored === undefined) {\n        continue; // its last row went in the meantime\n      }\n      const state = this.#reducer.empty();\n      for (const node of this.#input.fetch({\n        constraint: this.#constraint(groupRow),\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        if (rowEqualsForCompoundKey(node.row, groupRow, this.#columns)) {\n          this.#reducer.contribute(state, node.row);\n        }\n      }\n      yield* this.#emitIfChanged(this.#groupValues(groupRow), stored, state);\n    }\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n\n  /** An edit that moves its row from one group to another. */\n  *#move(oldRow: Row, row: Row): Stream<'yield'> {\n    yield* this.#remove(oldRow);\n    yield* this.#add(row);\n  }\n\n  #add(row: Row): Stream<'yield'> {\n    const values = this.#groupValues(row);\n    const key = groupKey(values);\n    const stored = this.#state(key);\n    if (stored === undefined) {\n      const state = this.#reducer.empty();\n      this.#reducer.contribute(state, row);\n      return this.#output.push(makeAddChange(this.#store(values, state)), this);\n    }\n    const state = {...stored};\n    if (this.#dirtyGroups.has(key)) {\n      // Re-read in reconcile; only the count is kept up to date.\n      state.count++;\n      this.#storage.set(key, state);\n      return emptyArray;\n    }\n    this.#reducer.contribute(state, row);\n    return this.#emitIfChanged(values, stored, state);\n  }\n\n  #remove(row: Row): Stream<'yield'> {\n    const values = this.#groupValues(row);\n    const key = groupKey(values);\n    const stored = must(\n      this.#state(key),\n      'GroupBy: removed a row of a group it lacks',\n    );\n    if (stored.count === 1) {\n      this.#storage.del(key);\n      this.#dirtyGroups.delete(key);\n      return this.#output.push(\n        makeRemoveChange(this.#makeNode(values, stored)),\n        this,\n      );\n    }\n    const state = {...stored};\n    if (isInvertible(this.#reducer.fn)) {\n      this.#reducer.applyInvertible(state, row, -1);\n    } else if (\n      this.#dirtyGroups.has(key) ||\n      !this.#reducer.pushExtreme(\n        state,\n        makeRemoveChange({row, relationships: {}}),\n      )\n    ) {\n      // Keep what was last sent downstream, with the count down by one.\n      this.#dirtyGroups.set(key, row);\n      this.#storage.set(key, {...stored, count: stored.count - 1});\n      return emptyArray;\n    }\n    return this.#emitIfChanged(values, stored, state);\n  }\n\n  /** An edit within a group. */\n  #update(oldRow: Row, row: Row): Stream<'yield'> {\n    const values = this.#groupValues(row);\n    const key = groupKey(values);\n    const stored = this.#state(key);\n    if (\n      stored === undefined ||\n      this.#dirtyGroups.has(key) ||\n      this.#reducer.sameValue(oldRow, row)\n    ) {\n      return emptyArray;\n    }\n    const state = {...stored};\n    if (!isInvertible(this.#reducer.fn)) {\n      // The extreme may have moved in either direction.\n      this.#dirtyGroups.set(key, row);\n      return emptyArray;\n    }\n    this.#reducer.applyInvertible(state, oldRow, -1, true);\n    this.#reducer.applyInvertible(state, row, 1, true);\n    return this.#emitIfChanged(values, stored, state);\n  }\n\n  /** Stores `state` and sends the move from `stored` downstream, if any. */\n  #emitIfChanged(\n    values: readonly NormalizedValue[],\n    stored: AggState,\n    state: AggState,\n  ): Stream<'yield'> {\n    this.#storage.set(groupKey(values), state);\n    if (\n      !this.#reducer.changed(stored, state) &&\n      // A row whose field is null moves only a sum/avg group's row count.\n      !(this.#carriesRows && stored.count !== state.count)\n    ) {\n      return emptyArray;\n    }\n    return this.#output.push(\n      makeEditChange(\n        this.#makeNode(values, state),\n        this.#makeNode(values, stored),\n      ),\n      this,\n    );\n  }\n\n  #state(key: string): AggState | undefined {\n    return this.#storage.get(key);\n  }\n\n  /** Records `state` for the group and returns its row. */\n  #store(values: readonly NormalizedValue[], state: AggState): Node {\n    this.#storage.set(groupKey(values), state);\n    return this.#makeNode(values, state);\n  }\n\n  #makeNode(values: readonly NormalizedValue[], state: AggState): Node {\n    const row: Record<string, Value> = {};\n    for (let i = 0; i < this.#columns.length; i++) {\n      assignProperty(row, this.#columns[i], values[i]);\n    }\n    row[AGGREGATE_KEY_COLUMN] = groupKey(values);\n    this.#reducer.writePayload(row, state);\n    if (this.#carriesRows) {\n      row[AGGREGATE_ROWS_COLUMN] = state.count;\n    }\n    return {row, relationships: {}};\n  }\n\n  /**\n   * A constraint that reads the rows of `row`'s group. It leaves out the\n   * `null` values, which a constraint never matches, so it can read rows of\n   * other groups too, which the caller skips.\n   */\n  #constraint(row: Row): Constraint | undefined {\n    let constraint: Record<string, Value> | undefined;\n    for (const col of this.#columns) {\n      const value = normalizeUndefined(row[col]);\n      if (value !== null) {\n        assignProperty((constraint ??= {}), col, value);\n      }\n    }\n    return constraint;\n  }\n\n  #groupValues(row: Row): NormalizedValue[] {\n    return groupValues(row, this.#columns);\n  }\n}\n\n/**\n * Turns the rows of a {@link GroupBy}, or of the synthetic source a synced\n * client reads them from, into the rows a view of the query shows: the group\n * columns under the query's column names, and, for a `groupBy()` with an\n * aggregate, its value under `valueName` (`count`, `sum`, …). A `distinct()`\n * shows no value, so an edit, which only moves its count, doesn't reach the\n * view.\n */\nexport class GroupProjection implements Operator {\n  readonly #input: Input;\n  // [the view's name, the input's name] of each group column.\n  readonly #columns: readonly (readonly [string, string])[];\n  readonly #valueName: string | undefined;\n  readonly #schema: SourceSchema;\n\n  #output: Output = throwOutput;\n\n  constructor(\n    input: Input,\n    columns: readonly (readonly [string, string])[],\n    valueName?: string | undefined,\n  ) {\n    this.#input = input;\n    this.#columns = columns;\n    this.#valueName = valueName;\n    // The value would overwrite the group column. The query builder rejects\n    // such a query; a hand-built AST can still name one.\n    assert(\n      valueName === undefined || columns.every(([out]) => out !== valueName),\n      () =>\n        `groupBy(): the column \"${valueName}\" has the same name as the ${valueName}() value`,\n    );\n    input.setOutput(this);\n\n    const inputSchema = input.getSchema();\n    const viewName = new Map(columns.map(([out, from]) => [from, out]));\n    const sort: Ordering = must(inputSchema.sort)\n      .filter(([col]) => viewName.has(col))\n      .map(([col, dir]) => [must(viewName.get(col)), dir] as const);\n    const viewColumns: Record<string, SchemaValue> = {};\n    for (const [out, from] of columns) {\n      assignProperty(viewColumns, out, must(inputSchema.columns[from]));\n    }\n    if (valueName !== undefined) {\n      assignProperty(\n        viewColumns,\n        valueName,\n        must(inputSchema.columns[AGGREGATE_VALUE_COLUMN]),\n      );\n    }\n    this.#schema = {\n      tableName: inputSchema.tableName,\n      columns: viewColumns,\n      primaryKey: columns.map(([out]) => out) as unknown as PrimaryKey,\n      relationships: {},\n      isHidden: false,\n      system: inputSchema.system,\n      sort,\n      compareRows: makeComparator(sort),\n    };\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    for (const node of this.#input.fetch(req)) {\n      yield node === 'yield' ? node : this.#project(node);\n    }\n  }\n\n  push(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        return this.#output.push(\n          makeAddChange(this.#project(change[ChangeIndex.NODE])),\n          this,\n        );\n      case ChangeType.REMOVE:\n        return this.#output.push(\n          makeRemoveChange(this.#project(change[ChangeIndex.NODE])),\n          this,\n        );\n      case ChangeType.EDIT: {\n        // A row's key is its group's values, so an edit only moves its\n        // value, which a distinct doesn't show. Nothing is copied unless\n        // the value changed.\n        const node = change[ChangeIndex.NODE];\n        const old = change[ChangeIndex.OLD_NODE];\n        if (\n          this.#valueName === undefined ||\n          node.row[AGGREGATE_VALUE_COLUMN] === old.row[AGGREGATE_VALUE_COLUMN]\n        ) {\n          return emptyArray;\n        }\n        return this.#output.push(\n          makeEditChange(this.#project(node), this.#project(old)),\n          this,\n        );\n      }\n      case ChangeType.CHILD:\n        return emptyArray;\n      default:\n        unreachable(change);\n    }\n  }\n\n  reconcile(_pusher: InputBase): Stream<'yield'> {\n    return this.#output.reconcile ? this.#output.reconcile(this) : emptyArray;\n  }\n\n  #project(node: Node): Node {\n    const row: Record<string, Value> = {};\n    for (const [out, from] of this.#columns) {\n      assignProperty(row, out, node.row[from]);\n    }\n    if (this.#valueName !== undefined) {\n      assignProperty(row, this.#valueName, node.row[AGGREGATE_VALUE_COLUMN]);\n    }\n    return {row, relationships: {}};\n  }\n}\n\n/**\n * The order of a grouped query's rows (its `groupBy`, or the columns a count\n * of distinct combinations groups by): its `orderBy`, which names only those\n * columns, then the rest of them ascending. Other columns, such as the\n * primary key a completed ordering ends with, are left out.\n */\nexport function groupOrdering(ast: AST): Ordering {\n  const columns = must(ast.groupBy ?? ast.aggregate?.distinct);\n  const ordering: [string, 'asc' | 'desc'][] = [];\n  for (const [col, dir] of ast.orderBy ?? []) {\n    if (columns.includes(col) && !ordering.some(([c]) => c === col)) {\n      ordering.push([col, dir]);\n    }\n  }\n  for (const col of columns) {\n    if (!ordering.some(([c]) => c === col)) {\n      ordering.push([col, 'asc']);\n    }\n  }\n  return ordering;\n}\n"],"mappings":"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"}

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

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

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

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

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

@@ -1,4 +1,5 @@
 import { must } from "../../../shared/src/must.js";
+import { assignProperty } from "../../../shared/src/objects.js";
 import { canonicalKey } from "./join-utils.js";
 //#region ../zql/src/ivm/join-index.ts
 var UNPARTITIONED = [void 0];
@@ -56,7 +57,7 @@ var JoinIndex = class {
 		let partition = partitions.get(partKey);
 		if (partition === void 0) {
 			const constraint = {};
-			for (const key of partitionKey) constraint[key] = row[key];
+			for (const key of partitionKey) assignProperty(constraint, key, row[key]);
 			partition = {
 				constraint,
 				pks: /* @__PURE__ */ new Set()

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

@@ -1 +1 @@
-{"version":3,"file":"join-index.js","names":["#parentKey","#primaryKey","#joinKeyIsPK","#partitionKey","#unpartitioned","#partitioned","#size","#pkOf"],"sources":["../../../../../zql/src/ivm/join-index.ts"],"sourcesContent":["import {must} from '../../../shared/src/must.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {canonicalKey} from './join-utils.ts';\n\n/**\n * The partitions of the indexed parents that share a join key, as fetch\n * constraints. An unpartitioned index reports a single `undefined`.\n */\nexport type ParentPartitions = readonly (Record<string, Value> | undefined)[];\n\nconst UNPARTITIONED: ParentPartitions = [undefined];\n\ntype Partition = {\n  readonly constraint: Record<string, Value>;\n  readonly pks: Set<string>;\n};\n\n/**\n * An in-memory index from a join key to the parent rows that have it. Join\n * and FlippedJoin look up a child change's join key here to skip the parent\n * fetch when no indexed parent can see the change.\n *\n * Parents are tracked by primary key so that adding or removing a row twice\n * is harmless. Lookups only report whether any parent has the key and, when\n * the index is partitioned, in which partitions.\n */\nexport class JoinIndex {\n  readonly #parentKey: CompoundKey;\n  readonly #primaryKey: CompoundKey;\n  /** The join key is the primary key, so one string serves as both. */\n  readonly #joinKeyIsPK: boolean;\n  readonly #partitionKey: CompoundKey | undefined;\n  readonly #unpartitioned = new Map<string, Set<string>>();\n  readonly #partitioned = new Map<string, Map<string, Partition>>();\n  #size = 0;\n\n  constructor(\n    parentKey: CompoundKey,\n    primaryKey: CompoundKey,\n    partitionKey?: CompoundKey | undefined,\n  ) {\n    this.#parentKey = parentKey;\n    this.#primaryKey = primaryKey;\n    this.#joinKeyIsPK =\n      parentKey.length === primaryKey.length &&\n      parentKey.every((k, i) => k === primaryKey[i]);\n    this.#partitionKey = partitionKey;\n  }\n\n  /** The number of parent rows in the index. */\n  get size(): number {\n    return this.#size;\n  }\n\n  add(row: Row): void {\n    const joinKey = joinKeyOf(row, this.#parentKey);\n    if (joinKey === undefined) {\n      return;\n    }\n    const pk = this.#pkOf(row, joinKey);\n    const partitionKey = this.#partitionKey;\n    if (partitionKey === undefined) {\n      let pks = this.#unpartitioned.get(joinKey);\n      if (pks === undefined) {\n        pks = new Set();\n        this.#unpartitioned.set(joinKey, pks);\n      }\n      if (!pks.has(pk)) {\n        pks.add(pk);\n        this.#size++;\n      }\n      return;\n    }\n\n    const partKey = canonicalKey(row, partitionKey);\n    let partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      partitions = new Map();\n      this.#partitioned.set(joinKey, partitions);\n    }\n    let partition = partitions.get(partKey);\n    if (partition === undefined) {\n      const constraint: Record<string, Value> = {};\n      for (const key of partitionKey) {\n        constraint[key] = row[key];\n      }\n      partition = {constraint, pks: new Set()};\n      partitions.set(partKey, partition);\n    }\n    if (!partition.pks.has(pk)) {\n      partition.pks.add(pk);\n      this.#size++;\n    }\n  }\n\n  remove(row: Row): void {\n    const joinKey = joinKeyOf(row, this.#parentKey);\n    if (joinKey === undefined) {\n      return;\n    }\n    const pk = this.#pkOf(row, joinKey);\n    const partitionKey = this.#partitionKey;\n    if (partitionKey === undefined) {\n      const pks = this.#unpartitioned.get(joinKey);\n      if (pks === undefined) {\n        return;\n      }\n      if (pks.delete(pk)) {\n        this.#size--;\n        if (pks.size === 0) {\n          this.#unpartitioned.delete(joinKey);\n        }\n      }\n      return;\n    }\n\n    const partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      return;\n    }\n    const partKey = canonicalKey(row, partitionKey);\n    const partition = partitions.get(partKey);\n    if (partition === undefined) {\n      return;\n    }\n    if (partition.pks.delete(pk)) {\n      this.#size--;\n      if (partition.pks.size === 0) {\n        partitions.delete(partKey);\n        if (partitions.size === 0) {\n          this.#partitioned.delete(joinKey);\n        }\n      }\n    }\n  }\n\n  /**\n   * The partitions of the indexed parents whose join key matches `childRow`\n   * over `childKey`, or `undefined` if there are none.\n   */\n  lookup(childRow: Row, childKey: CompoundKey): ParentPartitions | undefined {\n    const joinKey = joinKeyOf(childRow, childKey);\n    if (joinKey === undefined) {\n      return undefined;\n    }\n    if (this.#partitionKey === undefined) {\n      return this.#unpartitioned.has(joinKey) ? UNPARTITIONED : undefined;\n    }\n    const partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      return undefined;\n    }\n    return Array.from(partitions.values(), p => p.constraint);\n  }\n\n  /**\n   * The index as the operator storage entries it replaced, keyed\n   * `j\\0<joinKey>\\0[<partitionKey>\\0]<primaryKey>`. For tests.\n   */\n  entriesForTest(): Record<string, 1> {\n    const entries: Record<string, 1> = {};\n    for (const [joinKey, pks] of this.#unpartitioned) {\n      for (const pk of pks) {\n        entries[`j\\x00${joinKey}\\x00${pk}`] = 1;\n      }\n    }\n    for (const [joinKey, partitions] of this.#partitioned) {\n      const partitionKey = must(this.#partitionKey);\n      for (const {constraint, pks} of partitions.values()) {\n        const partKey = canonicalKey(constraint, partitionKey);\n        for (const pk of pks) {\n          entries[`j\\x00${joinKey}\\x00${partKey}\\x00${pk}`] = 1;\n        }\n      }\n    }\n    return entries;\n  }\n\n  #pkOf(row: Row, joinKey: string): string {\n    return this.#joinKeyIsPK ? joinKey : canonicalKey(row, this.#primaryKey);\n  }\n}\n\n/**\n * The canonical join key of `row`, or `undefined` if any part of it is null:\n * a null key cannot match anything.\n */\nfunction joinKeyOf(row: Row, key: CompoundKey): string | undefined {\n  for (const k of key) {\n    if (row[k] === null) {\n      return undefined;\n    }\n  }\n  return canonicalKey(row, key);\n}\n"],"mappings":"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"}
+{"version":3,"file":"join-index.js","names":[],"sources":["../../../../../zql/src/ivm/join-index.ts"],"sourcesContent":["import {must} from '../../../shared/src/must.ts';\nimport {assignProperty} from '../../../shared/src/objects.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {canonicalKey} from './join-utils.ts';\n\n/**\n * The partitions of the indexed parents that share a join key, as fetch\n * constraints. An unpartitioned index reports a single `undefined`.\n */\nexport type ParentPartitions = readonly (Record<string, Value> | undefined)[];\n\nconst UNPARTITIONED: ParentPartitions = [undefined];\n\ntype Partition = {\n  readonly constraint: Record<string, Value>;\n  readonly pks: Set<string>;\n};\n\n/**\n * An in-memory index from a join key to the parent rows that have it. Join\n * and FlippedJoin look up a child change's join key here to skip the parent\n * fetch when no indexed parent can see the change.\n *\n * Parents are tracked by primary key so that adding or removing a row twice\n * is harmless. Lookups only report whether any parent has the key and, when\n * the index is partitioned, in which partitions.\n */\nexport class JoinIndex {\n  readonly #parentKey: CompoundKey;\n  readonly #primaryKey: CompoundKey;\n  /** The join key is the primary key, so one string serves as both. */\n  readonly #joinKeyIsPK: boolean;\n  readonly #partitionKey: CompoundKey | undefined;\n  readonly #unpartitioned = new Map<string, Set<string>>();\n  readonly #partitioned = new Map<string, Map<string, Partition>>();\n  #size = 0;\n\n  constructor(\n    parentKey: CompoundKey,\n    primaryKey: CompoundKey,\n    partitionKey?: CompoundKey | undefined,\n  ) {\n    this.#parentKey = parentKey;\n    this.#primaryKey = primaryKey;\n    this.#joinKeyIsPK =\n      parentKey.length === primaryKey.length &&\n      parentKey.every((k, i) => k === primaryKey[i]);\n    this.#partitionKey = partitionKey;\n  }\n\n  /** The number of parent rows in the index. */\n  get size(): number {\n    return this.#size;\n  }\n\n  add(row: Row): void {\n    const joinKey = joinKeyOf(row, this.#parentKey);\n    if (joinKey === undefined) {\n      return;\n    }\n    const pk = this.#pkOf(row, joinKey);\n    const partitionKey = this.#partitionKey;\n    if (partitionKey === undefined) {\n      let pks = this.#unpartitioned.get(joinKey);\n      if (pks === undefined) {\n        pks = new Set();\n        this.#unpartitioned.set(joinKey, pks);\n      }\n      if (!pks.has(pk)) {\n        pks.add(pk);\n        this.#size++;\n      }\n      return;\n    }\n\n    const partKey = canonicalKey(row, partitionKey);\n    let partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      partitions = new Map();\n      this.#partitioned.set(joinKey, partitions);\n    }\n    let partition = partitions.get(partKey);\n    if (partition === undefined) {\n      const constraint: Record<string, Value> = {};\n      for (const key of partitionKey) {\n        assignProperty(constraint, key, row[key]);\n      }\n      partition = {constraint, pks: new Set()};\n      partitions.set(partKey, partition);\n    }\n    if (!partition.pks.has(pk)) {\n      partition.pks.add(pk);\n      this.#size++;\n    }\n  }\n\n  remove(row: Row): void {\n    const joinKey = joinKeyOf(row, this.#parentKey);\n    if (joinKey === undefined) {\n      return;\n    }\n    const pk = this.#pkOf(row, joinKey);\n    const partitionKey = this.#partitionKey;\n    if (partitionKey === undefined) {\n      const pks = this.#unpartitioned.get(joinKey);\n      if (pks === undefined) {\n        return;\n      }\n      if (pks.delete(pk)) {\n        this.#size--;\n        if (pks.size === 0) {\n          this.#unpartitioned.delete(joinKey);\n        }\n      }\n      return;\n    }\n\n    const partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      return;\n    }\n    const partKey = canonicalKey(row, partitionKey);\n    const partition = partitions.get(partKey);\n    if (partition === undefined) {\n      return;\n    }\n    if (partition.pks.delete(pk)) {\n      this.#size--;\n      if (partition.pks.size === 0) {\n        partitions.delete(partKey);\n        if (partitions.size === 0) {\n          this.#partitioned.delete(joinKey);\n        }\n      }\n    }\n  }\n\n  /**\n   * The partitions of the indexed parents whose join key matches `childRow`\n   * over `childKey`, or `undefined` if there are none.\n   */\n  lookup(childRow: Row, childKey: CompoundKey): ParentPartitions | undefined {\n    const joinKey = joinKeyOf(childRow, childKey);\n    if (joinKey === undefined) {\n      return undefined;\n    }\n    if (this.#partitionKey === undefined) {\n      return this.#unpartitioned.has(joinKey) ? UNPARTITIONED : undefined;\n    }\n    const partitions = this.#partitioned.get(joinKey);\n    if (partitions === undefined) {\n      return undefined;\n    }\n    return Array.from(partitions.values(), p => p.constraint);\n  }\n\n  /**\n   * The index as the operator storage entries it replaced, keyed\n   * `j\\0<joinKey>\\0[<partitionKey>\\0]<primaryKey>`. For tests.\n   */\n  entriesForTest(): Record<string, 1> {\n    const entries: Record<string, 1> = {};\n    for (const [joinKey, pks] of this.#unpartitioned) {\n      for (const pk of pks) {\n        entries[`j\\x00${joinKey}\\x00${pk}`] = 1;\n      }\n    }\n    for (const [joinKey, partitions] of this.#partitioned) {\n      const partitionKey = must(this.#partitionKey);\n      for (const {constraint, pks} of partitions.values()) {\n        const partKey = canonicalKey(constraint, partitionKey);\n        for (const pk of pks) {\n          entries[`j\\x00${joinKey}\\x00${partKey}\\x00${pk}`] = 1;\n        }\n      }\n    }\n    return entries;\n  }\n\n  #pkOf(row: Row, joinKey: string): string {\n    return this.#joinKeyIsPK ? joinKey : canonicalKey(row, this.#primaryKey);\n  }\n}\n\n/**\n * The canonical join key of `row`, or `undefined` if any part of it is null:\n * a null key cannot match anything.\n */\nfunction joinKeyOf(row: Row, key: CompoundKey): string | undefined {\n  for (const k of key) {\n    if (row[k] === null) {\n      return undefined;\n    }\n  }\n  return canonicalKey(row, key);\n}\n"],"mappings":"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"}

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

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

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

@@ -1,4 +1,5 @@
 import { assert } from "../../../shared/src/asserts.js";
+import { assignProperty } from "../../../shared/src/objects.js";
 import { compareValues, valuesEqual } from "./data.js";
 //#region ../zql/src/ivm/join-utils.ts
 function generateWithOverlayNoYield(stream, overlay, schema) {
@@ -39,19 +40,17 @@ function* generateWithOverlay(stream, overlay, schema) {
 					yieldNode = false;
 				}
 				break;
-			case 3:
-				if (schema.compareRows(overlay[1].row, node.row) === 0) {
-					applied = true;
-					yield {
-						row: node.row,
-						relationships: {
-							...node.relationships,
-							[overlay[2].relationshipName]: () => generateWithOverlay(node.relationships[overlay[2].relationshipName](), overlay[2].change, schema.relationships[overlay[2].relationshipName])
-						}
-					};
-					yieldNode = false;
-				}
-				break;
+			case 3: if (schema.compareRows(overlay[1].row, node.row) === 0) {
+				applied = true;
+				yield {
+					row: node.row,
+					relationships: {
+						...node.relationships,
+						[overlay[2].relationshipName]: () => generateWithOverlay(node.relationships[overlay[2].relationshipName](), overlay[2].change, schema.relationships[overlay[2].relationshipName])
+					}
+				};
+				yieldNode = false;
+			}
 		}
 		if (yieldNode) yield node;
 	}
@@ -120,7 +119,7 @@ function buildJoinConstraint(sourceRow, sourceKey, targetKey) {
 	for (let i = 0; i < targetKey.length; i++) {
 		const value = sourceRow[sourceKey[i]];
 		if (value === null) return;
-		constraint[targetKey[i]] = value;
+		assignProperty(constraint, targetKey[i], value);
 	}
 	return constraint;
 }