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

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

@@ -67,7 +67,7 @@ var Take = class {
 		const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
 		const takeState = this.#storage.get(takeStateKey);
 		if (!takeState) {
-			if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) yield* this.#initialFetch(req);
+			if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) yield* this.#initialFetch(req, takeStateKey);
 			return;
 		}
 		if (takeState.bound === void 0) return;
@@ -84,13 +84,11 @@ var Take = class {
 			if (count >= this.#limit) return;
 		}
 	}
-	*#initialFetch(req) {
+	*#initialFetch(req, takeStateKey) {
 		assert(req.start === void 0, "Start should be undefined");
 		assert(!req.reverse, "Reverse should be false");
 		if (this.#limit === 0) return;
 		assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey), "Constraint should match partition key");
-		const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
-		assert(this.#storage.get(takeStateKey) === void 0, "Take state should be undefined");
 		let size = 0;
 		let bound;
 		let downstreamEarlyReturn = true;

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

@@ -1 +1 @@
-{"version":3,"file":"take.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#dirtyPartitions","#takeGate","#output","#initialFetch","#rowHiddenFromFetch","#setTakeState","#pushEditChange","#getStateAndConstraint","#pushWithRowHiddenFromFetch"],"sources":["../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, type Comparator, type Node} from './data.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 Stream} from './stream.ts';\nimport type {TakeBoundProvider, TakeGate} from './take-gate.ts';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: string): TakeState | undefined;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\ntype DirtyPartitionState = {\n  constraint: Constraint | undefined;\n  /**\n   * The bound to report to upstream TakeGate via getBound() until Phase 2\n   * reconciliation completes.\n   *\n   * When removals reduce partition size below limit in Phase 1, normal getBound()\n   * would return undefined (unbounded), which would cause upstream TakeGate to open\n   * and allow unbounded parent pushes through. Preserving gateBound keeps TakeGate\n   * capped at the pre-removal boundary until Phase 2 refills the deficit.\n   */\n  gateBound: Row | undefined;\n};\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #takeGate: TakeGate | undefined;\n  /**\n   * Partitions that incurred removals in Phase 1 and require deficit refills in\n   * Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching\n   * `#storage` keys: `'[\"take\"]'` when unpartitioned, or `'[\"take\", ...partitionValues]'`\n   * when partitioned.\n   */\n  readonly #dirtyPartitions = new Map<string, DirtyPartitionState>();\n\n  #output: Output = throwOutput;\n\n  setTakeGate(gate: TakeGate): void {\n    this.#takeGate = gate;\n  }\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (\n      this.#partitionKey &&\n      !constraintContainsPartitionKey(constraint, this.#partitionKey)\n    ) {\n      return undefined;\n    }\n    const takeStateKey = getTakeStateKey(this.#partitionKey, constraint);\n    const dirty = this.#dirtyPartitions.get(takeStateKey);\n    if (dirty) {\n      // While dirty in Phase 1, return gateBound (the bound prior to removals) so\n      // upstream operators (e.g. TakeGate) remain capped rather than unbounding during push.\n      return dirty.gateBound;\n    }\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState || takeState.size < this.#limit) {\n      return undefined;\n    }\n    return takeState.bound;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintContainsPartitionKey(req.constraint, this.#partitionKey)),\n      'Partitioned take does not allow unpartitioned fetches',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState) {\n      if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {\n        yield* this.#initialFetch(req);\n      }\n      return;\n    }\n    if (takeState.bound === undefined) {\n      return;\n    }\n    let count = 0;\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n        return;\n      }\n      if (\n        this.#rowHiddenFromFetch &&\n        this.getSchema().compareRows(\n          this.#rowHiddenFromFetch,\n          inputNode.row,\n        ) === 0\n      ) {\n        continue;\n      }\n      yield inputNode;\n      count++;\n      if (count >= this.#limit) {\n        return;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(takeStateKey) === undefined,\n      'Take state should be undefined',\n    );\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(takeStateKey, size, bound);\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        if (this.#dirtyPartitions.has(takeStateKey)) {\n          // While dirty with an unresolved deficit in Phase 1, only admit rows that\n          // sort strictly before the current window boundary. We refuse to expand the\n          // bound forward during Phase 1 so that Phase 2 can backfill earlier candidate\n          // rows from storage in sort order.\n          if (\n            takeState.bound === undefined ||\n            compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n          ) {\n            return;\n          }\n        }\n        const nextSize = takeState.size + 1;\n        if (nextSize === this.#limit) {\n          this.#dirtyPartitions.delete(takeStateKey);\n        }\n        this.#setTakeState(\n          takeStateKey,\n          nextSize,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0 || (compToBound < 0 && this.#limit === 1)) {\n        // change is not in window\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      const finalBound =\n        takeState.size - 1 === 0\n          ? undefined\n          : compToBound < 0\n            ? takeState.bound\n            : beforeBoundNode?.row;\n      if (!this.#dirtyPartitions.has(takeStateKey)) {\n        // Snapshot the pre-removal bound as the gate bound on the first removal that\n        // dirties this partition. Subsequent getBound() calls throughout Phase 1 will return\n        // this bound to keep upstream TakeGate bounded until Phase 2 refills deficits.\n        this.#dirtyPartitions.set(takeStateKey, {\n          constraint,\n          gateBound: takeState.bound,\n        });\n      }\n      this.#setTakeState(takeStateKey, takeState.size - 1, finalBound);\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const replaceBoundAndForwardChange = () => {\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n      );\n      return this.#output.push(change, this);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row);\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          newBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          afterBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row);\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(takeStateKey: string, size: number, bound: Row | undefined) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher?: InputBase): Stream<'yield'> {\n    if (this.#dirtyPartitions.size > 0) {\n      const dirty = [...this.#dirtyPartitions.entries()];\n      this.#dirtyPartitions.clear();\n\n      for (const [takeStateKey, {constraint}] of dirty) {\n        const takeState = this.#storage.get(takeStateKey);\n        assert(\n          takeState !== undefined,\n          'Take: dirty partition must exist in storage',\n        );\n        const deficit = this.#limit - takeState.size;\n        assert(deficit > 0, 'Take: dirty partition must have a deficit');\n\n        const toPush: Node[] = [];\n        this.#takeGate?.open();\n        try {\n          const stream = this.#input.fetch({\n            start: takeState.bound\n              ? {\n                  row: takeState.bound,\n                  basis: 'after',\n                }\n              : undefined,\n            constraint,\n          });\n\n          for (const node of stream) {\n            if (node === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            toPush.push(node);\n            if (toPush.length === deficit) {\n              break;\n            }\n          }\n        } finally {\n          this.#takeGate?.close();\n        }\n\n        let currentSize = takeState.size;\n        for (const node of toPush) {\n          currentSize++;\n          this.#setTakeState(takeStateKey, currentSize, node.row);\n          yield* this.#output.push(makeAddChange(node), this);\n        }\n      }\n    }\n\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintContainsPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"take.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#dirtyPartitions","#takeGate","#output","#initialFetch","#rowHiddenFromFetch","#setTakeState","#pushEditChange","#getStateAndConstraint","#pushWithRowHiddenFromFetch"],"sources":["../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, type Comparator, type Node} from './data.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 Stream} from './stream.ts';\nimport type {TakeBoundProvider, TakeGate} from './take-gate.ts';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: string): TakeState | undefined;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\ntype DirtyPartitionState = {\n  constraint: Constraint | undefined;\n  /**\n   * The bound to report to upstream TakeGate via getBound() until Phase 2\n   * reconciliation completes.\n   *\n   * When removals reduce partition size below limit in Phase 1, normal getBound()\n   * would return undefined (unbounded), which would cause upstream TakeGate to open\n   * and allow unbounded parent pushes through. Preserving gateBound keeps TakeGate\n   * capped at the pre-removal boundary until Phase 2 refills the deficit.\n   */\n  gateBound: Row | undefined;\n};\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #takeGate: TakeGate | undefined;\n  /**\n   * Partitions that incurred removals in Phase 1 and require deficit refills in\n   * Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching\n   * `#storage` keys: `'[\"take\"]'` when unpartitioned, or `'[\"take\", ...partitionValues]'`\n   * when partitioned.\n   */\n  readonly #dirtyPartitions = new Map<string, DirtyPartitionState>();\n\n  #output: Output = throwOutput;\n\n  setTakeGate(gate: TakeGate): void {\n    this.#takeGate = gate;\n  }\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (\n      this.#partitionKey &&\n      !constraintContainsPartitionKey(constraint, this.#partitionKey)\n    ) {\n      return undefined;\n    }\n    const takeStateKey = getTakeStateKey(this.#partitionKey, constraint);\n    const dirty = this.#dirtyPartitions.get(takeStateKey);\n    if (dirty) {\n      // While dirty in Phase 1, return gateBound (the bound prior to removals) so\n      // upstream operators (e.g. TakeGate) remain capped rather than unbounding during push.\n      return dirty.gateBound;\n    }\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState || takeState.size < this.#limit) {\n      return undefined;\n    }\n    return takeState.bound;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintContainsPartitionKey(req.constraint, this.#partitionKey)),\n      'Partitioned take does not allow unpartitioned fetches',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState) {\n      if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {\n        yield* this.#initialFetch(req, takeStateKey);\n      }\n      return;\n    }\n    if (takeState.bound === undefined) {\n      return;\n    }\n    let count = 0;\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n        return;\n      }\n      if (\n        this.#rowHiddenFromFetch &&\n        this.getSchema().compareRows(\n          this.#rowHiddenFromFetch,\n          inputNode.row,\n        ) === 0\n      ) {\n        continue;\n      }\n      yield inputNode;\n      count++;\n      if (count >= this.#limit) {\n        return;\n      }\n    }\n  }\n\n  *#initialFetch(\n    req: FetchRequest,\n    takeStateKey: string,\n  ): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    // The caller (fetch) has already checked that there is no state for\n    // takeStateKey.\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(takeStateKey, size, bound);\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        if (this.#dirtyPartitions.has(takeStateKey)) {\n          // While dirty with an unresolved deficit in Phase 1, only admit rows that\n          // sort strictly before the current window boundary. We refuse to expand the\n          // bound forward during Phase 1 so that Phase 2 can backfill earlier candidate\n          // rows from storage in sort order.\n          if (\n            takeState.bound === undefined ||\n            compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n          ) {\n            return;\n          }\n        }\n        const nextSize = takeState.size + 1;\n        if (nextSize === this.#limit) {\n          this.#dirtyPartitions.delete(takeStateKey);\n        }\n        this.#setTakeState(\n          takeStateKey,\n          nextSize,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0 || (compToBound < 0 && this.#limit === 1)) {\n        // change is not in window\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      const finalBound =\n        takeState.size - 1 === 0\n          ? undefined\n          : compToBound < 0\n            ? takeState.bound\n            : beforeBoundNode?.row;\n      if (!this.#dirtyPartitions.has(takeStateKey)) {\n        // Snapshot the pre-removal bound as the gate bound on the first removal that\n        // dirties this partition. Subsequent getBound() calls throughout Phase 1 will return\n        // this bound to keep upstream TakeGate bounded until Phase 2 refills deficits.\n        this.#dirtyPartitions.set(takeStateKey, {\n          constraint,\n          gateBound: takeState.bound,\n        });\n      }\n      this.#setTakeState(takeStateKey, takeState.size - 1, finalBound);\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const replaceBoundAndForwardChange = () => {\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n      );\n      return this.#output.push(change, this);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row);\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          newBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          afterBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row);\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(takeStateKey: string, size: number, bound: Row | undefined) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher?: InputBase): Stream<'yield'> {\n    if (this.#dirtyPartitions.size > 0) {\n      const dirty = [...this.#dirtyPartitions.entries()];\n      this.#dirtyPartitions.clear();\n\n      for (const [takeStateKey, {constraint}] of dirty) {\n        const takeState = this.#storage.get(takeStateKey);\n        assert(\n          takeState !== undefined,\n          'Take: dirty partition must exist in storage',\n        );\n        const deficit = this.#limit - takeState.size;\n        assert(deficit > 0, 'Take: dirty partition must have a deficit');\n\n        const toPush: Node[] = [];\n        this.#takeGate?.open();\n        try {\n          const stream = this.#input.fetch({\n            start: takeState.bound\n              ? {\n                  row: takeState.bound,\n                  basis: 'after',\n                }\n              : undefined,\n            constraint,\n          });\n\n          for (const node of stream) {\n            if (node === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            toPush.push(node);\n            if (toPush.length === deficit) {\n              break;\n            }\n          }\n        } finally {\n          this.#takeGate?.close();\n        }\n\n        let currentSize = takeState.size;\n        for (const node of toPush) {\n          currentSize++;\n          this.#setTakeState(takeStateKey, currentSize, node.row);\n          yield* this.#output.push(makeAddChange(node), this);\n        }\n      }\n    }\n\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintContainsPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}

package/out/zqlite/src/database-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database-storage.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/database-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAEjC,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,aAAa,IAAI,OAAO,CAAC;IAEzB,gDAAgD;IAChD,OAAO,IAAI,IAAI,CAAC;CACjB;AAcD,eAAO,MAAM,oBAAoB,wJAQ9B,CAAC;AAOJ,qBAAa,eAAe;;IAC1B,MAAM,CAAC,MAAM,CACX,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,EACZ,OAAO;;;KAAiB,GACvB,eAAe,CAiBjB;IAOD,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO;;;KAAiB,EAiCjD;IAED,KAAK,SAGJ;IA+DD,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAuBzD;CACF"}
+{"version":3,"file":"database-storage.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/database-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAEjC,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,aAAa,IAAI,OAAO,CAAC;IAEzB,gDAAgD;IAChD,OAAO,IAAI,IAAI,CAAC;CACjB;AAcD,eAAO,MAAM,oBAAoB,wJAQ9B,CAAC;AAeJ,qBAAa,eAAe;;IAC1B,MAAM,CAAC,MAAM,CACX,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,EACZ,OAAO;;;KAAiB,GACvB,eAAe,CAiBjB;IAOD,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO;;;KAAiB,EAiCjD;IAED,KAAK,SAGJ;IA0DD,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CA4DzD;CACF"}

package/out/zqlite/src/database-storage.js

@@ -9,6 +9,13 @@ var CREATE_STORAGE_TABLE = `
     PRIMARY KEY(clientGroupID, op, key)
   )
   `;
+/**
+* The most values each operator's storage keeps in memory. The storage is in
+* SQLite so that operator state can spill to disk, so only a few values per
+* operator are kept: profiles of the view-syncer gain as much from 64 as from
+* 1,024.
+*/
+var MAX_CACHED_ENTRIES_PER_OP = 64;
 var defaultOptions = {
 	commitInterval: 5e3,
 	compactionThresholdBytes: 50 * 1024 * 1024
@@ -68,10 +75,10 @@ var DatabaseStorage = class DatabaseStorage {
 		this.#checkpoint();
 		this.#db.close();
 	}
-	#get(cgID, opID, key, def) {
+	#get(cgID, opID, key) {
 		this.#maybeCheckpoint();
 		const row = this.#stmts.get.get(cgID, opID, key);
-		return row ? JSON.parse(row.val) : def;
+		return row ? JSON.parse(row.val) : void 0;
 	}
 	#set(cgID, opID, key, val) {
 		this.#maybeCheckpoint();
@@ -107,8 +114,10 @@ var DatabaseStorage = class DatabaseStorage {
 		}
 	}
 	createClientGroupStorage(cgID) {
+		const caches = /* @__PURE__ */ new Set();
 		const destroy = () => {
 			this.#stmts.clear.run(cgID);
+			for (const cache of caches) cache.clear();
 			this.#checkpoint();
 			this.#db.compact(this.#options.compactionThresholdBytes);
 		};
@@ -117,12 +126,35 @@ var DatabaseStorage = class DatabaseStorage {
 		return {
 			createStorage: () => {
 				const opID = nextOpID++;
+				const cache = /* @__PURE__ */ new Map();
+				caches.add(cache);
+				const cacheSet = (key, val) => {
+					if (cache.size >= MAX_CACHED_ENTRIES_PER_OP && !cache.has(key)) cache.clear();
+					cache.set(key, val);
+				};
 				return {
-					get: (key, def) => this.#get(cgID, opID, key, def),
-					set: (key, val) => this.#set(cgID, opID, key, val),
-					del: (key) => this.#del(cgID, opID, key),
+					get: (key, def) => {
+						let val = cache.get(key);
+						if (val === void 0 && !cache.has(key)) {
+							val = this.#get(cgID, opID, key);
+							cacheSet(key, val);
+						}
+						return val === void 0 ? def : val;
+					},
+					set: (key, val) => {
+						this.#set(cgID, opID, key, val);
+						cacheSet(key, val);
+					},
+					del: (key) => {
+						this.#del(cgID, opID, key);
+						cacheSet(key, void 0);
+					},
 					scan: (opts) => this.#scan(cgID, opID, opts),
-					destroy: () => this.#destroy(cgID, opID)
+					destroy: () => {
+						this.#destroy(cgID, opID);
+						cache.clear();
+						caches.delete(cache);
+					}
 				};
 			},
 			destroy

package/out/zqlite/src/database-storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"database-storage.js","names":["#stmts","#options","#db","#checkpoint","#maybeCheckpoint","#numWrites","#scan","#get","#set","#del","#destroy"],"sources":["../../../../zqlite/src/database-storage.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {JSONValue} from '../../shared/src/json.ts';\nimport type {Storage} from '../../zql/src/ivm/operator.ts';\nimport type {Stream} from '../../zql/src/ivm/stream.ts';\nimport type {Statement} from './db.ts';\nimport {Database} from './db.ts';\n\nexport interface ClientGroupStorage {\n  /** Creates a {@link Storage} instance for a single operator. */\n  createStorage(): Storage;\n\n  /** Deletes all storage for the client group. */\n  destroy(): void;\n}\n\ntype Statements = {\n  get: Statement;\n  set: Statement;\n  del: Statement;\n  scan: Statement;\n  clear: Statement;\n  clearOp: Statement;\n  commit: Statement;\n  begin: Statement;\n};\n\n// Exported for testing.\nexport const CREATE_STORAGE_TABLE = `\n  CREATE TABLE storage (\n    clientGroupID TEXT,\n    op NUMBER,\n    key TEXT,\n    val TEXT,\n    PRIMARY KEY(clientGroupID, op, key)\n  )\n  `;\n\nconst defaultOptions = {\n  commitInterval: 5_000,\n  compactionThresholdBytes: 50 * 1024 * 1024,\n};\n\nexport class DatabaseStorage {\n  static create(\n    lc: LogContext,\n    path: string,\n    options = defaultOptions,\n  ): DatabaseStorage {\n    // SQLite is used for ephemeral storage (i.e. similar to RAM) that can spill to\n    // disk to avoid consuming too much memory. Each worker thread gets its own\n    // database (file) and acts as the single reader/writer of the DB, so\n    // `locking_mode` is set to `EXCLUSIVE` for performance. Similarly, since\n    // durability is not important, `synchronous` is set to `OFF` for performance.\n    const db = new Database(lc, path);\n    db.unsafeMode(true); // Allows journal_mode = OFF\n    db.pragma('locking_mode = EXCLUSIVE');\n    db.pragma('foreign_keys = OFF');\n    db.pragma('journal_mode = OFF');\n    db.pragma('synchronous = OFF');\n    db.pragma('auto_vacuum = INCREMENTAL');\n\n    db.prepare(CREATE_STORAGE_TABLE).run();\n    lc.debug?.(`Created DatabaseStorage backed by ${path}`);\n    return new DatabaseStorage(db, options);\n  }\n\n  readonly #stmts: Statements;\n  readonly #options: typeof defaultOptions;\n  readonly #db: Database;\n  #numWrites = 0;\n\n  constructor(db: Database, options = defaultOptions) {\n    this.#stmts = {\n      get: db.prepare(`\n        SELECT val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      set: db.prepare(`\n        INSERT INTO storage (clientGroupID, op, key, val)\n          VALUES(?, ?, ?, ?)\n        ON CONFLICT(clientGroupID, op, key) \n        DO \n          UPDATE SET val = excluded.val\n      `),\n      del: db.prepare(`\n        DELETE FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      scan: db.prepare(`\n        SELECT key, val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key >= ?\n      `),\n      clear: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ?\n      `),\n      clearOp: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ? AND op = ?\n      `),\n      commit: db.prepare('COMMIT'),\n      begin: db.prepare('BEGIN'),\n    };\n    this.#stmts.begin.run();\n    this.#options = options;\n    this.#db = db;\n  }\n\n  close() {\n    this.#checkpoint();\n    this.#db.close();\n  }\n\n  #get(\n    cgID: string,\n    opID: number,\n    key: string,\n    def?: JSONValue,\n  ): JSONValue | undefined {\n    this.#maybeCheckpoint();\n    const row = this.#stmts.get.get<{val: string}>(cgID, opID, key);\n    return row ? JSON.parse(row.val) : def;\n  }\n\n  #set(cgID: string, opID: number, key: string, val: JSONValue) {\n    this.#maybeCheckpoint();\n    this.#stmts.set.run(cgID, opID, key, JSON.stringify(val));\n  }\n\n  #del(cgID: string, opID: number, key: string) {\n    this.#maybeCheckpoint();\n    this.#stmts.del.run(cgID, opID, key);\n  }\n\n  #destroy(cgID: string, opID: number) {\n    this.#maybeCheckpoint();\n    this.#stmts.clearOp.run(cgID, opID);\n  }\n\n  /**\n   * We don't need to commit every single write to the DB\n   * since we're not concerned with durability.\n   * Waiting on commits can be expensive, so we commit\n   * every `COMMIT_INTERVAL` writes.\n   */\n  #maybeCheckpoint() {\n    if (++this.#numWrites >= this.#options.commitInterval) {\n      this.#checkpoint();\n    }\n  }\n\n  #checkpoint() {\n    this.#stmts.commit.run();\n    this.#stmts.begin.run();\n    this.#numWrites = 0;\n  }\n\n  *#scan(\n    cgID: string,\n    opID: number,\n    opts: {prefix: string} = {prefix: ''},\n  ): Stream<[string, JSONValue]> {\n    const {prefix} = opts;\n    for (const {key, val} of this.#stmts.scan.iterate<{\n      key: string;\n      val: string;\n    }>(cgID, opID, prefix)) {\n      if (!key.startsWith(prefix)) {\n        return;\n      }\n      yield [key, JSON.parse(val)];\n    }\n  }\n\n  createClientGroupStorage(cgID: string): ClientGroupStorage {\n    const destroy = () => {\n      this.#stmts.clear.run(cgID);\n      this.#checkpoint();\n      this.#db.compact(this.#options.compactionThresholdBytes);\n    };\n    this.#stmts.clear.run(cgID);\n\n    let nextOpID = 1;\n    return {\n      createStorage: () => {\n        const opID = nextOpID++;\n        return {\n          get: (key, def?) => this.#get(cgID, opID, key, def),\n          set: (key, val) => this.#set(cgID, opID, key, val),\n          del: key => this.#del(cgID, opID, key),\n          scan: opts => this.#scan(cgID, opID, opts),\n          destroy: () => this.#destroy(cgID, opID),\n        };\n      },\n\n      destroy,\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"database-storage.js","names":["#stmts","#options","#db","#checkpoint","#maybeCheckpoint","#numWrites","#scan","#get","#set","#del","#destroy"],"sources":["../../../../zqlite/src/database-storage.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {JSONValue} from '../../shared/src/json.ts';\nimport type {Storage} from '../../zql/src/ivm/operator.ts';\nimport type {Stream} from '../../zql/src/ivm/stream.ts';\nimport type {Statement} from './db.ts';\nimport {Database} from './db.ts';\n\nexport interface ClientGroupStorage {\n  /** Creates a {@link Storage} instance for a single operator. */\n  createStorage(): Storage;\n\n  /** Deletes all storage for the client group. */\n  destroy(): void;\n}\n\ntype Statements = {\n  get: Statement;\n  set: Statement;\n  del: Statement;\n  scan: Statement;\n  clear: Statement;\n  clearOp: Statement;\n  commit: Statement;\n  begin: Statement;\n};\n\n// Exported for testing.\nexport const CREATE_STORAGE_TABLE = `\n  CREATE TABLE storage (\n    clientGroupID TEXT,\n    op NUMBER,\n    key TEXT,\n    val TEXT,\n    PRIMARY KEY(clientGroupID, op, key)\n  )\n  `;\n\n/**\n * The most values each operator's storage keeps in memory. The storage is in\n * SQLite so that operator state can spill to disk, so only a few values per\n * operator are kept: profiles of the view-syncer gain as much from 64 as from\n * 1,024.\n */\nconst MAX_CACHED_ENTRIES_PER_OP = 64;\n\nconst defaultOptions = {\n  commitInterval: 5_000,\n  compactionThresholdBytes: 50 * 1024 * 1024,\n};\n\nexport class DatabaseStorage {\n  static create(\n    lc: LogContext,\n    path: string,\n    options = defaultOptions,\n  ): DatabaseStorage {\n    // SQLite is used for ephemeral storage (i.e. similar to RAM) that can spill to\n    // disk to avoid consuming too much memory. Each worker thread gets its own\n    // database (file) and acts as the single reader/writer of the DB, so\n    // `locking_mode` is set to `EXCLUSIVE` for performance. Similarly, since\n    // durability is not important, `synchronous` is set to `OFF` for performance.\n    const db = new Database(lc, path);\n    db.unsafeMode(true); // Allows journal_mode = OFF\n    db.pragma('locking_mode = EXCLUSIVE');\n    db.pragma('foreign_keys = OFF');\n    db.pragma('journal_mode = OFF');\n    db.pragma('synchronous = OFF');\n    db.pragma('auto_vacuum = INCREMENTAL');\n\n    db.prepare(CREATE_STORAGE_TABLE).run();\n    lc.debug?.(`Created DatabaseStorage backed by ${path}`);\n    return new DatabaseStorage(db, options);\n  }\n\n  readonly #stmts: Statements;\n  readonly #options: typeof defaultOptions;\n  readonly #db: Database;\n  #numWrites = 0;\n\n  constructor(db: Database, options = defaultOptions) {\n    this.#stmts = {\n      get: db.prepare(`\n        SELECT val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      set: db.prepare(`\n        INSERT INTO storage (clientGroupID, op, key, val)\n          VALUES(?, ?, ?, ?)\n        ON CONFLICT(clientGroupID, op, key) \n        DO \n          UPDATE SET val = excluded.val\n      `),\n      del: db.prepare(`\n        DELETE FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      scan: db.prepare(`\n        SELECT key, val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key >= ?\n      `),\n      clear: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ?\n      `),\n      clearOp: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ? AND op = ?\n      `),\n      commit: db.prepare('COMMIT'),\n      begin: db.prepare('BEGIN'),\n    };\n    this.#stmts.begin.run();\n    this.#options = options;\n    this.#db = db;\n  }\n\n  close() {\n    this.#checkpoint();\n    this.#db.close();\n  }\n\n  #get(cgID: string, opID: number, key: string): JSONValue | undefined {\n    this.#maybeCheckpoint();\n    const row = this.#stmts.get.get<{val: string}>(cgID, opID, key);\n    return row ? JSON.parse(row.val) : undefined;\n  }\n\n  #set(cgID: string, opID: number, key: string, val: JSONValue) {\n    this.#maybeCheckpoint();\n    this.#stmts.set.run(cgID, opID, key, JSON.stringify(val));\n  }\n\n  #del(cgID: string, opID: number, key: string) {\n    this.#maybeCheckpoint();\n    this.#stmts.del.run(cgID, opID, key);\n  }\n\n  #destroy(cgID: string, opID: number) {\n    this.#maybeCheckpoint();\n    this.#stmts.clearOp.run(cgID, opID);\n  }\n\n  /**\n   * We don't need to commit every single write to the DB\n   * since we're not concerned with durability.\n   * Waiting on commits can be expensive, so we commit\n   * every `COMMIT_INTERVAL` writes.\n   */\n  #maybeCheckpoint() {\n    if (++this.#numWrites >= this.#options.commitInterval) {\n      this.#checkpoint();\n    }\n  }\n\n  #checkpoint() {\n    this.#stmts.commit.run();\n    this.#stmts.begin.run();\n    this.#numWrites = 0;\n  }\n\n  *#scan(\n    cgID: string,\n    opID: number,\n    opts: {prefix: string} = {prefix: ''},\n  ): Stream<[string, JSONValue]> {\n    const {prefix} = opts;\n    for (const {key, val} of this.#stmts.scan.iterate<{\n      key: string;\n      val: string;\n    }>(cgID, opID, prefix)) {\n      if (!key.startsWith(prefix)) {\n        return;\n      }\n      yield [key, JSON.parse(val)];\n    }\n  }\n\n  createClientGroupStorage(cgID: string): ClientGroupStorage {\n    // The caches of the group's live operator storages.\n    const caches = new Set<Map<string, JSONValue | undefined>>();\n    const destroy = () => {\n      this.#stmts.clear.run(cgID);\n      for (const cache of caches) {\n        cache.clear();\n      }\n      this.#checkpoint();\n      this.#db.compact(this.#options.compactionThresholdBytes);\n    };\n    this.#stmts.clear.run(cgID);\n\n    let nextOpID = 1;\n    return {\n      createStorage: () => {\n        const opID = nextOpID++;\n        // The operator's most recently read and written values, `undefined`\n        // for a key known to be absent. Operators read the same key again and\n        // again (Cap and Take read their state on every fetch and push), so\n        // this saves most of the SQLite reads. Like MemoryStorage, `get`\n        // returns the stored value itself, which operators do not mutate.\n        const cache = new Map<string, JSONValue | undefined>();\n        caches.add(cache);\n        const cacheSet = (key: string, val: JSONValue | undefined) => {\n          if (cache.size >= MAX_CACHED_ENTRIES_PER_OP && !cache.has(key)) {\n            cache.clear();\n          }\n          cache.set(key, val);\n        };\n        return {\n          get: (key, def?) => {\n            let val = cache.get(key);\n            if (val === undefined && !cache.has(key)) {\n              val = this.#get(cgID, opID, key);\n              cacheSet(key, val);\n            }\n            return val === undefined ? def : val;\n          },\n          // The cache is updated only once the database is, so a failed write\n          // leaves it consistent with the database.\n          set: (key, val) => {\n            this.#set(cgID, opID, key, val);\n            cacheSet(key, val);\n          },\n          del: key => {\n            this.#del(cgID, opID, key);\n            cacheSet(key, undefined);\n          },\n          scan: opts => this.#scan(cgID, opID, opts),\n          destroy: () => {\n            this.#destroy(cgID, opID);\n            cache.clear();\n            caches.delete(cache);\n          },\n        };\n      },\n\n      destroy,\n    };\n  }\n}\n"],"mappings":";;AA2BA,IAAa,uBAAuB;;;;;;;;;;;;;;;AAgBpC,IAAM,4BAA4B;AAElC,IAAM,iBAAiB;CACrB,gBAAgB;CAChB,0BAA0B,KAAK,OAAO;AACxC;AAEA,IAAa,kBAAb,MAAa,gBAAgB;CAC3B,OAAO,OACL,IACA,MACA,UAAU,gBACO;EAMjB,MAAM,KAAK,IAAI,SAAS,IAAI,IAAI;EAChC,GAAG,WAAW,IAAI;EAClB,GAAG,OAAO,0BAA0B;EACpC,GAAG,OAAO,oBAAoB;EAC9B,GAAG,OAAO,oBAAoB;EAC9B,GAAG,OAAO,mBAAmB;EAC7B,GAAG,OAAO,2BAA2B;EAErC,GAAG,QAAQ,oBAAoB,EAAE,IAAI;EACrC,GAAG,QAAQ,qCAAqC,MAAM;EACtD,OAAO,IAAI,gBAAgB,IAAI,OAAO;CACxC;CAEA;CACA;CACA;CACA,aAAa;CAEb,YAAY,IAAc,UAAU,gBAAgB;EAClD,KAAKA,SAAS;GACZ,KAAK,GAAG,QAAQ;;;OAGf;GACD,KAAK,GAAG,QAAQ;;;;;;OAMf;GACD,KAAK,GAAG,QAAQ;;;OAGf;GACD,MAAM,GAAG,QAAQ;;;OAGhB;GACD,OAAO,GAAG,QAAQ;;OAEjB;GACD,SAAS,GAAG,QAAQ;;OAEnB;GACD,QAAQ,GAAG,QAAQ,QAAQ;GAC3B,OAAO,GAAG,QAAQ,OAAO;EAC3B;EACA,KAAKA,OAAO,MAAM,IAAI;EACtB,KAAKC,WAAW;EAChB,KAAKC,MAAM;CACb;CAEA,QAAQ;EACN,KAAKC,YAAY;EACjB,KAAKD,IAAI,MAAM;CACjB;CAEA,KAAK,MAAc,MAAc,KAAoC;EACnE,KAAKE,iBAAiB;EACtB,MAAM,MAAM,KAAKJ,OAAO,IAAI,IAAmB,MAAM,MAAM,GAAG;EAC9D,OAAO,MAAM,KAAK,MAAM,IAAI,GAAG,IAAI,KAAA;CACrC;CAEA,KAAK,MAAc,MAAc,KAAa,KAAgB;EAC5D,KAAKI,iBAAiB;EACtB,KAAKJ,OAAO,IAAI,IAAI,MAAM,MAAM,KAAK,KAAK,UAAU,GAAG,CAAC;CAC1D;CAEA,KAAK,MAAc,MAAc,KAAa;EAC5C,KAAKI,iBAAiB;EACtB,KAAKJ,OAAO,IAAI,IAAI,MAAM,MAAM,GAAG;CACrC;CAEA,SAAS,MAAc,MAAc;EACnC,KAAKI,iBAAiB;EACtB,KAAKJ,OAAO,QAAQ,IAAI,MAAM,IAAI;CACpC;;;;;;;CAQA,mBAAmB;EACjB,IAAI,EAAE,KAAKK,cAAc,KAAKJ,SAAS,gBACrC,KAAKE,YAAY;CAErB;CAEA,cAAc;EACZ,KAAKH,OAAO,OAAO,IAAI;EACvB,KAAKA,OAAO,MAAM,IAAI;EACtB,KAAKK,aAAa;CACpB;CAEA,CAACC,MACC,MACA,MACA,OAAyB,EAAC,QAAQ,GAAE,GACP;EAC7B,MAAM,EAAC,WAAU;EACjB,KAAK,MAAM,EAAC,KAAK,SAAQ,KAAKN,OAAO,KAAK,QAGvC,MAAM,MAAM,MAAM,GAAG;GACtB,IAAI,CAAC,IAAI,WAAW,MAAM,GACxB;GAEF,MAAM,CAAC,KAAK,KAAK,MAAM,GAAG,CAAC;EAC7B;CACF;CAEA,yBAAyB,MAAkC;EAEzD,MAAM,yBAAS,IAAI,IAAwC;EAC3D,MAAM,gBAAgB;GACpB,KAAKA,OAAO,MAAM,IAAI,IAAI;GAC1B,KAAK,MAAM,SAAS,QAClB,MAAM,MAAM;GAEd,KAAKG,YAAY;GACjB,KAAKD,IAAI,QAAQ,KAAKD,SAAS,wBAAwB;EACzD;EACA,KAAKD,OAAO,MAAM,IAAI,IAAI;EAE1B,IAAI,WAAW;EACf,OAAO;GACL,qBAAqB;IACnB,MAAM,OAAO;IAMb,MAAM,wBAAQ,IAAI,IAAmC;IACrD,OAAO,IAAI,KAAK;IAChB,MAAM,YAAY,KAAa,QAA+B;KAC5D,IAAI,MAAM,QAAQ,6BAA6B,CAAC,MAAM,IAAI,GAAG,GAC3D,MAAM,MAAM;KAEd,MAAM,IAAI,KAAK,GAAG;IACpB;IACA,OAAO;KACL,MAAM,KAAK,QAAS;MAClB,IAAI,MAAM,MAAM,IAAI,GAAG;MACvB,IAAI,QAAQ,KAAA,KAAa,CAAC,MAAM,IAAI,GAAG,GAAG;OACxC,MAAM,KAAKO,KAAK,MAAM,MAAM,GAAG;OAC/B,SAAS,KAAK,GAAG;MACnB;MACA,OAAO,QAAQ,KAAA,IAAY,MAAM;KACnC;KAGA,MAAM,KAAK,QAAQ;MACjB,KAAKC,KAAK,MAAM,MAAM,KAAK,GAAG;MAC9B,SAAS,KAAK,GAAG;KACnB;KACA,MAAK,QAAO;MACV,KAAKC,KAAK,MAAM,MAAM,GAAG;MACzB,SAAS,KAAK,KAAA,CAAS;KACzB;KACA,OAAM,SAAQ,KAAKH,MAAM,MAAM,MAAM,IAAI;KACzC,eAAe;MACb,KAAKI,SAAS,MAAM,IAAI;MACxB,MAAM,MAAM;MACZ,OAAO,OAAO,KAAK;KACrB;IACF;GACF;GAEA;EACF;CACF;AACF"}

package/out/zqlite/src/fetch-sql.d.ts

@@ -0,0 +1,27 @@
+import type { Ordering } from '../../zero-protocol/src/ast.ts';
+import type { SchemaValue } from '../../zero-schema/src/table-schema.ts';
+import type { FetchRequest } from '../../zql/src/ivm/operator.ts';
+import { type NoSubqueryCondition } from './query-builder.ts';
+export type FetchSQL = {
+    readonly text: string;
+    readonly values: readonly unknown[];
+};
+/**
+ * Builds the SELECTs of {@link buildSelectQueries} for the fetches of one
+ * connection, formatting the SQL text only once per fetch shape.
+ *
+ * Building and formatting the SQL is a fixed cost of every fetch that is
+ * comparable to running the statement for the small fetches IVM does most.
+ * The text depends only on the fetch's shape, though: which columns it
+ * constrains, how many entries each multi-constraint has, its direction,
+ * which columns of its start row are NULL, and its `req.filter`. The values
+ * are bound to `?` placeholders, so a shape's text is built once with a
+ * {@link Binding} in place of each value, and each fetch only reads its values
+ * from those.
+ */
+export declare class FetchSQLCache {
+    #private;
+    constructor(tableName: string, columns: Record<string, SchemaValue>, filters: NoSubqueryCondition | undefined, order: Ordering | undefined);
+    get(req: FetchRequest): FetchSQL[];
+}
+//# sourceMappingURL=fetch-sql.d.ts.map

package/out/zqlite/src/fetch-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-sql.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/fetch-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gCAAgC,CAAC;AAE7D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,uCAAuC,CAAC;AAEvE,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;CACrC,CAAC;AAYF;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;;IAOxB,YACE,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAM5B;IAED,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,QAAQ,EAAE,CAcjC;CA2GF"}

package/out/zqlite/src/fetch-sql.js

@@ -0,0 +1,112 @@
+import { assignProperty } from "../../shared/src/objects.js";
+import { format } from "./internal/sql.js";
+import { Binding, buildSelectQueries, toSQLiteType } from "./query-builder.js";
+//#region ../zqlite/src/fetch-sql.ts
+/**
+* More shapes than a connection is expected to fetch. Past it the cache is
+* cleared, which bounds it if some fetch parameter that is part of the shape
+* (a `req.filter` that is not the same object every time, say) never repeats.
+*/
+var MAX_SHAPES = 256;
+var filterIDs = /* @__PURE__ */ new WeakMap();
+var nextFilterID = 0;
+/**
+* Builds the SELECTs of {@link buildSelectQueries} for the fetches of one
+* connection, formatting the SQL text only once per fetch shape.
+*
+* Building and formatting the SQL is a fixed cost of every fetch that is
+* comparable to running the statement for the small fetches IVM does most.
+* The text depends only on the fetch's shape, though: which columns it
+* constrains, how many entries each multi-constraint has, its direction,
+* which columns of its start row are NULL, and its `req.filter`. The values
+* are bound to `?` placeholders, so a shape's text is built once with a
+* {@link Binding} in place of each value, and each fetch only reads its values
+* from those.
+*/
+var FetchSQLCache = class {
+	#tableName;
+	#columns;
+	#filters;
+	#order;
+	#templates = /* @__PURE__ */ new Map();
+	constructor(tableName, columns, filters, order) {
+		this.#tableName = tableName;
+		this.#columns = columns;
+		this.#filters = filters;
+		this.#order = order;
+	}
+	get(req) {
+		const key = this.#shapeKey(req);
+		let templates = this.#templates.get(key);
+		if (templates === void 0) {
+			templates = this.#buildTemplates(req);
+			if (this.#templates.size >= MAX_SHAPES) this.#templates.clear();
+			this.#templates.set(key, templates);
+		}
+		return templates.map(({ text, values }) => ({
+			text,
+			values: values.map((v) => v instanceof Binding ? v.get(req) : v)
+		}));
+	}
+	#shapeKey(req) {
+		const { constraint, multiConstraints, start, filter } = req;
+		let key = req.reverse ? "r" : "f";
+		if (constraint) for (const k in constraint) key += k + "\0";
+		key += "\0";
+		if (multiConstraints) for (const mc of multiConstraints) {
+			key += mc.length + "\0";
+			if (mc.length > 0) for (const k in mc[0]) key += k + "\0";
+			key += "\0";
+		}
+		key += "\0";
+		if (start) {
+			key += start.basis;
+			for (const [field] of this.#order ?? []) key += isNullish(start.row[field]) ? "0" : "1";
+		}
+		key += "\0";
+		if (filter) {
+			let id = filterIDs.get(filter);
+			if (id === void 0) {
+				id = nextFilterID++;
+				filterIDs.set(filter, id);
+			}
+			key += id;
+		}
+		return key;
+	}
+	#buildTemplates(req) {
+		const columns = this.#columns;
+		const binding = (get, field) => {
+			const { type } = columns[field];
+			return new Binding((req) => toSQLiteType(get(req), type));
+		};
+		let constraint;
+		if (req.constraint) {
+			const probe = {};
+			for (const k in req.constraint) assignProperty(probe, k, binding((req) => req.constraint[k], k));
+			constraint = probe;
+		}
+		const multiConstraints = req.multiConstraints?.map((mc, i) => mc.map((entry, j) => {
+			const probe = {};
+			for (const k in entry) assignProperty(probe, k, binding((req) => req.multiConstraints[i][j][k], k));
+			return probe;
+		}));
+		let start;
+		if (req.start) {
+			const row = {};
+			for (const [field] of this.#order ?? []) assignProperty(row, field, isNullish(req.start.row[field]) ? null : binding((req) => req.start.row[field], field));
+			start = {
+				basis: req.start.basis,
+				row
+			};
+		}
+		return buildSelectQueries(this.#tableName, columns, constraint, this.#filters, this.#order, req.reverse, start, multiConstraints, req.filter).map((query) => format(query));
+	}
+};
+function isNullish(v) {
+	return v === null || v === void 0;
+}
+//#endregion
+export { FetchSQLCache };
+
+//# sourceMappingURL=fetch-sql.js.map

package/out/zqlite/src/fetch-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-sql.js","names":["#tableName","#columns","#filters","#order","#templates","#shapeKey","#buildTemplates"],"sources":["../../../../zqlite/src/fetch-sql.ts"],"sourcesContent":["import {assignProperty} from '../../shared/src/objects.ts';\nimport type {Ordering} from '../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../zero-protocol/src/data.ts';\nimport type {SchemaValue} from '../../zero-schema/src/table-schema.ts';\nimport type {Constraint} from '../../zql/src/ivm/constraint.ts';\nimport type {\n  FetchRequest,\n  MultiConstraint,\n} from '../../zql/src/ivm/operator.ts';\nimport {format} from './internal/sql.ts';\nimport {\n  Binding,\n  buildSelectQueries,\n  toSQLiteType,\n  type NoSubqueryCondition,\n} from './query-builder.ts';\n\nexport type FetchSQL = {\n  readonly text: string;\n  readonly values: readonly unknown[];\n};\n\n/**\n * More shapes than a connection is expected to fetch. Past it the cache is\n * cleared, which bounds it if some fetch parameter that is part of the shape\n * (a `req.filter` that is not the same object every time, say) never repeats.\n */\nconst MAX_SHAPES = 256;\n\nconst filterIDs = new WeakMap<NoSubqueryCondition, number>();\nlet nextFilterID = 0;\n\n/**\n * Builds the SELECTs of {@link buildSelectQueries} for the fetches of one\n * connection, formatting the SQL text only once per fetch shape.\n *\n * Building and formatting the SQL is a fixed cost of every fetch that is\n * comparable to running the statement for the small fetches IVM does most.\n * The text depends only on the fetch's shape, though: which columns it\n * constrains, how many entries each multi-constraint has, its direction,\n * which columns of its start row are NULL, and its `req.filter`. The values\n * are bound to `?` placeholders, so a shape's text is built once with a\n * {@link Binding} in place of each value, and each fetch only reads its values\n * from those.\n */\nexport class FetchSQLCache {\n  readonly #tableName: string;\n  readonly #columns: Record<string, SchemaValue>;\n  readonly #filters: NoSubqueryCondition | undefined;\n  readonly #order: Ordering | undefined;\n  readonly #templates = new Map<string, readonly FetchSQL[]>();\n\n  constructor(\n    tableName: string,\n    columns: Record<string, SchemaValue>,\n    filters: NoSubqueryCondition | undefined,\n    order: Ordering | undefined,\n  ) {\n    this.#tableName = tableName;\n    this.#columns = columns;\n    this.#filters = filters;\n    this.#order = order;\n  }\n\n  get(req: FetchRequest): FetchSQL[] {\n    const key = this.#shapeKey(req);\n    let templates = this.#templates.get(key);\n    if (templates === undefined) {\n      templates = this.#buildTemplates(req);\n      if (this.#templates.size >= MAX_SHAPES) {\n        this.#templates.clear();\n      }\n      this.#templates.set(key, templates);\n    }\n    return templates.map(({text, values}) => ({\n      text,\n      values: values.map(v => (v instanceof Binding ? v.get(req) : v)),\n    }));\n  }\n\n  // Column names are never empty and never contain NUL, so terminating each\n  // with NUL and each list with an extra NUL keeps distinct shapes distinct.\n  #shapeKey(req: FetchRequest): string {\n    const {constraint, multiConstraints, start, filter} = req;\n    let key = req.reverse ? 'r' : 'f';\n    if (constraint) {\n      for (const k in constraint) {\n        key += k + '\\0';\n      }\n    }\n    key += '\\0';\n    if (multiConstraints) {\n      for (const mc of multiConstraints) {\n        key += mc.length + '\\0';\n        if (mc.length > 0) {\n          for (const k in mc[0]) {\n            key += k + '\\0';\n          }\n        }\n        key += '\\0';\n      }\n    }\n    key += '\\0';\n    if (start) {\n      key += start.basis;\n      // Only the order's columns of the start row are read.\n      for (const [field] of this.#order ?? []) {\n        key += isNullish(start.row[field]) ? '0' : '1';\n      }\n    }\n    key += '\\0';\n    if (filter) {\n      let id = filterIDs.get(filter);\n      if (id === undefined) {\n        id = nextFilterID++;\n        filterIDs.set(filter, id);\n      }\n      key += id;\n    }\n    return key;\n  }\n\n  #buildTemplates(req: FetchRequest): FetchSQL[] {\n    const columns = this.#columns;\n    const binding = (\n      get: (req: FetchRequest) => unknown,\n      field: string,\n    ): Binding => {\n      const {type} = columns[field];\n      return new Binding(req => toSQLiteType(get(req), type));\n    };\n\n    let constraint: Constraint | undefined;\n    if (req.constraint) {\n      const probe: Record<string, unknown> = {};\n      for (const k in req.constraint) {\n        assignProperty(\n          probe,\n          k,\n          binding(req => req.constraint![k], k),\n        );\n      }\n      constraint = probe as Constraint;\n    }\n    const multiConstraints = req.multiConstraints?.map(\n      (mc, i): MultiConstraint =>\n        mc.map((entry, j) => {\n          const probe: Record<string, unknown> = {};\n          for (const k in entry) {\n            assignProperty(\n              probe,\n              k,\n              binding(req => req.multiConstraints![i][j][k], k),\n            );\n          }\n          return probe as Row;\n        }),\n    );\n    let start: FetchRequest['start'];\n    if (req.start) {\n      const row: Record<string, unknown> = {};\n      for (const [field] of this.#order ?? []) {\n        assignProperty(\n          row,\n          field,\n          isNullish(req.start.row[field])\n            ? null\n            : binding(req => req.start!.row[field], field),\n        );\n      }\n      start = {basis: req.start.basis, row: row as Row};\n    }\n\n    return buildSelectQueries(\n      this.#tableName,\n      columns,\n      constraint,\n      this.#filters,\n      this.#order,\n      req.reverse,\n      start,\n      multiConstraints,\n      req.filter,\n    ).map(query => format(query));\n  }\n}\n\nfunction isNullish(v: unknown): boolean {\n  return v === null || v === undefined;\n}\n"],"mappings":"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"}

package/out/zqlite/src/query-builder.d.ts

@@ -2,7 +2,7 @@ import type { SQLQuery } from '@databases/sql';
 import type { Condition, Ordering } from '../../zero-protocol/src/ast.ts';
 import type { SchemaValue, ValueType } from '../../zero-schema/src/table-schema.ts';
 import type { Constraint } from '../../zql/src/ivm/constraint.ts';
-import type { MultiConstraint, Start } from '../../zql/src/ivm/operator.ts';
+import type { FetchRequest, MultiConstraint, Start } from '../../zql/src/ivm/operator.ts';
 /**
  * Condition type without correlated subqueries.
  * This matches the output of transformFilters from zql/builder/filter.ts
@@ -47,4 +47,14 @@ export declare function orderByToSQL(order: Ordering, reverse: boolean): SQLQuer
  */
 export declare function filtersToSQL(filters: NoSubqueryCondition): SQLQuery;
 export declare function toSQLiteType(v: unknown, type: ValueType): unknown;
+/**
+ * A placeholder for a fetch's value that {@link buildSelectQueries} passes
+ * through to the bindings of its SELECTs, where `toSQLiteType` would convert
+ * the value itself. It lets a fetch's SQL text be built once and reused for
+ * every fetch of the same shape (see `fetch-sql.ts`).
+ */
+export declare class Binding {
+    readonly get: (req: FetchRequest) => unknown;
+    constructor(get: (req: FetchRequest) => unknown);
+}
 //# sourceMappingURL=query-builder.d.ts.map

package/out/zqlite/src/query-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/query-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EAGT,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACV,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAE,KAAK,EAAC,MAAM,+BAA+B,CAAC;AAG1E;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,SAAS,EACT;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAC,CAC7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAC3B,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EACzD,YAAY,CAAC,EAAE,mBAAmB,GAAG,SAAS,GAC7C,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CA4DnC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAC7C,QAAQ,CAOV;AA0DD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,cAcrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACnC,QAAQ,CAyCV;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,CAmBxE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAuBnE;AAgGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAWjE"}
+{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/query-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EAGT,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACV,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,KAAK,EACN,MAAM,+BAA+B,CAAC;AAGvC;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,SAAS,EACT;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAC,CAC7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAC3B,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EACzD,YAAY,CAAC,EAAE,mBAAmB,GAAG,SAAS,GAC7C,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CA4DnC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAC7C,QAAQ,CAOV;AA0DD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,cAcrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACnC,QAAQ,CAyCV;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,CAmBxE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAuBnE;AAgGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAWjE;AAED;;;;;GAKG;AACH,qBAAa,OAAO;IAClB,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC;IAC7C,YAAY,GAAG,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,EAE9C;CACF"}

package/out/zqlite/src/query-builder.js

@@ -87,7 +87,7 @@ function constraintsRejectNull(constraint, multiConstraints, field) {
 function constraintsToSQL(constraint, columns) {
 	if (!constraint) return [];
 	const constraints = [];
-	for (const [key, value] of Object.entries(constraint)) constraints.push(sql`${sql.ident(key)} = ${toSQLiteType(value, columns[key].type)}`);
+	for (const [key, value] of Object.entries(constraint)) constraints.push(sql`${sql.ident(key)} = ${toSQLiteBinding(value, columns[key].type)}`);
 	return constraints;
 }
 /**
@@ -112,10 +112,10 @@ function multiConstraintToSQL(multiConstraint, columns) {
 	if (keys.length === 1) {
 		const key = keys[0];
 		const colType = columns[key].type;
-		return sql`${sql.ident(key)} IN (${sql.join(multiConstraint.map((c) => sql`${toSQLiteType(c[key], colType)}`), sql`,`)})`;
+		return sql`${sql.ident(key)} IN (${sql.join(multiConstraint.map((c) => sql`${toSQLiteBinding(c[key], colType)}`), sql`,`)})`;
 	}
 	const colList = sql`(${sql.join(keys.map((k) => sql.ident(k)), sql`,`)})`;
-	const rows = multiConstraint.map((c) => sql`(${sql.join(keys.map((k) => sql`${toSQLiteType(c[k], columns[k].type)}`), sql`,`)})`);
+	const rows = multiConstraint.map((c) => sql`(${sql.join(keys.map((k) => sql`${toSQLiteBinding(c[k], columns[k].type)}`), sql`,`)})`);
 	return sql`${colList} IN (VALUES ${sql.join(rows, sql`,`)})`;
 }
 function orderByToSQL(order, reverse) {
@@ -173,6 +173,21 @@ function toSQLiteType(v, type) {
 		case "json": return JSON.stringify(v);
 	}
 }
+/**
+* A placeholder for a fetch's value that {@link buildSelectQueries} passes
+* through to the bindings of its SELECTs, where `toSQLiteType` would convert
+* the value itself. It lets a fetch's SQL text be built once and reused for
+* every fetch of the same shape (see `fetch-sql.ts`).
+*/
+var Binding = class {
+	get;
+	constructor(get) {
+		this.get = get;
+	}
+};
+function toSQLiteBinding(v, type) {
+	return v instanceof Binding ? v : toSQLiteType(v, type);
+}
 function nullableAwareEquality(field, value, columnType) {
 	if (value === null) return sql`${sql.ident(field)} IS NULL`;
 	return columnType.optional === true ? sql`${sql.ident(field)} IS ${value}` : sql`${sql.ident(field)} = ${value}`;
@@ -226,7 +241,7 @@ function gatherStartConstraints(start, reverse, order, columnTypes) {
 		const [iField, iDirection] = order[i];
 		for (let j = 0; j <= i; j++) if (j === i) {
 			const columnType = columnTypes[iField];
-			const constraintValue = toSQLiteType(from[iField] ?? null, columnType.type);
+			const constraintValue = toSQLiteBinding(from[iField] ?? null, columnType.type);
 			const operator = iDirection === "asc" ? reverse ? "<" : ">" : reverse ? ">" : "<";
 			let nullGroupExcluded = false;
 			if (i === 0) {
@@ -237,14 +252,14 @@ function gatherStartConstraints(start, reverse, order, columnTypes) {
 		} else {
 			const [jField] = order[j];
 			const columnType = columnTypes[jField];
-			const value = toSQLiteType(from[jField] ?? null, columnType.type);
+			const value = toSQLiteBinding(from[jField] ?? null, columnType.type);
 			group.push(nullableAwareEquality(jField, value, columnType));
 		}
 		constraints.push(sql`(${sql.join(group, sql` AND `)})`);
 	}
 	if (basis === "at") constraints.push(sql`(${sql.join(order.map(([field]) => {
 		const columnType = columnTypes[field];
-		return nullableAwareEquality(field, toSQLiteType(from[field] ?? null, columnType.type), columnType);
+		return nullableAwareEquality(field, toSQLiteBinding(from[field] ?? null, columnType.type), columnType);
 	}), sql` AND `)})`);
 	const lexicographicStart = sql`(${sql.join(constraints, sql` OR `)})`;
 	if (leadingBound === void 0) return {
@@ -257,6 +272,6 @@ function gatherStartConstraints(start, reverse, order, columnTypes) {
 	};
 }
 //#endregion
-export { buildSelectQueries, buildSelectQuery, toSQLiteType };
+export { Binding, buildSelectQueries, buildSelectQuery, toSQLiteType };
 
 //# sourceMappingURL=query-builder.js.map