@rocicorp/zero 1.10.0-canary.0 → 1.10.0-canary.10

package/out/zero-cache/src/services/replicator/change-log-cookies.d.ts

@@ -0,0 +1,169 @@
+/**
+ * The change log's *second* job.
+ *
+ * A change log is a buffer **and** a cookie jar. The buffer catches a
+ * reconnecting subscriber up to the head; the cookie jar holds the backfill
+ * progress state that the change-streamer hands the change-source on every
+ * `startStream`, so that the change source never has to persist backfill state
+ * upstream. See `change-log-db.ts` for the buffer.
+ *
+ * There are two cookies, mirroring the two `cdc` tables the Postgres change log
+ * has always carried (`change-streamer/schema/tables.ts`):
+ *
+ * - **table metadata**, the most current {@link TableMetadata} of a table, which
+ *   a {@link BackfillRequest} has to carry; and
+ * - **backfilling columns**, the opaque {@link BackfillID} of every column whose
+ *   backfill has not completed.
+ *
+ * Both are a *fold over the change stream*: the cookie set is only meaningful
+ * paired with the watermark it was folded up to. {@link cookieOps} is that fold,
+ * expressed transport-free so that the Postgres change log and the SQLite change
+ * log cannot drift from each other — they must agree on all eight transitions
+ * forever, and the failure mode if they disagree is a backfill that is silently
+ * never re-requested. The two interpreters are {@link ChangeLogCookieWriter}
+ * here and `Storer.#trackBackfillMetadata()` in
+ * `change-streamer/storer.ts`.
+ *
+ * The tables live in the change-log database rather than in the replica: the
+ * replicator is a subscriber *downstream* of the change-streamer's write loop,
+ * so its state version trails the log's head, and pairing its cookies with the
+ * log's resume watermark would lose every backfill that completed in between.
+ * The replica's own copies (`_zero.tableMetadata`, `_zero.column_metadata`) are
+ * the *seed* source; these are the *working* set.
+ */
+import type { Database } from '../../../../zqlite/src/db.ts';
+import type { BackfillID, Identifier, SchemaChange, TableMetadata } from '../change-source/protocol/current/data.ts';
+import { type BackfillRequest } from '../change-source/protocol/current/upstream.ts';
+export declare const CHANGE_LOG_TABLE_METADATA_TABLE = "_zero.changeLogTableMetadata";
+export declare const CHANGE_LOG_BACKFILLING_TABLE = "_zero.changeLogBackfilling";
+export declare const CREATE_CHANGE_LOG_COOKIE_SCHEMA = "\n  CREATE TABLE \"_zero.changeLogTableMetadata\" (\n    \"schema\"   TEXT NOT NULL,\n    \"table\"    TEXT NOT NULL,\n    \"metadata\" TEXT NOT NULL,\n    PRIMARY KEY (\"schema\", \"table\")\n  );\n\n  CREATE TABLE \"_zero.changeLogBackfilling\" (\n    \"schema\"   TEXT NOT NULL,\n    \"table\"    TEXT NOT NULL,\n    \"column\"   TEXT NOT NULL,\n    \"backfill\" TEXT NOT NULL,\n    PRIMARY KEY (\"schema\", \"table\", \"column\")\n  );\n";
+export declare const DROP_CHANGE_LOG_COOKIE_TABLES = "\n  DROP TABLE IF EXISTS \"_zero.changeLogTableMetadata\";\n  DROP TABLE IF EXISTS \"_zero.changeLogBackfilling\";\n";
+export type TableMetadataCookie = {
+    readonly schema: string;
+    readonly table: string;
+    readonly metadata: TableMetadata;
+};
+export type BackfillCookie = {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly backfill: BackfillID;
+};
+/**
+ * The whole cookie set, as of the log's head. Both lists are ordered by their
+ * primary key so that two stores' sets can be compared directly.
+ */
+export type CookieSet = {
+    readonly tableMetadata: readonly TableMetadataCookie[];
+    readonly backfilling: readonly BackfillCookie[];
+};
+export declare const EMPTY_COOKIE_SET: CookieSet;
+/**
+ * A transport-free description of a cookie mutation. This is the whole of what
+ * a {@link SchemaChange} means to the cookie jar; everything else about the
+ * change belongs to the buffer.
+ */
+export type CookieOp = {
+    op: 'upsert-metadata';
+    table: Identifier;
+    metadata: TableMetadata;
+} | {
+    op: 'upsert-backfill';
+    table: Identifier;
+    column: string;
+    backfill: BackfillID;
+} | {
+    op: 'rename-table';
+    old: Identifier;
+    new: Identifier;
+} | {
+    op: 'drop-table';
+    table: Identifier;
+} | {
+    op: 'rename-column';
+    table: Identifier;
+    old: string;
+    new: string;
+} | {
+    op: 'drop-column';
+    table: Identifier;
+    column: string;
+} | {
+    op: 'complete-backfill';
+    table: Identifier;
+    columns: readonly string[];
+};
+export type CookieOpTag = CookieOp['op'];
+/**
+ * The fold, and the only place either store decides what a schema change means
+ * for the cookie set. Both interpreters are mechanical translations of what this
+ * returns, in the order it returns them.
+ *
+ * Changes that carry no cookie state — index changes, and the `create-table` /
+ * `add-column` variants whose optional `metadata` and `backfill` fields are
+ * absent — produce no ops.
+ */
+export declare function cookieOps(change: SchemaChange): CookieOp[];
+/**
+ * The SQLite interpreter of {@link cookieOps}, over prepared statements on the
+ * change-log database.
+ *
+ * The statements run inside the log's transaction, in stream order, at the point
+ * the schema change is appended (see `ChangeLogStreamWriter`). That is what
+ * makes the cookie set atomic with the head — a crash cannot leave cookies ahead
+ * of or behind the rows they were folded from — and what makes an aborted
+ * transaction discard its cookies with its rows, for free.
+ *
+ * Statements are prepared against the tables as they exist now, so an instance
+ * does not survive a reconcile that drops and recreates them.
+ */
+export declare class ChangeLogCookieWriter {
+    #private;
+    constructor(db: Database);
+    /** Applies the change's cookie ops, returning the ops that were applied. */
+    apply(change: SchemaChange): CookieOp[];
+}
+/**
+ * The in-memory interpreter of {@link cookieOps}: the third one, and the only
+ * one that is not a store.
+ *
+ * A replica-derived cookie set is a snapshot at the replica's state version,
+ * which trails the change log's head, so it cannot be compared with a
+ * Postgres-derived set directly. This carries it forward over the schema changes
+ * the log holds in between, which turns "the two stores disagree, but they are
+ * also at different positions" into an exact equality — and makes a
+ * disagreement between any two of the three interpreters visible as an
+ * inequality that neither store would have noticed on its own.
+ *
+ * `changes` must be the log's schema changes over `(from, to]` in stream order.
+ * Anything else produces a set that belongs to no watermark.
+ */
+export declare function foldCookies(cookies: CookieSet, changes: Iterable<SchemaChange>): CookieSet;
+/**
+ * Returns one {@link BackfillRequest} for each table with an active backfill.
+ * Each request contains the stored table metadata, if available.
+ */
+export declare function backfillRequestsFrom(cookies: CookieSet): BackfillRequest[];
+/**
+ * Reads the whole cookie set, ordered by primary key. This is what a
+ * change-streamer would hand `startStream`, and what the Postgres-derived and
+ * replica-derived sets are compared against.
+ */
+export declare function readCookies(db: Database): CookieSet;
+/**
+ * Replaces the cookie set wholesale.
+ *
+ * The cookies are unversioned point-in-time state, so a reconciliation that
+ * moves the head invalidates them: truncating the stream above `W` does not roll
+ * the cookie set back to `W`, and the truncated transactions can contain
+ * `create-table`, `add-column`, and `backfill-completed`. The caller must run
+ * this in the same transaction as the reconciliation that invalidated them.
+ */
+export declare function replaceCookies(db: Database, cookies: CookieSet): void;
+/** Retained cookie rows, by table. Both are normally zero. */
+export type CookieRowCounts = {
+    readonly tableMetadata: number;
+    readonly backfilling: number;
+};
+export declare function readCookieRowCounts(db: Database): CookieRowCounts;
+//# sourceMappingURL=change-log-cookies.d.ts.map

package/out/zero-cache/src/services/replicator/change-log-cookies.d.ts.map

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

package/out/zero-cache/src/services/replicator/change-log-cookies.js

@@ -0,0 +1,434 @@
+import { unreachable } from "../../../../shared/src/asserts.js";
+import { parse, valita_exports } from "../../../../shared/src/valita.js";
+import { BigIntJSON } from "../../../../shared/src/bigint-json.js";
+import { backfillRequestSchema } from "../change-source/protocol/current/upstream.js";
+//#region ../zero-cache/src/services/replicator/change-log-cookies.ts
+/**
+* The change log's *second* job.
+*
+* A change log is a buffer **and** a cookie jar. The buffer catches a
+* reconnecting subscriber up to the head; the cookie jar holds the backfill
+* progress state that the change-streamer hands the change-source on every
+* `startStream`, so that the change source never has to persist backfill state
+* upstream. See `change-log-db.ts` for the buffer.
+*
+* There are two cookies, mirroring the two `cdc` tables the Postgres change log
+* has always carried (`change-streamer/schema/tables.ts`):
+*
+* - **table metadata**, the most current {@link TableMetadata} of a table, which
+*   a {@link BackfillRequest} has to carry; and
+* - **backfilling columns**, the opaque {@link BackfillID} of every column whose
+*   backfill has not completed.
+*
+* Both are a *fold over the change stream*: the cookie set is only meaningful
+* paired with the watermark it was folded up to. {@link cookieOps} is that fold,
+* expressed transport-free so that the Postgres change log and the SQLite change
+* log cannot drift from each other — they must agree on all eight transitions
+* forever, and the failure mode if they disagree is a backfill that is silently
+* never re-requested. The two interpreters are {@link ChangeLogCookieWriter}
+* here and `Storer.#trackBackfillMetadata()` in
+* `change-streamer/storer.ts`.
+*
+* The tables live in the change-log database rather than in the replica: the
+* replicator is a subscriber *downstream* of the change-streamer's write loop,
+* so its state version trails the log's head, and pairing its cookies with the
+* log's resume watermark would lose every backfill that completed in between.
+* The replica's own copies (`_zero.tableMetadata`, `_zero.column_metadata`) are
+* the *seed* source; these are the *working* set.
+*/
+var CHANGE_LOG_TABLE_METADATA_TABLE = "_zero.changeLogTableMetadata";
+var CHANGE_LOG_BACKFILLING_TABLE = "_zero.changeLogBackfilling";
+var CREATE_CHANGE_LOG_COOKIE_SCHEMA = `
+  CREATE TABLE "${CHANGE_LOG_TABLE_METADATA_TABLE}" (
+    "schema"   TEXT NOT NULL,
+    "table"    TEXT NOT NULL,
+    "metadata" TEXT NOT NULL,
+    PRIMARY KEY ("schema", "table")
+  );
+
+  CREATE TABLE "${CHANGE_LOG_BACKFILLING_TABLE}" (
+    "schema"   TEXT NOT NULL,
+    "table"    TEXT NOT NULL,
+    "column"   TEXT NOT NULL,
+    "backfill" TEXT NOT NULL,
+    PRIMARY KEY ("schema", "table", "column")
+  );
+`;
+var DROP_CHANGE_LOG_COOKIE_TABLES = `
+  DROP TABLE IF EXISTS "${CHANGE_LOG_TABLE_METADATA_TABLE}";
+  DROP TABLE IF EXISTS "${CHANGE_LOG_BACKFILLING_TABLE}";
+`;
+/**
+* The fold, and the only place either store decides what a schema change means
+* for the cookie set. Both interpreters are mechanical translations of what this
+* returns, in the order it returns them.
+*
+* Changes that carry no cookie state — index changes, and the `create-table` /
+* `add-column` variants whose optional `metadata` and `backfill` fields are
+* absent — produce no ops.
+*/
+function cookieOps(change) {
+	switch (change.tag) {
+		case "update-table-metadata": return [{
+			op: "upsert-metadata",
+			table: change.table,
+			metadata: change.new
+		}];
+		case "create-table": {
+			const { spec, metadata, backfill } = change;
+			const table = {
+				schema: spec.schema,
+				name: spec.name
+			};
+			const ops = [];
+			if (metadata) ops.push({
+				op: "upsert-metadata",
+				table,
+				metadata
+			});
+			if (backfill) for (const [column, id] of Object.entries(backfill)) ops.push({
+				op: "upsert-backfill",
+				table,
+				column,
+				backfill: id
+			});
+			return ops;
+		}
+		case "rename-table": return [{
+			op: "rename-table",
+			old: change.old,
+			new: change.new
+		}];
+		case "drop-table": return [{
+			op: "drop-table",
+			table: change.id
+		}];
+		case "add-column": {
+			const { table, tableMetadata, column, backfill } = change;
+			const ops = [];
+			if (tableMetadata) ops.push({
+				op: "upsert-metadata",
+				table,
+				metadata: tableMetadata
+			});
+			if (backfill) ops.push({
+				op: "upsert-backfill",
+				table,
+				column: column.name,
+				backfill
+			});
+			return ops;
+		}
+		case "update-column": {
+			const { table, old, new: updated } = change;
+			return old.name === updated.name ? [] : [{
+				op: "rename-column",
+				table,
+				old: old.name,
+				new: updated.name
+			}];
+		}
+		case "drop-column": return [{
+			op: "drop-column",
+			table: change.table,
+			column: change.column
+		}];
+		case "backfill-completed": {
+			const { relation, columns } = change;
+			const cleared = [...relation.rowKey.columns, ...columns];
+			return cleared.length === 0 ? [] : [{
+				op: "complete-backfill",
+				table: {
+					schema: relation.schema,
+					name: relation.name
+				},
+				columns: cleared
+			}];
+		}
+		case "create-index":
+		case "drop-index": return [];
+		default: unreachable(change);
+	}
+}
+/**
+* The SQLite interpreter of {@link cookieOps}, over prepared statements on the
+* change-log database.
+*
+* The statements run inside the log's transaction, in stream order, at the point
+* the schema change is appended (see `ChangeLogStreamWriter`). That is what
+* makes the cookie set atomic with the head — a crash cannot leave cookies ahead
+* of or behind the rows they were folded from — and what makes an aborted
+* transaction discard its cookies with its rows, for free.
+*
+* Statements are prepared against the tables as they exist now, so an instance
+* does not survive a reconcile that drops and recreates them.
+*/
+var ChangeLogCookieWriter = class {
+	#upsertMetadata;
+	#upsertBackfill;
+	#renameMetadataTable;
+	#renameBackfillTable;
+	#deleteMetadataTable;
+	#deleteBackfillTable;
+	#renameBackfillColumn;
+	#deleteBackfillColumn;
+	constructor(db) {
+		this.#upsertMetadata = db.prepare(`
+      INSERT INTO "${CHANGE_LOG_TABLE_METADATA_TABLE}"
+        ("schema", "table", "metadata") VALUES (?, ?, ?)
+        ON CONFLICT ("schema", "table")
+        DO UPDATE SET "metadata" = excluded."metadata"
+    `);
+		this.#upsertBackfill = db.prepare(`
+      INSERT INTO "${CHANGE_LOG_BACKFILLING_TABLE}"
+        ("schema", "table", "column", "backfill") VALUES (?, ?, ?, ?)
+        ON CONFLICT ("schema", "table", "column")
+        DO UPDATE SET "backfill" = excluded."backfill"
+    `);
+		this.#renameMetadataTable = db.prepare(`
+      UPDATE "${CHANGE_LOG_TABLE_METADATA_TABLE}"
+        SET "schema" = ?, "table" = ? WHERE "schema" = ? AND "table" = ?
+    `);
+		this.#renameBackfillTable = db.prepare(`
+      UPDATE "${CHANGE_LOG_BACKFILLING_TABLE}"
+        SET "schema" = ?, "table" = ? WHERE "schema" = ? AND "table" = ?
+    `);
+		this.#deleteMetadataTable = db.prepare(`
+      DELETE FROM "${CHANGE_LOG_TABLE_METADATA_TABLE}"
+        WHERE "schema" = ? AND "table" = ?
+    `);
+		this.#deleteBackfillTable = db.prepare(`
+      DELETE FROM "${CHANGE_LOG_BACKFILLING_TABLE}"
+        WHERE "schema" = ? AND "table" = ?
+    `);
+		this.#renameBackfillColumn = db.prepare(`
+      UPDATE "${CHANGE_LOG_BACKFILLING_TABLE}" SET "column" = ?
+        WHERE "schema" = ? AND "table" = ? AND "column" = ?
+    `);
+		this.#deleteBackfillColumn = db.prepare(`
+      DELETE FROM "${CHANGE_LOG_BACKFILLING_TABLE}"
+        WHERE "schema" = ? AND "table" = ? AND "column" = ?
+    `);
+	}
+	/** Applies the change's cookie ops, returning the ops that were applied. */
+	apply(change) {
+		const ops = cookieOps(change);
+		for (const op of ops) this.#run(op);
+		return ops;
+	}
+	#run(op) {
+		switch (op.op) {
+			case "upsert-metadata":
+				this.#upsertMetadata.run(op.table.schema, op.table.name, BigIntJSON.stringify(op.metadata));
+				break;
+			case "upsert-backfill":
+				this.#upsertBackfill.run(op.table.schema, op.table.name, op.column, BigIntJSON.stringify(op.backfill));
+				break;
+			case "rename-table":
+				this.#renameMetadataTable.run(op.new.schema, op.new.name, op.old.schema, op.old.name);
+				this.#renameBackfillTable.run(op.new.schema, op.new.name, op.old.schema, op.old.name);
+				break;
+			case "drop-table":
+				this.#deleteMetadataTable.run(op.table.schema, op.table.name);
+				this.#deleteBackfillTable.run(op.table.schema, op.table.name);
+				break;
+			case "rename-column":
+				this.#renameBackfillColumn.run(op.new, op.table.schema, op.table.name, op.old);
+				break;
+			case "drop-column":
+				this.#deleteBackfillColumn.run(op.table.schema, op.table.name, op.column);
+				break;
+			case "complete-backfill":
+				for (const column of op.columns) this.#deleteBackfillColumn.run(op.table.schema, op.table.name, column);
+				break;
+			default: unreachable(op);
+		}
+	}
+};
+var tableKey = (schema, table) => JSON.stringify([schema, table]);
+var columnKey = (schema, table, column) => JSON.stringify([
+	schema,
+	table,
+	column
+]);
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+* The in-memory interpreter of {@link cookieOps}: the third one, and the only
+* one that is not a store.
+*
+* A replica-derived cookie set is a snapshot at the replica's state version,
+* which trails the change log's head, so it cannot be compared with a
+* Postgres-derived set directly. This carries it forward over the schema changes
+* the log holds in between, which turns "the two stores disagree, but they are
+* also at different positions" into an exact equality — and makes a
+* disagreement between any two of the three interpreters visible as an
+* inequality that neither store would have noticed on its own.
+*
+* `changes` must be the log's schema changes over `(from, to]` in stream order.
+* Anything else produces a set that belongs to no watermark.
+*/
+function foldCookies(cookies, changes) {
+	const metadata = new Map(cookies.tableMetadata.map((c) => [tableKey(c.schema, c.table), c]));
+	const backfilling = new Map(cookies.backfilling.map((c) => [columnKey(c.schema, c.table, c.column), c]));
+	const dropColumn = ({ schema, name }, column) => backfilling.delete(columnKey(schema, name, column));
+	for (const change of changes) for (const op of cookieOps(change)) switch (op.op) {
+		case "upsert-metadata":
+			metadata.set(tableKey(op.table.schema, op.table.name), {
+				schema: op.table.schema,
+				table: op.table.name,
+				metadata: op.metadata
+			});
+			break;
+		case "upsert-backfill":
+			backfilling.set(columnKey(op.table.schema, op.table.name, op.column), {
+				schema: op.table.schema,
+				table: op.table.name,
+				column: op.column,
+				backfill: op.backfill
+			});
+			break;
+		case "rename-table": {
+			const { old, new: renamed } = op;
+			const moved = metadata.get(tableKey(old.schema, old.name));
+			if (moved) {
+				metadata.delete(tableKey(old.schema, old.name));
+				metadata.set(tableKey(renamed.schema, renamed.name), {
+					...moved,
+					schema: renamed.schema,
+					table: renamed.name
+				});
+			}
+			for (const [key, cookie] of [...backfilling]) if (cookie.schema === old.schema && cookie.table === old.name) {
+				backfilling.delete(key);
+				backfilling.set(columnKey(renamed.schema, renamed.name, cookie.column), {
+					...cookie,
+					schema: renamed.schema,
+					table: renamed.name
+				});
+			}
+			break;
+		}
+		case "drop-table": {
+			const { schema, name } = op.table;
+			metadata.delete(tableKey(schema, name));
+			for (const [key, cookie] of [...backfilling]) if (cookie.schema === schema && cookie.table === name) backfilling.delete(key);
+			break;
+		}
+		case "rename-column": {
+			const { schema, name } = op.table;
+			const moved = backfilling.get(columnKey(schema, name, op.old));
+			if (moved) {
+				backfilling.delete(columnKey(schema, name, op.old));
+				backfilling.set(columnKey(schema, name, op.new), {
+					...moved,
+					column: op.new
+				});
+			}
+			break;
+		}
+		case "drop-column":
+			dropColumn(op.table, op.column);
+			break;
+		case "complete-backfill":
+			for (const column of op.columns) dropColumn(op.table, column);
+			break;
+		default: unreachable(op);
+	}
+	return {
+		tableMetadata: [...metadata.values()].toSorted((a, b) => cmp(a.schema, b.schema) || cmp(a.table, b.table)),
+		backfilling: [...backfilling.values()].toSorted((a, b) => cmp(a.schema, b.schema) || cmp(a.table, b.table) || cmp(a.column, b.column))
+	};
+}
+var backfillRequestsSchema = valita_exports.array(backfillRequestSchema);
+/**
+* Returns one {@link BackfillRequest} for each table with an active backfill.
+* Each request contains the stored table metadata, if available.
+*/
+function backfillRequestsFrom(cookies) {
+	const metadata = new Map(cookies.tableMetadata.map((c) => [tableKey(c.schema, c.table), c.metadata]));
+	const requests = [];
+	let curr;
+	for (const { schema, table, column, backfill } of cookies.backfilling) {
+		if (curr?.table.schema !== schema || curr.table.name !== table) {
+			curr = {
+				table: {
+					schema,
+					name: table,
+					metadata: metadata.get(tableKey(schema, table)) ?? null
+				},
+				columns: {}
+			};
+			requests.push(curr);
+		}
+		curr.columns[column] = backfill;
+	}
+	return parse(requests, backfillRequestsSchema);
+}
+/**
+* Reads the whole cookie set, ordered by primary key. This is what a
+* change-streamer would hand `startStream`, and what the Postgres-derived and
+* replica-derived sets are compared against.
+*/
+function readCookies(db) {
+	return {
+		tableMetadata: db.prepare(`
+      SELECT "schema", "table", "metadata"
+        FROM "${CHANGE_LOG_TABLE_METADATA_TABLE}"
+        ORDER BY "schema", "table"
+    `).all().map(({ schema, table, metadata }) => ({
+			schema,
+			table,
+			metadata: BigIntJSON.parse(metadata)
+		})),
+		backfilling: db.prepare(`
+      SELECT "schema", "table", "column", "backfill"
+        FROM "${CHANGE_LOG_BACKFILLING_TABLE}"
+        ORDER BY "schema", "table", "column"
+    `).all().map(({ schema, table, column, backfill }) => ({
+			schema,
+			table,
+			column,
+			backfill: BigIntJSON.parse(backfill)
+		}))
+	};
+}
+/**
+* Replaces the cookie set wholesale.
+*
+* The cookies are unversioned point-in-time state, so a reconciliation that
+* moves the head invalidates them: truncating the stream above `W` does not roll
+* the cookie set back to `W`, and the truncated transactions can contain
+* `create-table`, `add-column`, and `backfill-completed`. The caller must run
+* this in the same transaction as the reconciliation that invalidated them.
+*/
+function replaceCookies(db, cookies) {
+	db.prepare(`DELETE FROM "${CHANGE_LOG_TABLE_METADATA_TABLE}"`).run();
+	db.prepare(`DELETE FROM "${CHANGE_LOG_BACKFILLING_TABLE}"`).run();
+	if (cookies.tableMetadata.length > 0) {
+		const insert = db.prepare(`
+      INSERT INTO "${CHANGE_LOG_TABLE_METADATA_TABLE}"
+        ("schema", "table", "metadata") VALUES (?, ?, ?)
+    `);
+		for (const { schema, table, metadata } of cookies.tableMetadata) insert.run(schema, table, BigIntJSON.stringify(metadata));
+	}
+	if (cookies.backfilling.length > 0) {
+		const insert = db.prepare(`
+      INSERT INTO "${CHANGE_LOG_BACKFILLING_TABLE}"
+        ("schema", "table", "column", "backfill") VALUES (?, ?, ?, ?)
+    `);
+		for (const { schema, table, column, backfill } of cookies.backfilling) insert.run(schema, table, column, BigIntJSON.stringify(backfill));
+	}
+}
+function readCookieRowCounts(db) {
+	return db.prepare(`
+      SELECT
+        (SELECT count(*) FROM "${CHANGE_LOG_TABLE_METADATA_TABLE}")
+          AS "tableMetadata",
+        (SELECT count(*) FROM "${CHANGE_LOG_BACKFILLING_TABLE}")
+          AS "backfilling"
+    `).get();
+}
+//#endregion
+export { CHANGE_LOG_BACKFILLING_TABLE, CHANGE_LOG_TABLE_METADATA_TABLE, CREATE_CHANGE_LOG_COOKIE_SCHEMA, ChangeLogCookieWriter, DROP_CHANGE_LOG_COOKIE_TABLES, backfillRequestsFrom, cookieOps, foldCookies, readCookieRowCounts, readCookies, replaceCookies };
+
+//# sourceMappingURL=change-log-cookies.js.map