@rocicorp/zero 1.11.0-canary.4 → 1.11.0-canary.40

package/out/zero-cache/src/services/view-syncer/snapshotter.d.ts

@@ -6,6 +6,7 @@ import type { LiteAndZqlSpec, LiteTableSpecWithKeysAndVersion } from '../../db/s
 import { StatementRunner } from '../../db/statements.ts';
 import { type RowKey, type RowValue } from '../../types/row-key.ts';
 import type { AppID } from '../../types/shards.ts';
+import type { SnapshotRowCache } from './snapshot-row-cache.ts';
 /**
  * A `Snapshotter` manages the progression of database snapshots for a
  * ViewSyncer.
@@ -67,7 +68,13 @@ import type { AppID } from '../../types/shards.ts';
  */
 export declare class Snapshotter {
     #private;
-    constructor(lc: LogContext, dbFile: string, { appID }: AppID, pageCacheSizeKib?: number);
+    /**
+     * @param rowCache An optional worker-wide {@link SnapshotRowCache} through
+     *        which the row reads performed when iterating over a
+     *        {@link SnapshotDiff} are shared with the other Snapshotters
+     *        (i.e. client groups) on the worker.
+     */
+    constructor(lc: LogContext, dbFile: string, { appID }: AppID, pageCacheSizeKib?: number, rowCache?: SnapshotRowCache);
     /**
      * Initializes the snapshot to the current head of the database. This must be
      * only be called once. The state of whether a Snapshotter has been initialized
@@ -113,12 +120,60 @@ export declare class Snapshotter {
      * change-applying iterations, the caller must (1) create a save point
      * on `prev` before each iteration, and (2) rollback to the save point after
      * the iteration.
+     *
+     * @param prevWrites How the caller writes to `prev` during the iteration,
+     *        which determines which `prev` reads can be shared through the
+     *        {@link SnapshotRowCache}. See {@link PrevWrites}.
+     */
+    advance(syncableTables: Map<string, LiteAndZqlSpec>, allTableNames: Set<string>, observedTables?: TableFilter | undefined, prevWrites?: PrevWrites): SnapshotDiff;
+    /**
+     * The diff between the two snapshots of the last
+     * {@link advanceWithoutDiff()}, as {@link advance()} returns it.
+     *
+     * @param counts The counts of the change log entries between the two
+     *        snapshots, if the caller has counted them already (see
+     *        `Snapshot.countChangesSince()`). The diff then does not count
+     *        them again.
+     * @param readTables If set, only the change log entries of these tables
+     *        (and of the permissions table) are read, along with the
+     *        table-wide ops of every table, where `observedTables` reads the
+     *        entries of every table and skips those it does not have. For a
+     *        caller that does not need the changes of the other tables, this
+     *        saves reading and parsing their entries. This requires `counts`.
+     *        If they show that there is no entry of these tables and no
+     *        table-wide op, the change log is not read at all, and the
+     *        diff's `changes` is 0.
      */
-    advance(syncableTables: Map<string, LiteAndZqlSpec>, allTableNames: Set<string>): SnapshotDiff;
+    diff(syncableTables: Map<string, LiteAndZqlSpec>, allTableNames: Set<string>, observedTables?: TableFilter | undefined, prevWrites?: PrevWrites, counts?: ChangeLogCounts | undefined, readTables?: Iterable<string> | undefined): SnapshotDiff;
     advanceWithoutDiff(): {
         prev: Snapshot;
         curr: Snapshot;
     };
+    /**
+     * The reset of the pipelines that iterating over the changes from the
+     * previous snapshot to the current one ends in, if it does: the first of
+     * a schema change, a truncation, and a change of the permissions. It is
+     * found without iterating, so that a caller that would reset the pipelines
+     * anyway does not first process the changes that come before it.
+     *
+     * If there is none, iterating over a {@link diff()} of the two snapshots
+     * does not throw a {@link ResetPipelinesSignal}, and can be stopped at any
+     * point without missing one.
+     *
+     * @param counts The changes from the previous snapshot to the current
+     *        one, from which it is known whether there is anything to look
+     *        for.
+     */
+    pendingReset(syncableTables: Map<string, LiteAndZqlSpec>, counts: ChangeLogCounts): ResetPipelinesSignal | undefined;
+    /**
+     * Releases the previous snapshot, i.e. the `prev` of the last
+     * {@link advance()} or {@link advanceWithoutDiff()}. It is only read
+     * while the diff that it is the start of is iterated over, but its read
+     * transaction otherwise stays open until the next advance, which keeps
+     * the replica from checkpointing its write-ahead log past it. A diff that
+     * starts at it can no longer be iterated over.
+     */
+    releasePrevious(): void;
     /**
      * Call this to close the database connections when the Snapshotter is
      * no longer needed.
@@ -137,6 +192,53 @@ export type Change = {
     readonly nextValue: Readonly<Row> | null;
     readonly rowKey: RowKey;
 };
+/** See `Snapshot.countChangesSince()`. */
+/** Where an entry is in the order that the change log is read in. */
+type ChangeLogPosition = {
+    readonly stateVersion: string;
+    readonly pos: number;
+};
+export type ChangeLogCounts = {
+    /** The number of entries. */
+    readonly total: number;
+    /** The number of them that are table-wide ops (a RESET or TRUNCATE). */
+    readonly tableWideOps: number;
+    /**
+     * The number of entries of each table. If {@link sampled}, these are
+     * estimates, and a table with few entries may be missing.
+     */
+    readonly byTable: ReadonlyMap<string, number>;
+    /** Whether {@link byTable} was estimated from a sample of the entries. */
+    readonly sampled: boolean;
+};
+/**
+ * The most change log entries that are read to count a batch's changes by
+ * table. Reading an entry costs microseconds, and nothing else runs on the
+ * sync worker in the meantime, so the cost of counting must not grow with
+ * the number of changes that a client group has to catch up on.
+ */
+export declare const CHANGE_LOG_SAMPLE_SIZE = 1000;
+export interface TableFilter {
+    has(table: string): boolean;
+}
+/**
+ * How the caller of {@link Snapshotter.advance()} writes the changes of a
+ * {@link SnapshotDiff} to its `prev` snapshot while iterating over it.
+ *
+ * A `prev` read for a table with a single unique key (its primary key)
+ * cannot observe earlier changes of the iteration, since a row key appears
+ * once in the diff. A read for a table with other unique keys can, because
+ * the rows it returns may have been displaced or edited by earlier changes.
+ *
+ * * `uniform`: every caller applies every change, so such a read depends on
+ *   the `<prev, curr>` versions of the diff, and is shared on that basis.
+ * * `divergent`: callers apply different subsets of the changes (e.g. the
+ *   pipeline driver skips changes that no pipeline can observe), so such a
+ *   read depends on the caller and is not shared.
+ * * `none`: the caller does not write to `prev` (e.g. IVM derivation is
+ *   held in memory), so every read depends solely on `prev.version`.
+ */
+export type PrevWrites = 'uniform' | 'divergent' | 'none';
 /**
  * Represents the difference between two database Snapshots.
  * Iterating over the object will produce a sequence of {@link Change}s
@@ -144,6 +246,12 @@ export type Change = {
  *
  * See {@link Snapshotter.advance()} for semantics and usage.
  */
+export type DiffTimingStats = {
+    changeLogReadMs: number;
+    rowReadMs: number;
+    parseMs: number;
+    totalDiffMs: number;
+};
 export interface SnapshotDiff extends Iterable<Change> {
     readonly prev: {
         readonly db: StatementRunner;
@@ -154,17 +262,38 @@ export interface SnapshotDiff extends Iterable<Change> {
         readonly version: string;
     };
     /**
-     * The number of ChangeLog entries between the snapshots. Note that this
-     * may not necessarily equal the number of `Change` objects that the iteration
-     * will produce, as `TRUNCATE` entries are counted as a single log entry which
-     * may be expanded into many changes (i.e. row deletes).
-     *
-     * TODO: Determine if it is worth changing the definition to count the
-     *       truncated rows. This would make diff computation more expensive
-     *       (requiring the count to be aggregated by operation type), which
-     *       may not be worth it for a presumable rare operation.
+     * The raw number of ChangeLog entries between the snapshots, before filtering
+     * out unobserved/non-syncable tables or no-op changes. Progress against this
+     * total must use {@link changesScanned}, rather than the number of yielded
+     * changes. Table-wide operations abort iteration and reset the pipelines.
      */
     readonly changes: number;
+    /** The number of raw ChangeLog entries read so far, including skipped entries. */
+    readonly changesScanned: number;
+    /**
+     * The raw ChangeLog entries read so far, by table. Like
+     * {@link changesScanned}, this includes the entries that are not yielded,
+     * so it counts the same entries as {@link ChangeLogCounts.byTable} does.
+     */
+    readonly changesScannedByTable: ReadonlyMap<string, number>;
+    /** The scanned entries omitted because their table is unobserved/non-syncable or the change is a no-op. */
+    readonly changesSkipped: number;
+    /**
+     * The scanned entries whose rows were looked up in the snapshots. Unlike
+     * the entries that are yielded, this includes the no-op changes, which are
+     * only known to be that from their rows.
+     */
+    readonly changesLookedUp: number;
+    /** Timing metrics recorded during diff iteration. */
+    readonly stats?: DiffTimingStats | undefined;
+    /**
+     * Overrides the `prevWrites` passed to {@link Snapshotter.advance()}, for a
+     * caller that decides how to write to `prev` once it knows the number of
+     * {@link changes}. Must be called before the diff is iterated, except to
+     * switch to `divergent`, which can be done between any two changes: it
+     * shares only the reads that no write to `prev` can affect.
+     */
+    setPrevWrites(prevWrites: PrevWrites): void;
 }
 /**
  * Thrown during an iteration of a {@link SnapshotDiff} when a schema
@@ -175,21 +304,105 @@ export type ResetPipelinesReason = 'advancement-timeout' | 'scalar-subquery' | '
 export declare class ResetPipelinesSignal extends Error {
     readonly name = "ResetPipelinesSignal";
     readonly reason: ResetPipelinesReason;
-    constructor(msg: string, reason: ResetPipelinesReason);
+    readonly breakdown?: string | undefined;
+    constructor(msg: string, reason: ResetPipelinesReason, breakdown?: string);
 }
 declare class Snapshot {
     #private;
     static create(lc: LogContext, dbFile: string, appID: string, pageCacheSizeKib: number | undefined): Snapshot;
     readonly db: StatementRunner;
     readonly version: string;
-    constructor(db: StatementRunner, appID: string);
+    /**
+     * @param begun Whether `db` is already in a `BEGIN CONCURRENT` transaction
+     *        that has not read anything.
+     */
+    constructor(db: StatementRunner, appID: string, begun?: boolean);
     numChangesSince(prevVersion: string): any;
-    changesSince(prevVersion: string): {
+    /**
+     * Counts the change log entries after `prevVersion`. The change log keeps
+     * the latest entry of a row, so these are counts of the rows that changed,
+     * which is what a diff from `prevVersion` to this snapshot reads.
+     *
+     * The total, and the number of table-wide ops (a RESET or TRUNCATE), are
+     * exact, and are counted from the index alone. The counts by table are
+     * exact if there are at most `sampleSize` entries. Otherwise they are
+     * estimated from the newest `sampleSize` entries, so that at most that
+     * many entries are read however many there are.
+     */
+    countChangesSince(prevVersion: string, sampleSize?: number): ChangeLogCounts;
+    /**
+     * Whether an entry of `table` was logged after `prevVersion`. This reads
+     * the table's entries in the change log, however old, so it is for tables
+     * with few rows.
+     */
+    tableChangedSince(table: string, prevVersion: string): boolean;
+    /**
+     * Whether a table-wide RESET op (i.e. a schema change) was logged after
+     * `prevVersion`. Table specs computed at or before `prevVersion` are
+     * stale with respect to this snapshot if so.
+     */
+    schemaChangedSince(prevVersion: string): boolean;
+    /**
+     * Whether any table-wide op (i.e. a RESET or TRUNCATE) was logged after
+     * `prevVersion`. Iterating over a diff ending at this snapshot will
+     * abort with a {@link ResetPipelinesSignal} if so.
+     */
+    hasTableWideOpSince(prevVersion: string): boolean;
+    /**
+     * The first table-wide op (a schema change or a truncation) logged after
+     * `prevVersion`, in the order that {@link changesSince} reads the entries.
+     */
+    firstTableWideOpSince(prevVersion: string): ChangeLogPosition & {
+        table: string;
+        op: string;
+    };
+    /**
+     * The entries of `table` logged after `prevVersion`, in the order that
+     * {@link changesSince} reads them. For a table with few rows.
+     */
+    entriesSince(table: string, prevVersion: string): (ChangeLogPosition & {
+        rowKey: string | null;
+        op: string;
+    })[];
+    /**
+     * @param tables If set, only the entries of these tables, and the
+     *        table-wide ops of every table, are read.
+     */
+    changesSince(prevVersion: string, tables?: string | undefined): {
         changes: IterableIterator<unknown>;
         cleanup: () => void;
     };
-    getRow(table: LiteTableSpecWithKeysAndVersion, rowKey: JSONValue): any;
-    getRows(table: LiteTableSpecWithKeysAndVersion, keys: PrimaryKey[], row: RowValue): any[];
+    /**
+     * Reads the row with the given `rowKey`, or `undefined` if it does not
+     * exist.
+     *
+     * @param cache An optional {@link SnapshotRowCache} through which to
+     *        perform the read, along with the `tag` that identifies the
+     *        version(s) of the replica that the result depends on.
+     */
+    getRow(table: LiteTableSpecWithKeysAndVersion, rowKey: JSONValue, cache?: SnapshotRowCache, tag?: string): any;
+    /**
+     * Reads the rows that conflict with `row` on any of the given unique
+     * `keys` (which includes the row with the same primary key, if any).
+     *
+     * @param cache An optional {@link SnapshotRowCache} through which to
+     *        perform the read, along with the `tag` that identifies the
+     *        version(s) of the replica that the result depends on.
+     */
+    getRows(table: LiteTableSpecWithKeysAndVersion, keys: PrimaryKey[], row: RowValue, cache?: SnapshotRowCache, tag?: string): any[];
+    /**
+     * Whether the snapshot has been released, or its connection reset to a
+     * newer snapshot (i.e. via {@link release()} or {@link resetToHead()}),
+     * after which reads no longer reflect {@link version}.
+     */
+    get reset(): boolean;
+    /**
+     * Ends the snapshot's read transaction, after which reads no longer
+     * reflect {@link version}. An open read transaction keeps SQLite from
+     * checkpointing the write-ahead log past the snapshot, so a snapshot that
+     * is no longer read should not be left open.
+     */
+    release(): void;
     resetToHead(): Snapshot;
 }
 export declare class InvalidDiffError extends Error {

package/out/zero-cache/src/services/view-syncer/snapshotter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshotter.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/snapshotter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"snapshotter.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/snapshotter.ts"],"names":[],"mappings":"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"}