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

package/out/zqlite/src/pending-delta.js

@@ -0,0 +1,278 @@
+import { hasOwn } from "../../shared/src/has-own.js";
+import { constraintMatchesPrimaryKey, constraintMatchesRow } from "../../zql/src/ivm/constraint.js";
+import { BTreeSet } from "../../shared/src/btree-set.js";
+import { generateRows, makeBoundComparator, maxValue, minValue } from "../../zql/src/ivm/memory-source.js";
+//#region ../zqlite/src/pending-delta.ts
+/**
+* The batch overlay that lets a `TableSource` derive a transaction without
+* writing to the database it is reading from.
+*
+* A `TableSource` normally makes each change durable in its backing SQLite
+* connection as soon as it has been vended to every output, because change
+* *k+1* has to read a base that already includes changes *1..k* -- IVM's
+* joins fetch from the source mid-push. On the server that backing connection
+* is a `BEGIN CONCURRENT` snapshot that is never committed and always rolled
+* back, so those writes exist only to serve reads for the rest of the pass.
+*
+* A `PendingDelta` holds them in memory instead. The base stays pinned at the
+* state it had when the pass began and this object supplies *1..k*, merged
+* into every leaf scan. The durable copy comes from the replicator's own
+* commit, which the source picks up when it leapfrogs to the next snapshot.
+*
+* State is coalesced by primary key: whatever the batch did to a row, all that
+* matters downstream is the row's final value, or that it is gone. A key that
+* appears here overrides the base unconditionally -- an added row has no base
+* to override, an edited row's base copy is suppressed in favor of the new
+* value, and a removed row's base copy is suppressed with nothing to put in
+* its place.
+*
+* Live rows are additionally kept in lazily built sorted indexes, one per
+* `[...constraintKeys, ...sort]` shape a fetch has asked for, so that merging
+* the delta into a constrained scan costs `O(log D + matches)` rather than a
+* walk of the whole delta. This mirrors `MemorySource`'s index handling; see
+* its `#fetch` for the bound construction the scans here reproduce.
+*/
+var PendingDelta = class {
+	#primaryKey;
+	#singleColumnKey;
+	/**
+	* For a composite primary key, the first key column's value of every key in
+	* `#byKey`. {@link overrides} runs for every base row of a merged fetch, and
+	* building a composite key allocates, so this rules most rows out first.
+	*/
+	#firstKeyValues = /* @__PURE__ */ new Set();
+	/**
+	* The coalesced net state, keyed by primary key. A `undefined` value is a
+	* tombstone: the batch removed the row, so the base copy is suppressed and
+	* nothing replaces it. Membership alone is what suppresses a base row, so
+	* this map is also the "is this key overridden" test.
+	*/
+	#byKey = /* @__PURE__ */ new Map();
+	/** Sorted views over the live (non-tombstone) rows, keyed by `JSON(sort)`. */
+	#indexes = /* @__PURE__ */ new Map();
+	#liveCount = 0;
+	#rowBytes = 0;
+	#indexBytes = 0;
+	constructor(primaryKey) {
+		this.#primaryKey = primaryKey;
+		this.#singleColumnKey = primaryKey.length === 1 ? primaryKey[0] : void 0;
+	}
+	/**
+	* True when the source can take its untouched fast path: no suppression
+	* test per base row, no merge, no index maintenance.
+	*/
+	get isEmpty() {
+		return this.#byKey.size === 0;
+	}
+	/** The number of rows the batch has touched, tombstones included. */
+	get size() {
+		return this.#byKey.size;
+	}
+	/**
+	* Estimated retained bytes, including keys, tombstones, and sorted indexes.
+	* This is a budgeting heuristic, not a measurement of the JavaScript heap.
+	*/
+	get estimatedBytes() {
+		return this.#rowBytes + this.#indexBytes + this.#liveCount * this.#indexes.size * 32;
+	}
+	#key(row) {
+		const single = this.#singleColumnKey;
+		if (single !== void 0) return row[single];
+		const key = this.#primaryKey.map((k) => row[k]);
+		return JSON.stringify(key);
+	}
+	#track(row, key) {
+		if (this.#byKey.has(key)) return;
+		this.#rowBytes += 64 + estimateBytes(key);
+		if (this.#singleColumnKey === void 0) this.#firstKeyValues.add(row[this.#primaryKey[0]]);
+	}
+	/** Records that `row` is now present with this value. */
+	set(row) {
+		const key = this.#key(row);
+		const existing = this.#byKey.get(key);
+		this.#track(row, key);
+		this.#rowBytes += estimateBytes(row) - (existing === void 0 ? 0 : estimateBytes(existing));
+		if (existing !== void 0) {
+			this.#removeFromIndexes(existing);
+			this.#liveCount--;
+		}
+		this.#byKey.set(key, row);
+		this.#addToIndexes(row);
+		this.#liveCount++;
+	}
+	/** Records that `row` is now absent. */
+	delete(row) {
+		const key = this.#key(row);
+		const existing = this.#byKey.get(key);
+		this.#track(row, key);
+		if (existing !== void 0) {
+			this.#rowBytes -= estimateBytes(existing);
+			this.#removeFromIndexes(existing);
+			this.#liveCount--;
+		}
+		this.#byKey.set(key, void 0);
+	}
+	/**
+	* Whether the batch overrides this base row. Callers use it to suppress base
+	* rows during a merge, so it must be answered by primary key -- the value
+	* carried by the base row is exactly what the delta is replacing.
+	*/
+	overrides(row) {
+		if (this.#singleColumnKey === void 0 && !this.#firstKeyValues.has(row[this.#primaryKey[0]])) return false;
+		return this.#byKey.has(this.#key(row));
+	}
+	/**
+	* The batch's value for a row, by primary key. Returns `NOT_OVERRIDDEN` when
+	* the batch has not touched the key at all (so the caller should consult the
+	* base) and `undefined` when the batch removed it.
+	*/
+	get(row) {
+		const key = this.#key(row);
+		if (!this.#byKey.has(key)) return NOT_OVERRIDDEN;
+		return this.#byKey.get(key);
+	}
+	/**
+	* Looks a row up by an arbitrary (not necessarily primary) unique key. Only
+	* reachable when the delta is non-empty, which is never the case for the one
+	* caller that uses a non-primary key, so a walk is fine here.
+	*/
+	getByColumns(keyCols, keyRow) {
+		for (const row of this.#byKey.values()) if (row !== void 0 && keyCols.every((c) => row[c] === keyRow[c])) return row;
+	}
+	#addToIndexes(row) {
+		for (const data of this.#indexes.values()) data.add(row);
+	}
+	#removeFromIndexes(row) {
+		for (const data of this.#indexes.values()) data.delete(row);
+	}
+	#getOrCreateIndex(sort) {
+		const indexKey = JSON.stringify(sort);
+		let data = this.#indexes.get(indexKey);
+		if (data === void 0) {
+			data = new BTreeSet(makeBoundComparator(sort));
+			for (const row of this.#byKey.values()) if (row !== void 0) data.add(row);
+			this.#indexes.set(indexKey, data);
+			this.#indexBytes += 128 + estimateBytes(indexKey) + estimateBytes(sort);
+		}
+		return data;
+	}
+	/**
+	* The live rows this batch contributes to a fetch, in the same order the
+	* backing SQL query returns its rows, so the two streams can be merged.
+	*
+	* `constraint`, `multiConstraints` and `filterPredicate` are the ones SQL
+	* already applied to the base rows; they are applied here so the delta rows
+	* are subject to the same query. `start` is the fetch's start row: the scan
+	* begins there rather than at the start of the constraint span. It is
+	* inclusive, so the caller still applies an `after` basis.
+	*/
+	*rowsFor(sort, constraint, reverse, filterPredicate, multiConstraints, start) {
+		if (this.#liveCount === 0) return;
+		const indexSort = [];
+		if (constraint) for (const key of Object.keys(constraint)) indexSort.push([key, "asc"]);
+		const sorted = !constraint || !constraintMatchesPrimaryKey(constraint, this.#primaryKey);
+		if (sorted) indexSort.push(...sort);
+		const data = this.#getOrCreateIndex(indexSort);
+		let scanStart;
+		if (start !== void 0 && sorted && (!constraint || constraintMatchesRow(constraint, start))) scanStart = start;
+		else if (constraint) {
+			scanStart = {};
+			for (const [key, dir] of indexSort) if (hasOwn(constraint, key)) scanStart[key] = constraint[key];
+			else if (reverse) scanStart[key] = dir === "asc" ? maxValue : minValue;
+			else scanStart[key] = dir === "asc" ? minValue : maxValue;
+		}
+		for (const row of generateRows(data, scanStart, reverse)) {
+			if (constraint && !constraintMatchesRow(constraint, row)) break;
+			if (multiConstraints && !matchesMultiConstraints(row, multiConstraints)) continue;
+			if (filterPredicate && !filterPredicate(row)) continue;
+			yield row;
+		}
+	}
+	/**
+	* A row with the primary key of each row the batch has touched, removed
+	* rows included. A live row is returned as is.
+	*/
+	*touchedKeys() {
+		const single = this.#singleColumnKey;
+		for (const [key, row] of this.#byKey) if (row !== void 0) yield row;
+		else if (single !== void 0) yield { [single]: key };
+		else {
+			const values = JSON.parse(key);
+			yield Object.fromEntries(this.#primaryKey.map((k, i) => [k, values[i]]));
+		}
+	}
+	/** The rows the batch has added or edited, and not since removed. */
+	*liveRows() {
+		for (const row of this.#byKey.values()) if (row !== void 0) yield row;
+	}
+	/** Drops the batch. Called when the source moves to a snapshot that has it. */
+	clear() {
+		this.#byKey.clear();
+		this.#firstKeyValues.clear();
+		this.#indexes.clear();
+		this.#liveCount = 0;
+		this.#rowBytes = 0;
+		this.#indexBytes = 0;
+	}
+};
+function estimateBytes(value) {
+	if (typeof value === "string") return 24 + value.length * 2;
+	if (value === null || typeof value !== "object") return 8;
+	let bytes = 32;
+	if (Array.isArray(value)) for (const item of value) bytes += 8 + estimateBytes(item);
+	else for (const key in value) bytes += 16 + estimateBytes(key) + estimateBytes(value[key]);
+	return bytes;
+}
+var NOT_OVERRIDDEN = Symbol("not-overridden");
+function matchesMultiConstraints(row, multiConstraints) {
+	for (const mc of multiConstraints) {
+		if (mc.length === 0) continue;
+		let any = false;
+		for (const c of mc) if (constraintMatchesRow(c, row)) {
+			any = true;
+			break;
+		}
+		if (!any) return false;
+	}
+	return true;
+}
+/**
+* Merges a batch's rows into an ordered base stream and drops the base rows
+* the batch overrides.
+*
+* Both streams must already be in `compare` order. A delta row that ties with
+* a base row is the *same* row by primary key -- every fetch ordering includes
+* the primary key -- so the base copy is suppressed and the delta's value
+* takes its place at that position.
+*/
+function* generateWithPendingDelta(baseRows, deltaRows, delta, compare) {
+	const deltaIter = deltaRows[Symbol.iterator]();
+	let pending = deltaIter.next();
+	try {
+		for (const row of baseRows) {
+			while (!pending.done && compare(pending.value, row) < 0) {
+				yield pending.value;
+				pending = deltaIter.next();
+			}
+			if (!delta.overrides(row)) yield row;
+		}
+		while (!pending.done) {
+			yield pending.value;
+			pending = deltaIter.next();
+		}
+	} finally {
+		if (!pending.done) deltaIter.return?.(void 0);
+	}
+}
+/**
+* The unordered counterpart. Nothing downstream depends on position, so the
+* surviving base rows are emitted first and the batch's rows follow.
+*/
+function* generateWithPendingDeltaUnordered(baseRows, deltaRows, delta) {
+	for (const row of baseRows) if (!delta.overrides(row)) yield row;
+	yield* deltaRows;
+}
+//#endregion
+export { NOT_OVERRIDDEN, PendingDelta, generateWithPendingDelta, generateWithPendingDeltaUnordered };
+
+//# sourceMappingURL=pending-delta.js.map

package/out/zqlite/src/pending-delta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-delta.js","names":["#primaryKey","#singleColumnKey","#firstKeyValues","#byKey","#indexes","#rowBytes","#indexBytes","#liveCount","#key","#track","#removeFromIndexes","#addToIndexes","#getOrCreateIndex"],"sources":["../../../../zqlite/src/pending-delta.ts"],"sourcesContent":["import {BTreeSet} from '../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../shared/src/has-own.ts';\nimport type {Ordering, OrderPart} 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 {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  type Constraint,\n} from '../../zql/src/ivm/constraint.ts';\nimport type {Comparator} from '../../zql/src/ivm/data.ts';\nimport {\n  generateRows,\n  makeBoundComparator,\n  maxValue,\n  minValue,\n  type RowBound,\n} from '../../zql/src/ivm/memory-source.ts';\nimport type {MultiConstraint} from '../../zql/src/ivm/operator.ts';\n\n/**\n * The batch overlay that lets a `TableSource` derive a transaction without\n * writing to the database it is reading from.\n *\n * A `TableSource` normally makes each change durable in its backing SQLite\n * connection as soon as it has been vended to every output, because change\n * *k+1* has to read a base that already includes changes *1..k* -- IVM's\n * joins fetch from the source mid-push. On the server that backing connection\n * is a `BEGIN CONCURRENT` snapshot that is never committed and always rolled\n * back, so those writes exist only to serve reads for the rest of the pass.\n *\n * A `PendingDelta` holds them in memory instead. The base stays pinned at the\n * state it had when the pass began and this object supplies *1..k*, merged\n * into every leaf scan. The durable copy comes from the replicator's own\n * commit, which the source picks up when it leapfrogs to the next snapshot.\n *\n * State is coalesced by primary key: whatever the batch did to a row, all that\n * matters downstream is the row's final value, or that it is gone. A key that\n * appears here overrides the base unconditionally -- an added row has no base\n * to override, an edited row's base copy is suppressed in favor of the new\n * value, and a removed row's base copy is suppressed with nothing to put in\n * its place.\n *\n * Live rows are additionally kept in lazily built sorted indexes, one per\n * `[...constraintKeys, ...sort]` shape a fetch has asked for, so that merging\n * the delta into a constrained scan costs `O(log D + matches)` rather than a\n * walk of the whole delta. This mirrors `MemorySource`'s index handling; see\n * its `#fetch` for the bound construction the scans here reproduce.\n */\nexport class PendingDelta {\n  readonly #primaryKey: PrimaryKey;\n  readonly #singleColumnKey: string | undefined;\n\n  /**\n   * For a composite primary key, the first key column's value of every key in\n   * `#byKey`. {@link overrides} runs for every base row of a merged fetch, and\n   * building a composite key allocates, so this rules most rows out first.\n   */\n  readonly #firstKeyValues = new Set<Value>();\n\n  /**\n   * The coalesced net state, keyed by primary key. A `undefined` value is a\n   * tombstone: the batch removed the row, so the base copy is suppressed and\n   * nothing replaces it. Membership alone is what suppresses a base row, so\n   * this map is also the \"is this key overridden\" test.\n   */\n  readonly #byKey = new Map<unknown, Row | undefined>();\n\n  /** Sorted views over the live (non-tombstone) rows, keyed by `JSON(sort)`. */\n  readonly #indexes = new Map<string, BTreeSet<Row>>();\n\n  #liveCount = 0;\n  #rowBytes = 0;\n  #indexBytes = 0;\n\n  constructor(primaryKey: PrimaryKey) {\n    this.#primaryKey = primaryKey;\n    this.#singleColumnKey = primaryKey.length === 1 ? primaryKey[0] : undefined;\n  }\n\n  /**\n   * True when the source can take its untouched fast path: no suppression\n   * test per base row, no merge, no index maintenance.\n   */\n  get isEmpty(): boolean {\n    return this.#byKey.size === 0;\n  }\n\n  /** The number of rows the batch has touched, tombstones included. */\n  get size(): number {\n    return this.#byKey.size;\n  }\n\n  /**\n   * Estimated retained bytes, including keys, tombstones, and sorted indexes.\n   * This is a budgeting heuristic, not a measurement of the JavaScript heap.\n   */\n  get estimatedBytes(): number {\n    // Budget 32 bytes per live row per index for references and B-tree nodes.\n    return (\n      this.#rowBytes +\n      this.#indexBytes +\n      this.#liveCount * this.#indexes.size * 32\n    );\n  }\n\n  #key(row: Row): unknown {\n    const single = this.#singleColumnKey;\n    if (single !== undefined) {\n      return row[single];\n    }\n    const key = this.#primaryKey.map(k => row[k]);\n    return JSON.stringify(key);\n  }\n\n  #track(row: Row, key: unknown): void {\n    if (this.#byKey.has(key)) {\n      return;\n    }\n    this.#rowBytes += 64 + estimateBytes(key as Value);\n    if (this.#singleColumnKey === undefined) {\n      this.#firstKeyValues.add(row[this.#primaryKey[0]]);\n    }\n  }\n\n  /** Records that `row` is now present with this value. */\n  set(row: Row): void {\n    const key = this.#key(row);\n    const existing = this.#byKey.get(key);\n    this.#track(row, key);\n    this.#rowBytes +=\n      estimateBytes(row) -\n      (existing === undefined ? 0 : estimateBytes(existing));\n    if (existing !== undefined) {\n      // A live row for this key is already indexed under its old value, which\n      // may sort differently. Retract it before inserting the new one.\n      this.#removeFromIndexes(existing);\n      this.#liveCount--;\n    }\n    this.#byKey.set(key, row);\n    this.#addToIndexes(row);\n    this.#liveCount++;\n  }\n\n  /** Records that `row` is now absent. */\n  delete(row: Row): void {\n    const key = this.#key(row);\n    const existing = this.#byKey.get(key);\n    this.#track(row, key);\n    if (existing !== undefined) {\n      this.#rowBytes -= estimateBytes(existing);\n      this.#removeFromIndexes(existing);\n      this.#liveCount--;\n    }\n    this.#byKey.set(key, undefined);\n  }\n\n  /**\n   * Whether the batch overrides this base row. Callers use it to suppress base\n   * rows during a merge, so it must be answered by primary key -- the value\n   * carried by the base row is exactly what the delta is replacing.\n   */\n  overrides(row: Row): boolean {\n    if (\n      this.#singleColumnKey === undefined &&\n      !this.#firstKeyValues.has(row[this.#primaryKey[0]])\n    ) {\n      return false;\n    }\n    return this.#byKey.has(this.#key(row));\n  }\n\n  /**\n   * The batch's value for a row, by primary key. Returns `NOT_OVERRIDDEN` when\n   * the batch has not touched the key at all (so the caller should consult the\n   * base) and `undefined` when the batch removed it.\n   */\n  get(row: Row): Row | undefined | typeof NOT_OVERRIDDEN {\n    const key = this.#key(row);\n    if (!this.#byKey.has(key)) {\n      return NOT_OVERRIDDEN;\n    }\n    return this.#byKey.get(key);\n  }\n\n  /**\n   * Looks a row up by an arbitrary (not necessarily primary) unique key. Only\n   * reachable when the delta is non-empty, which is never the case for the one\n   * caller that uses a non-primary key, so a walk is fine here.\n   */\n  getByColumns(keyCols: readonly string[], keyRow: Row): Row | undefined {\n    for (const row of this.#byKey.values()) {\n      if (row !== undefined && keyCols.every(c => row[c] === keyRow[c])) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  #addToIndexes(row: Row): void {\n    for (const data of this.#indexes.values()) {\n      data.add(row);\n    }\n  }\n\n  #removeFromIndexes(row: Row): void {\n    for (const data of this.#indexes.values()) {\n      data.delete(row);\n    }\n  }\n\n  #getOrCreateIndex(sort: Ordering): BTreeSet<Row> {\n    const indexKey = JSON.stringify(sort);\n    let data = this.#indexes.get(indexKey);\n    if (data === undefined) {\n      data = new BTreeSet<Row>(makeBoundComparator(sort) as Comparator);\n      for (const row of this.#byKey.values()) {\n        if (row !== undefined) {\n          data.add(row);\n        }\n      }\n      this.#indexes.set(indexKey, data);\n      this.#indexBytes += 128 + estimateBytes(indexKey) + estimateBytes(sort);\n    }\n    return data;\n  }\n\n  /**\n   * The live rows this batch contributes to a fetch, in the same order the\n   * backing SQL query returns its rows, so the two streams can be merged.\n   *\n   * `constraint`, `multiConstraints` and `filterPredicate` are the ones SQL\n   * already applied to the base rows; they are applied here so the delta rows\n   * are subject to the same query. `start` is the fetch's start row: the scan\n   * begins there rather than at the start of the constraint span. It is\n   * inclusive, so the caller still applies an `after` basis.\n   */\n  *rowsFor(\n    sort: Ordering,\n    constraint: Constraint | undefined,\n    reverse: boolean | undefined,\n    filterPredicate: ((row: Row) => boolean | undefined) | undefined,\n    multiConstraints: readonly MultiConstraint[] | undefined,\n    start?: Row | undefined,\n  ): Iterable<Row> {\n    if (this.#liveCount === 0) {\n      return;\n    }\n\n    // Lead the index with the constraint keys so a constrained fetch scans\n    // only the matching span; within that span rows come out in `sort` order,\n    // which is the order SQL returned the base rows in.\n    const indexSort: OrderPart[] = [];\n    if (constraint) {\n      for (const key of Object.keys(constraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n    // Constraining by the whole primary key admits at most one row, so the\n    // requested sort adds nothing.\n    const sorted =\n      !constraint || !constraintMatchesPrimaryKey(constraint, this.#primaryKey);\n    if (sorted) {\n      indexSort.push(...sort);\n    }\n\n    const data = this.#getOrCreateIndex(indexSort);\n\n    let scanStart: RowBound | undefined;\n    if (\n      start !== undefined &&\n      sorted &&\n      (!constraint || constraintMatchesRow(constraint, start))\n    ) {\n      // `start` carries every index column, and within the constraint span it\n      // agrees with the constraint, so it is the scan's bound as it stands.\n      // A `start` outside the span bounds nothing the scan can use.\n      scanStart = start;\n    } else if (constraint) {\n      // The first row matching the constraint is not simply the constraint\n      // values with everything else absent: a `desc` part puts absent values\n      // last. The min/max sentinels say \"the first row with these constraint\n      // values\" regardless of direction. Same construction as `MemorySource`.\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(constraint, key)) {\n          scanStart[key] = constraint[key] as Value;\n        } else if (reverse) {\n          scanStart[key] = dir === 'asc' ? maxValue : minValue;\n        } else {\n          scanStart[key] = dir === 'asc' ? minValue : maxValue;\n        }\n      }\n    }\n\n    for (const row of generateRows(data, scanStart, reverse)) {\n      if (constraint && !constraintMatchesRow(constraint, row)) {\n        // Rows are sorted by the constraint keys first, so matches are\n        // contiguous and the first miss ends the span.\n        break;\n      }\n      if (multiConstraints && !matchesMultiConstraints(row, multiConstraints)) {\n        continue;\n      }\n      if (filterPredicate && !filterPredicate(row)) {\n        continue;\n      }\n      yield row;\n    }\n  }\n\n  /**\n   * A row with the primary key of each row the batch has touched, removed\n   * rows included. A live row is returned as is.\n   */\n  *touchedKeys(): Iterable<Row> {\n    const single = this.#singleColumnKey;\n    for (const [key, row] of this.#byKey) {\n      if (row !== undefined) {\n        yield row;\n      } else if (single !== undefined) {\n        yield {[single]: key as Value};\n      } else {\n        const values = JSON.parse(key as string) as Value[];\n        yield Object.fromEntries(\n          this.#primaryKey.map((k, i) => [k, values[i]]),\n        );\n      }\n    }\n  }\n\n  /** The rows the batch has added or edited, and not since removed. */\n  *liveRows(): Iterable<Row> {\n    for (const row of this.#byKey.values()) {\n      if (row !== undefined) {\n        yield row;\n      }\n    }\n  }\n\n  /** Drops the batch. Called when the source moves to a snapshot that has it. */\n  clear(): void {\n    this.#byKey.clear();\n    this.#firstKeyValues.clear();\n    this.#indexes.clear();\n    this.#liveCount = 0;\n    this.#rowBytes = 0;\n    this.#indexBytes = 0;\n  }\n}\n\n// Allow for object/property storage and UTF-16 strings without allocating a\n// serialized copy. Shared values may be counted more than once intentionally.\nfunction estimateBytes(value: Value): number {\n  if (typeof value === 'string') {\n    return 24 + value.length * 2;\n  }\n  if (value === null || typeof value !== 'object') {\n    return 8;\n  }\n  let bytes = 32;\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      bytes += 8 + estimateBytes(item);\n    }\n  } else {\n    for (const key in value) {\n      bytes += 16 + estimateBytes(key) + estimateBytes((value as Row)[key]);\n    }\n  }\n  return bytes;\n}\n\nexport const NOT_OVERRIDDEN = Symbol('not-overridden');\n\nfunction matchesMultiConstraints(\n  row: Row,\n  multiConstraints: readonly MultiConstraint[],\n): boolean {\n  for (const mc of multiConstraints) {\n    if (mc.length === 0) {\n      continue;\n    }\n    let any = false;\n    for (const c of mc) {\n      if (constraintMatchesRow(c, row)) {\n        any = true;\n        break;\n      }\n    }\n    if (!any) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Merges a batch's rows into an ordered base stream and drops the base rows\n * the batch overrides.\n *\n * Both streams must already be in `compare` order. A delta row that ties with\n * a base row is the *same* row by primary key -- every fetch ordering includes\n * the primary key -- so the base copy is suppressed and the delta's value\n * takes its place at that position.\n */\nexport function* generateWithPendingDelta(\n  baseRows: Iterable<Row>,\n  deltaRows: Iterable<Row>,\n  delta: PendingDelta,\n  compare: Comparator,\n): IterableIterator<Row> {\n  const deltaIter = deltaRows[Symbol.iterator]();\n  let pending = deltaIter.next();\n  try {\n    for (const row of baseRows) {\n      while (!pending.done && compare(pending.value, row) < 0) {\n        yield pending.value;\n        pending = deltaIter.next();\n      }\n      if (!delta.overrides(row)) {\n        yield row;\n      }\n    }\n    while (!pending.done) {\n      yield pending.value;\n      pending = deltaIter.next();\n    }\n  } finally {\n    // Propagate early termination so the delta iterator can release the BTree\n    // cursor it is walking, the same contract `mergeSortedStreams` documents.\n    if (!pending.done) {\n      deltaIter.return?.(undefined);\n    }\n  }\n}\n\n/**\n * The unordered counterpart. Nothing downstream depends on position, so the\n * surviving base rows are emitted first and the batch's rows follow.\n */\nexport function* generateWithPendingDeltaUnordered(\n  baseRows: Iterable<Row>,\n  deltaRows: Iterable<Row>,\n  delta: PendingDelta,\n): IterableIterator<Row> {\n  for (const row of baseRows) {\n    if (!delta.overrides(row)) {\n      yield row;\n    }\n  }\n  yield* deltaRows;\n}\n"],"mappings":"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"}

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

@@ -10,7 +10,23 @@ import type { MultiConstraint, Start } from '../../zql/src/ivm/operator.ts';
 export type NoSubqueryCondition = Exclude<Condition, {
     type: 'correlatedSubquery';
 }>;
-export declare function buildSelectQuery(tableName: string, columns: Record<string, SchemaValue>, constraint: Constraint | undefined, filters: NoSubqueryCondition | undefined, order: Ordering | undefined, reverse: boolean | undefined, start: Start | undefined, multiConstraints?: readonly MultiConstraint[] | undefined, fetchFilters?: NoSubqueryCondition | undefined): SQLQuery;
+/**
+ * Builds the SELECTs for a fetch. Running them in order and concatenating
+ * their rows gives the fetch's rows, in order.
+ *
+ * There is a second SELECT only when the fetch starts at a non-NULL value of a
+ * nullable leading sort column and walks towards its NULL group. The first
+ * SELECT then leaves that group out so that SQLite can seek it (see
+ * `gatherStartConstraints`), and the second fetches the group. NULLs sort
+ * before every other value, so the group follows all of the first SELECT's
+ * rows, and a fetch that stops early never needs to run the second.
+ */
+export declare function buildSelectQueries(tableName: string, columns: Record<string, SchemaValue>, constraint: Constraint | undefined, filters: NoSubqueryCondition | undefined, order: Ordering | undefined, reverse: boolean | undefined, start: Start | undefined, multiConstraints?: readonly MultiConstraint[] | undefined, fetchFilters?: NoSubqueryCondition | undefined): [SQLQuery] | [SQLQuery, SQLQuery];
+/**
+ * {@link buildSelectQueries} for a fetch that needs only one SELECT, such as
+ * one without a start row.
+ */
+export declare function buildSelectQuery(...args: Parameters<typeof buildSelectQueries>): SQLQuery;
 export declare function constraintsToSQL(constraint: Constraint | undefined, columns: Record<string, SchemaValue>): SQLQuery[];
 /**
  * Builds a single batched IN clause from a `MultiConstraint`. All entries

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,wBAAgB,gBAAgB,CAC9B,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,YAqC/C;AAED,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,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"}

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

@@ -1,22 +1,89 @@
 import { assert } from "../../shared/src/asserts.js";
 import { sql } from "./internal/sql.js";
 //#region ../zqlite/src/query-builder.ts
-function buildSelectQuery(tableName, columns, constraint, filters, order, reverse, start, multiConstraints, fetchFilters) {
-	let query = sql`SELECT ${sql.join(Object.keys(columns).map((c) => sql.ident(c)), sql`,`)} FROM ${sql.ident(tableName)}`;
-	const constraints = constraintsToSQL(constraint, columns);
+/**
+* Builds the SELECTs for a fetch. Running them in order and concatenating
+* their rows gives the fetch's rows, in order.
+*
+* There is a second SELECT only when the fetch starts at a non-NULL value of a
+* nullable leading sort column and walks towards its NULL group. The first
+* SELECT then leaves that group out so that SQLite can seek it (see
+* `gatherStartConstraints`), and the second fetches the group. NULLs sort
+* before every other value, so the group follows all of the first SELECT's
+* rows, and a fetch that stops early never needs to run the second.
+*/
+function buildSelectQueries(tableName, columns, constraint, filters, order, reverse, start, multiConstraints, fetchFilters) {
+	const select = sql`SELECT ${sql.join(Object.keys(columns).map((c) => sql.ident(c)), sql`,`)} FROM ${sql.ident(tableName)}`;
+	const leading = constraintsToSQL(constraint, columns);
 	if (multiConstraints) {
-		for (const mc of multiConstraints) if (mc.length > 0) constraints.push(multiConstraintToSQL(mc, columns));
+		for (const mc of multiConstraints) if (mc.length > 0) leading.push(multiConstraintToSQL(mc, columns));
 	}
-	if (start) {
-		assert(order !== void 0, "start requires ordering");
-		constraints.push(gatherStartConstraints(start, reverse, order, columns));
-	}
-	if (filters) constraints.push(filtersToSQL(filters));
-	if (fetchFilters) constraints.push(filtersToSQL(fetchFilters));
-	if (constraints.length > 0) query = sql`${query} WHERE ${sql.join(constraints, sql` AND `)}`;
-	if (order && order.length > 0) return sql`${query} ${orderByToSQL(order, !!reverse)}`;
+	const trailing = [];
+	if (filters) trailing.push(filtersToSQL(filters));
+	if (fetchFilters) trailing.push(filtersToSQL(fetchFilters));
+	const orderBy = order && order.length > 0 ? orderByToSQL(order, !!reverse) : void 0;
+	const selectWhere = (constraints) => {
+		const query = constraints.length > 0 ? sql`${select} WHERE ${sql.join(constraints, sql` AND `)}` : select;
+		return orderBy ? sql`${query} ${orderBy}` : query;
+	};
+	if (!start) return [selectWhere([...leading, ...trailing])];
+	assert(order !== void 0, "start requires ordering");
+	const { constraint: startConstraint, excludesNullGroup } = gatherStartConstraints(start, reverse, order, columns);
+	const query = selectWhere([
+		...leading,
+		startConstraint,
+		...trailing
+	]);
+	const [leadingField] = order[0];
+	if (!excludesNullGroup || constraintsRejectNull(constraint, multiConstraints, leadingField) || rejectsNull(filters, leadingField) || rejectsNull(fetchFilters, leadingField)) return [query];
+	return [query, selectWhere([
+		...leading,
+		sql`${sql.ident(leadingField)} IS NULL`,
+		...trailing
+	])];
+}
+/**
+* {@link buildSelectQueries} for a fetch that needs only one SELECT, such as
+* one without a start row.
+*/
+function buildSelectQuery(...args) {
+	const [query, nullGroup] = buildSelectQueries(...args);
+	assert(nullGroup === void 0, "The fetch needs a second SELECT for its NULL group; use buildSelectQueries");
 	return query;
 }
+/**
+* Whether `condition` is never true for a row whose `field` is NULL. Only a
+* comparison of `field` itself, alone or ANDed with other conditions, is
+* recognized. Every operator yields NULL for a NULL operand except `IS`,
+* `IS NOT` and `NOT IN`, which is true for an empty list.
+*/
+function rejectsNull(condition, field) {
+	switch (condition?.type) {
+		case void 0:
+		case "or": return false;
+		case "and": return condition.conditions.some((c) => rejectsNull(c, field));
+		case "simple": {
+			const { op, left, right } = condition;
+			if (left.type !== "column" || left.name !== field) return false;
+			switch (op) {
+				case "IS": return right.type === "literal" && right.value !== null;
+				case "IS NOT": return right.type === "literal" && right.value === null;
+				case "NOT IN": return false;
+				default: return true;
+			}
+		}
+	}
+}
+/**
+* Whether the constraints of the fetch are never true for a row whose `field`
+* is NULL. {@link constraintsToSQL} compares the field with `=` and
+* {@link multiConstraintToSQL} with `IN`, neither of which is ever true for a
+* NULL operand, so the field being constrained at all is enough.
+*/
+function constraintsRejectNull(constraint, multiConstraints, field) {
+	if (constraint && field in constraint) return true;
+	return multiConstraints?.some((mc) => mc.length > 0 && field in mc[0]) === true;
+}
 function constraintsToSQL(constraint, columns) {
 	if (!constraint) return [];
 	const constraints = [];
@@ -110,16 +177,19 @@ 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}`;
 }
-function nullableAwareRangeComparison(field, value, operator, columnType) {
+function nullableAwareRangeComparison(field, value, operator, columnType, nullGroupExcluded) {
 	if (value === null) return operator === ">" ? sql`${sql.ident(field)} IS NOT NULL` : sql`FALSE`;
 	const comparison = sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${value}`;
 	if (columnType.optional !== true) return comparison;
-	return operator === ">" ? comparison : sql`(${sql.ident(field)} IS NULL OR ${comparison})`;
+	return operator === ">" || nullGroupExcluded ? comparison : sql`(${sql.ident(field)} IS NULL OR ${comparison})`;
 }
 function sargableLeadingStartBound(field, value, operator, columnType) {
-	if (value === null || columnType.optional === true && operator === "<") return;
+	if (value === null) return;
 	const inclusiveOperator = operator === ">" ? ">=" : "<=";
-	return sql`${sql.ident(field)} ${sql.__dangerous__rawValue(inclusiveOperator)} ${value}`;
+	return {
+		bound: sql`${sql.ident(field)} ${sql.__dangerous__rawValue(inclusiveOperator)} ${value}`,
+		excludesNullGroup: columnType.optional === true && operator === "<"
+	};
 }
 /**
 * The ordering could be complex such as:
@@ -136,6 +206,16 @@ function sargableLeadingStartBound(field, value, operator, columnType) {
 *
 * - after vs before flips the comparison operators.
 * - inclusive adds a final `OR` clause for the exact match.
+*
+* SQLite cannot seek an index with that disjunction, so a redundant, entailed
+* bound on the leading column is ANDed in front of it (e.g. `a >= 1 AND ...`).
+*
+* When the leading column is nullable and the walk heads towards lower values
+* (`<`), the rows the start walks over include the whole NULL group, which
+* that bound drops. `excludesNullGroup` is set then, and the group is left out
+* of the disjunction too — every row the returned constraint admits has
+* `a <= ?`, so it and `a IS NULL` partition those rows, and the caller fetches
+* the NULL group with a second SELECT.
 */
 function gatherStartConstraints(start, reverse, order, columnTypes) {
 	const constraints = [];
@@ -148,8 +228,12 @@ function gatherStartConstraints(start, reverse, order, columnTypes) {
 			const columnType = columnTypes[iField];
 			const constraintValue = toSQLiteType(from[iField] ?? null, columnType.type);
 			const operator = iDirection === "asc" ? reverse ? "<" : ">" : reverse ? ">" : "<";
-			if (i === 0) leadingBound = sargableLeadingStartBound(iField, constraintValue, operator, columnType);
-			group.push(nullableAwareRangeComparison(iField, constraintValue, operator, columnType));
+			let nullGroupExcluded = false;
+			if (i === 0) {
+				leadingBound = sargableLeadingStartBound(iField, constraintValue, operator, columnType);
+				nullGroupExcluded = leadingBound?.excludesNullGroup === true;
+			}
+			group.push(nullableAwareRangeComparison(iField, constraintValue, operator, columnType, nullGroupExcluded));
 		} else {
 			const [jField] = order[j];
 			const columnType = columnTypes[jField];
@@ -163,9 +247,16 @@ function gatherStartConstraints(start, reverse, order, columnTypes) {
 		return nullableAwareEquality(field, toSQLiteType(from[field] ?? null, columnType.type), columnType);
 	}), sql` AND `)})`);
 	const lexicographicStart = sql`(${sql.join(constraints, sql` OR `)})`;
-	return leadingBound === void 0 ? lexicographicStart : sql`(${leadingBound} AND ${lexicographicStart})`;
+	if (leadingBound === void 0) return {
+		constraint: lexicographicStart,
+		excludesNullGroup: false
+	};
+	return {
+		constraint: sql`(${leadingBound.bound} AND ${lexicographicStart})`,
+		excludesNullGroup: leadingBound.excludesNullGroup
+	};
 }
 //#endregion
-export { buildSelectQuery, toSQLiteType };
+export { buildSelectQueries, buildSelectQuery, toSQLiteType };
 
 //# sourceMappingURL=query-builder.js.map