@rocicorp/zero 1.11.0-canary.13 → 1.11.0-canary.14

package/out/replicache/src/kv/idb-store-with-mem-fallback.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"idb-store-with-mem-fallback.js","names":["#lc","#name","#store","#withBrainTransplant"],"sources":["../../../../../replicache/src/kv/idb-store-with-mem-fallback.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {IDBOpenError, IDBStore} from './idb-store.ts';\nimport {MemStore, dropMemStore} from './mem-store.ts';\nimport type {Read, Store, Write} from './store.ts';\n\n/**\n * This store uses an {@link IDBStore} by default. If `indexedDB.open` rejects\n * (WebKit's \"Unable to open database file on disk\" and \"Error creating Records\n * table (13) - database or disk is full\", or Firefox private browsing), the\n * {@link IDBStore} rejects `read()` and `write()` with an {@link IDBOpenError}\n * and we switch out the implementation to use a {@link MemStore} instead. Any\n * other error, such as a transaction error on a database that did open, is\n * rethrown, so a store that has data is never swapped for an empty one behind\n * the caller's back. Every caller whose call failed with the open error retries\n * on the memory store, so concurrent first calls all succeed and the switch is\n * logged once.\n *\n * The reason this is relatively complicated is that when {@link IDBStore} is\n * created, it calls `openDatabase` synchronously, but that returns a `Promise`\n * that will reject if the database cannot be opened. We don't await this\n * promise until we call `read` or `write` so we cannot do the switch until\n * then.\n */\n\nexport class IDBStoreWithMemFallback implements Store {\n  readonly #lc: LogContext;\n  readonly #name: string;\n  #store: Store;\n  constructor(lc: LogContext, name: string) {\n    this.#lc = lc;\n    this.#name = name;\n    this.#store = new IDBStore(name);\n  }\n\n  read(): Promise<Read> {\n    return this.#withBrainTransplant(s => s.read());\n  }\n\n  write(): Promise<Write> {\n    return this.#withBrainTransplant(s => s.write());\n  }\n\n  async #withBrainTransplant<T extends Read>(\n    f: (store: Store) => Promise<T>,\n  ): Promise<T> {\n    try {\n      return await f(this.#store);\n    } catch (e) {\n      if (e instanceof IDBOpenError) {\n        // It is possible that we end up with multiple pending read/write and\n        // they all reject. Make sure we only replace the implementation once.\n        if (this.#store instanceof IDBStore) {\n          this.#lc.warn?.(\n            'Switching to MemStore because IndexedDB failed to open',\n            e,\n          );\n          this.#store = new MemStore(this.#name);\n        }\n        return f(this.#store);\n      }\n      throw e;\n    }\n  }\n\n  close(): Promise<void> {\n    return this.#store.close();\n  }\n\n  get closed(): boolean {\n    return this.#store.closed;\n  }\n\n  /**\n   * `'idb'` until an open failure switches this store to memory, then `'mem'`.\n   */\n  get kind(): string | undefined {\n    return this.#store.kind;\n  }\n}\n\nexport function newIDBStoreWithMemFallback(\n  lc: LogContext,\n  name: string,\n): Store {\n  return new IDBStoreWithMemFallback(lc, name);\n}\n\nexport function dropIDBStoreWithMemFallback(name: string): Promise<void> {\n  return dropIDBStore(name).catch((e: unknown) => {\n    if (e instanceof DOMException) {\n      return dropMemStore(name);\n    }\n    throw e;\n  });\n}\n\nfunction dropIDBStore(name: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const req = indexedDB.deleteDatabase(name);\n    req.onsuccess = () => resolve();\n    req.onerror = () => reject(req.error);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,0BAAb,MAAsD;CACpD;CACA;CACA;CACA,YAAY,IAAgB,MAAc;EACxC,KAAKA,MAAM;EACX,KAAKC,QAAQ;EACb,KAAKC,SAAS,IAAI,SAAS,IAAI;CACjC;CAEA,OAAsB;EACpB,OAAO,KAAKC,sBAAqB,MAAK,EAAE,KAAK,CAAC;CAChD;CAEA,QAAwB;EACtB,OAAO,KAAKA,sBAAqB,MAAK,EAAE,MAAM,CAAC;CACjD;CAEA,MAAMA,qBACJ,GACY;EACZ,IAAI;GACF,OAAO,MAAM,EAAE,KAAKD,MAAM;EAC5B,SAAS,GAAG;GACV,IAAI,aAAa,cAAc;IAG7B,IAAI,KAAKA,kBAAkB,UAAU;KACnC,KAAKF,IAAI,OACP,0DACA,CACF;KACA,KAAKE,SAAS,IAAI,SAAS,KAAKD,KAAK;IACvC;IACA,OAAO,EAAE,KAAKC,MAAM;GACtB;GACA,MAAM;EACR;CACF;CAEA,QAAuB;EACrB,OAAO,KAAKA,OAAO,MAAM;CAC3B;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA,OAAO;CACrB;;;;CAKA,IAAI,OAA2B;EAC7B,OAAO,KAAKA,OAAO;CACrB;AACF;AAEA,SAAgB,2BACd,IACA,MACO;CACP,OAAO,IAAI,wBAAwB,IAAI,IAAI;AAC7C;AAEA,SAAgB,4BAA4B,MAA6B;CACvE,OAAO,aAAa,IAAI,EAAE,OAAO,MAAe;EAC9C,IAAI,aAAa,cACf,OAAO,aAAa,IAAI;EAE1B,MAAM;CACR,CAAC;AACH;AAEA,SAAS,aAAa,MAA6B;CACjD,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,MAAM,UAAU,eAAe,IAAI;EACzC,IAAI,kBAAkB,QAAQ;EAC9B,IAAI,gBAAgB,OAAO,IAAI,KAAK;CACtC,CAAC;AACH"}

package/out/zero-cache/src/services/change-source/pg/backfill-resume.d.ts

@@ -1,156 +0,0 @@
-import type { PublishedTableSpec } from '../../../db/specs.ts';
-import type { PostgresDB, PostgresTransaction } from '../../../types/pg.ts';
-/**
- * The subset of a column spec needed to decide whether the column can
- * participate in a resumable row key, and to render its values as SQL
- * literals.
- *
- * `collationIsDeterministic` is not part of {@link PublishedTableSpec} (it is
- * stripped when the published schema is canonicalized); it is fetched
- * separately with {@link getKeyCollations}.
- */
-export type ResumeColumnSpec = {
-    readonly typeOID: number;
-    readonly pgTypeClass?: string | null | undefined;
-    readonly elemPgTypeClass?: string | null | undefined;
-    readonly collationIsDeterministic?: boolean | null | undefined;
-};
-/**
- * A **mark** is the Postgres text form of a row key's values, in
- * `relation.rowKey.columns` order. It is computed by the change source (which
- * knows the column types), stored and returned opaquely by subscribers, and
- * compared only for equality outside of Postgres.
- */
-export type Mark = readonly string[];
-/**
- * Whether a single column's values have an exact text form whose literal is
- * trivially safe to inline into a `COPY (query) TO STDOUT` (which accepts no
- * bind parameters).
- *
- * Types whose text form is lossy (`numeric`, the timestamp family, floats) and
- * columns with a non-deterministic collation are excluded. Excluding the latter
- * is conservatism rather than necessity: a unique index under a
- * non-deterministic collation enforces uniqueness by the same equality that
- * orders it.
- */
-export declare function isResumableColumn(spec: ResumeColumnSpec): boolean;
-/**
- * Whether every column of the row key is resumable. When this is false the
- * change source never attaches a `lastKey` to its `backfill` messages, so no
- * subscriber ever holds a mark for the table and every run starts from the
- * beginning.
- */
-export declare function isResumableKey(specs: readonly ResumeColumnSpec[]): boolean;
-/**
- * Renders one mark value as a SQL literal.
- *
- * The literal must be a *constant* expression so that Postgres can use it as
- * an index condition. (This rules out, e.g.,
- * `convert_from(decode(...), 'UTF8')`, which is `STABLE` and therefore
- * degrades a resume seek into a filtered full index scan.)
- *
- * @throws if `text` is not a valid value for the column's type, which
- *   indicates a corrupt or forged mark.
- */
-export declare function keyLiteral(spec: ResumeColumnSpec, text: string): string;
-export declare class InvalidMarkError extends Error {
-    readonly name = "InvalidMarkError";
-}
-/**
- * The `ORDER BY` clause for an ordered backfill: the row key columns in
- * `relation.rowKey.columns` order, each in its own (native) collation.
- *
- * Ordering in the column's native collation — rather than `COLLATE "C"` —
- * keeps the key's btree usable for both the ordering and the resume seek. Any
- * total, snapshot-stable order suffices, because keys are only ever compared
- * by Postgres.
- */
-export declare function orderByRowKey(rowKeyColumns: readonly string[]): string;
-/**
- * A boolean SQL expression selecting rows whose key sorts strictly after
- * `mark`, using a row-constructor comparison so that it is index-optimizable
- * on the key's btree.
- */
-export declare function resumeWhere(rowKeyColumns: readonly string[], specs: readonly ResumeColumnSpec[], mark: Mark): string;
-/**
- * The row filter of the table's publications, as a parenthesized boolean
- * expression, or `null` if the table is published without a filter.
- */
-export declare function publicationRowFilter(table: PublishedTableSpec): string | null;
-/**
- * Returns whether any row of `table` has a key in `(from, to]`, under the
- * table's publication row filter. `from === null` means "from the beginning",
- * in which case the answer is whether any row exists up to and including `to`.
- *
- * This is the only key comparison the system performs outside of the backfill
- * COPY itself, and it is what the {@link BackfillManager} asks in order to
- * decide whether a declaring subscriber needs rows that the running run has
- * already passed.
- */
-export declare function rowsExist(sql: PostgresDB | PostgresTransaction, table: PublishedTableSpec, rowKeyColumns: readonly string[], specs: readonly ResumeColumnSpec[], from: Mark | null, to: Mark): Promise<boolean>;
-/**
- * Converts a decoded row key value to its mark (Postgres text) form.
- *
- * Accepts the shapes produced by both the binary COPY decoders
- * (`pg-copy-binary.ts`) and the text COPY type parsers.
- */
-export declare function textKey(spec: ResumeColumnSpec, value: unknown): string;
-/**
- * Computes the mark of the last row of a batch of `rowValues`, whose leading
- * values are the row key values (see the `backfill` message).
- */
-export declare function markOfLastRow(specs: readonly ResumeColumnSpec[], rowValues: readonly (readonly unknown[])[]): string[];
-/**
- * Reads the collation determinism of the specified columns.
- *
- * `PublishedTableSpec` does not carry this (the published schema strips it
- * during canonicalization), so it is read directly. `null` means the column
- * has no collation, e.g. an integer or uuid column.
- */
-export declare function getKeyCollations(sql: PostgresDB | PostgresTransaction, relationOID: number, columns: readonly string[]): Promise<Map<string, boolean | null>>;
-/**
- * The minimum `pg_stats.correlation` of a row key's leading column for its
- * table's backfill to be ordered (and therefore resumable).
- *
- * Ordering a backfill COPY by the row key means walking the key's index in
- * order and fetching each row from the heap. When the heap's physical order
- * matches the key order the fetches are sequential and ordering is nearly
- * free; when it does not, each of N rows is a scattered visit into the same
- * pages, and throughput collapses.
- *
- * Measured on 1M rows (~155MB, warm cache, PG 17) with
- * `backfill-resume.bench.pg.ts`, ordered COPY as a fraction of unordered:
- *
- * | correlation | ordered / unordered |
- * | ----------- | ------------------- |
- * | 1.0         | 82%                 |
- * | 0.99995     | 51%                 |
- * | 0.995       | 32%                 |
- * | 0.70        | 22%                 |
- * | 0.0 (uuid)  | 18%                 |
- * | 0.0 (text)  | 17%                 |
- *
- * Correlation saturates near 1, so the threshold has to be tight to hold
- * ordering within ~2x of an unordered COPY. In practice this admits
- * append-mostly tables with a monotonic key, and `CLUSTER`ed tables; a table
- * with a random key (uuid, nanoid) is not ordered, and so is not resumable,
- * and keeps exactly today's behavior.
- */
-export declare const MIN_KEY_CORRELATION = 0.9999;
-/**
- * Reads `pg_stats.correlation` for the leading column of the row key: the
- * statistical correlation between the column's value order and the physical
- * row order.
- *
- * Returns `null` if the table has never been analyzed, or if the column has
- * no correlation statistic. Both are treated as "do not order" by
- * {@link isCheaplyOrderable}, which keeps today's behavior for a table whose
- * cost is unknown.
- */
-export declare function getKeyCorrelation(sql: PostgresDB | PostgresTransaction, relationOID: number, leadingKeyColumn: string): Promise<number | null>;
-/**
- * Whether ordering a backfill of the table by its row key is cheap enough to
- * be worth doing, based on {@link getKeyCorrelation}.
- */
-export declare function isCheaplyOrderable(correlation: number | null, minCorrelation?: number): boolean;
-//# sourceMappingURL=backfill-resume.d.ts.map

package/out/zero-cache/src/services/change-source/pg/backfill-resume.d.ts.map

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

package/out/zero-cache/src/services/change-source/pg/backfill-resume.js

@@ -1,15 +0,0 @@
-//#region ../zero-cache/src/services/change-source/pg/backfill-resume.ts
-/**
-* The row filter of the table's publications, as a parenthesized boolean
-* expression, or `null` if the table is published without a filter.
-*/
-function publicationRowFilter(table) {
-	const rowFilters = Object.values(table.publications).map(({ rowFilter }) => rowFilter);
-	if (rowFilters.some((filter) => filter === null)) return null;
-	const filters = rowFilters.filter((filter) => !!filter);
-	return filters.length === 0 ? null : `(${filters.join(" OR ")})`;
-}
-//#endregion
-export { publicationRowFilter };
-
-//# sourceMappingURL=backfill-resume.js.map

package/out/zero-cache/src/services/change-source/pg/backfill-resume.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-resume.js","names":[],"sources":["../../../../../../../zero-cache/src/services/change-source/pg/backfill-resume.ts"],"sourcesContent":["import {must} from '../../../../../shared/src/must.ts';\nimport * as PostgresTypeClass from '../../../db/postgres-type-class-enum.ts';\nimport type {PublishedTableSpec} from '../../../db/specs.ts';\nimport {\n  BOOL,\n  INT2,\n  INT4,\n  INT8,\n  TEXT,\n  UUID,\n  VARCHAR,\n} from '../../../types/pg-types.ts';\nimport type {PostgresDB, PostgresTransaction} from '../../../types/pg.ts';\nimport {id} from '../../../types/sql.ts';\n\n/**\n * The subset of a column spec needed to decide whether the column can\n * participate in a resumable row key, and to render its values as SQL\n * literals.\n *\n * `collationIsDeterministic` is not part of {@link PublishedTableSpec} (it is\n * stripped when the published schema is canonicalized); it is fetched\n * separately with {@link getKeyCollations}.\n */\nexport type ResumeColumnSpec = {\n  readonly typeOID: number;\n  readonly pgTypeClass?: string | null | undefined;\n  readonly elemPgTypeClass?: string | null | undefined;\n  readonly collationIsDeterministic?: boolean | null | undefined;\n};\n\n/**\n * A **mark** is the Postgres text form of a row key's values, in\n * `relation.rowKey.columns` order. It is computed by the change source (which\n * knows the column types), stored and returned opaquely by subscribers, and\n * compared only for equality outside of Postgres.\n */\nexport type Mark = readonly string[];\n\nconst INT_TYPES: ReadonlySet<number> = new Set([INT2, INT4, INT8]);\nconst TEXT_TYPES: ReadonlySet<number> = new Set([TEXT, VARCHAR]);\n\nconst INT_RE = /^-?[0-9]+$/;\nconst UUID_RE =\n  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;\n\n/**\n * Whether a single column's values have an exact text form whose literal is\n * trivially safe to inline into a `COPY (query) TO STDOUT` (which accepts no\n * bind parameters).\n *\n * Types whose text form is lossy (`numeric`, the timestamp family, floats) and\n * columns with a non-deterministic collation are excluded. Excluding the latter\n * is conservatism rather than necessity: a unique index under a\n * non-deterministic collation enforces uniqueness by the same equality that\n * orders it.\n */\nexport function isResumableColumn(spec: ResumeColumnSpec): boolean {\n  if (spec.elemPgTypeClass !== null && spec.elemPgTypeClass !== undefined) {\n    return false; // array types\n  }\n  if (spec.pgTypeClass === PostgresTypeClass.Enum) {\n    return false; // enum sort order is by attnum, not by text\n  }\n  const {typeOID} = spec;\n  if (TEXT_TYPES.has(typeOID)) {\n    // A non-deterministic collation is excluded; no collation at all\n    // (`null`/`undefined`) is not expected for a text column, but is treated\n    // conservatively as unknown.\n    return spec.collationIsDeterministic === true;\n  }\n  return INT_TYPES.has(typeOID) || typeOID === UUID || typeOID === BOOL;\n}\n\n/**\n * Whether every column of the row key is resumable. When this is false the\n * change source never attaches a `lastKey` to its `backfill` messages, so no\n * subscriber ever holds a mark for the table and every run starts from the\n * beginning.\n */\nexport function isResumableKey(specs: readonly ResumeColumnSpec[]): boolean {\n  return specs.length > 0 && specs.every(isResumableColumn);\n}\n\n/**\n * Escapes a string as a Postgres `E'...'` literal, which has the same meaning\n * whether or not `standard_conforming_strings` is on.\n *\n * A plain `'...'` literal would suffice under the default (and, since PG 9.1,\n * only supported) setting, but the `E` form makes the escaping explicit and\n * independent of server configuration.\n */\nfunction escapeString(value: string): string {\n  return `E'${value.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")}'`;\n}\n\n/**\n * Renders one mark value as a SQL literal.\n *\n * The literal must be a *constant* expression so that Postgres can use it as\n * an index condition. (This rules out, e.g.,\n * `convert_from(decode(...), 'UTF8')`, which is `STABLE` and therefore\n * degrades a resume seek into a filtered full index scan.)\n *\n * @throws if `text` is not a valid value for the column's type, which\n *   indicates a corrupt or forged mark.\n */\nexport function keyLiteral(spec: ResumeColumnSpec, text: string): string {\n  const {typeOID} = spec;\n  if (INT_TYPES.has(typeOID)) {\n    if (!INT_RE.test(text)) {\n      throw new InvalidMarkError(`${text} is not an integer`);\n    }\n    return text;\n  }\n  if (typeOID === UUID) {\n    if (!UUID_RE.test(text)) {\n      throw new InvalidMarkError(`${text} is not a uuid`);\n    }\n    return `'${text.toLowerCase()}'::uuid`;\n  }\n  if (typeOID === BOOL) {\n    if (text !== 'true' && text !== 'false') {\n      throw new InvalidMarkError(`${text} is not a boolean`);\n    }\n    return text;\n  }\n  if (TEXT_TYPES.has(typeOID)) {\n    return escapeString(text);\n  }\n  throw new InvalidMarkError(`type OID ${typeOID} is not resumable`);\n}\n\nexport class InvalidMarkError extends Error {\n  readonly name = 'InvalidMarkError';\n}\n\n/**\n * The `ORDER BY` clause for an ordered backfill: the row key columns in\n * `relation.rowKey.columns` order, each in its own (native) collation.\n *\n * Ordering in the column's native collation — rather than `COLLATE \"C\"` —\n * keeps the key's btree usable for both the ordering and the resume seek. Any\n * total, snapshot-stable order suffices, because keys are only ever compared\n * by Postgres.\n */\nexport function orderByRowKey(rowKeyColumns: readonly string[]): string {\n  return rowKeyColumns.map(id).join(',');\n}\n\n/**\n * A boolean SQL expression selecting rows whose key sorts strictly after\n * `mark`, using a row-constructor comparison so that it is index-optimizable\n * on the key's btree.\n */\nexport function resumeWhere(\n  rowKeyColumns: readonly string[],\n  specs: readonly ResumeColumnSpec[],\n  mark: Mark,\n): string {\n  return rowComparison(rowKeyColumns, specs, mark, '>');\n}\n\nfunction rowComparison(\n  rowKeyColumns: readonly string[],\n  specs: readonly ResumeColumnSpec[],\n  mark: Mark,\n  op: '>' | '<=',\n): string {\n  if (rowKeyColumns.length !== mark.length) {\n    throw new InvalidMarkError(\n      `mark has ${mark.length} values for a ${rowKeyColumns.length} column key`,\n    );\n  }\n  const cols = rowKeyColumns.map(id).join(',');\n  const vals = mark.map((text, i) => keyLiteral(specs[i], text)).join(',');\n  return `(${cols}) ${op} (${vals})`;\n}\n\n/**\n * The row filter of the table's publications, as a parenthesized boolean\n * expression, or `null` if the table is published without a filter.\n */\nexport function publicationRowFilter(table: PublishedTableSpec): string | null {\n  const rowFilters = Object.values(table.publications).map(\n    ({rowFilter}) => rowFilter,\n  );\n  // PostgreSQL publishes the union of all publications. An unfiltered\n  // publication therefore makes every row eligible, regardless of filters on\n  // any other publication containing the table.\n  if (rowFilters.some(filter => filter === null)) {\n    return null;\n  }\n  const filters = rowFilters.filter((filter): filter is string => !!filter);\n  return filters.length === 0 ? null : `(${filters.join(' OR ')})`;\n}\n\n/**\n * Returns whether any row of `table` has a key in `(from, to]`, under the\n * table's publication row filter. `from === null` means \"from the beginning\",\n * in which case the answer is whether any row exists up to and including `to`.\n *\n * This is the only key comparison the system performs outside of the backfill\n * COPY itself, and it is what the {@link BackfillManager} asks in order to\n * decide whether a declaring subscriber needs rows that the running run has\n * already passed.\n */\nexport async function rowsExist(\n  sql: PostgresDB | PostgresTransaction,\n  table: PublishedTableSpec,\n  rowKeyColumns: readonly string[],\n  specs: readonly ResumeColumnSpec[],\n  from: Mark | null,\n  to: Mark,\n): Promise<boolean> {\n  const conditions = [\n    publicationRowFilter(table),\n    from === null ? null : rowComparison(rowKeyColumns, specs, from, '>'),\n    rowComparison(rowKeyColumns, specs, to, '<='),\n  ].filter(c => c !== null);\n  const rows = await sql.unsafe(\n    /*sql*/ `SELECT 1 FROM ${id(table.schema)}.${id(table.name)} ` +\n      `WHERE ${conditions.join(' AND ')} LIMIT 1`,\n  );\n  return rows.length > 0;\n}\n\n/**\n * Converts a decoded row key value to its mark (Postgres text) form.\n *\n * Accepts the shapes produced by both the binary COPY decoders\n * (`pg-copy-binary.ts`) and the text COPY type parsers.\n */\nexport function textKey(spec: ResumeColumnSpec, value: unknown): string {\n  const {typeOID} = spec;\n  if (value === null || value === undefined) {\n    // Row key columns are `NOT NULL` (see `db/lite-tables.ts`), so this\n    // indicates a bug rather than data.\n    throw new InvalidMarkError(`null value in a row key`);\n  }\n  if (typeOID === BOOL) {\n    switch (typeof value) {\n      case 'boolean':\n        return value ? 'true' : 'false';\n      case 'number':\n      case 'bigint':\n        return value ? 'true' : 'false';\n      case 'string':\n        return value === 't' || value === 'true' ? 'true' : 'false';\n    }\n  }\n  const text = typeof value === 'string' ? value : String(value);\n  if (typeOID === UUID) {\n    return text.toLowerCase();\n  }\n  return text;\n}\n\n/**\n * Computes the mark of the last row of a batch of `rowValues`, whose leading\n * values are the row key values (see the `backfill` message).\n */\nexport function markOfLastRow(\n  specs: readonly ResumeColumnSpec[],\n  rowValues: readonly (readonly unknown[])[],\n): string[] {\n  const last = must(rowValues.at(-1), `no rows`);\n  return specs.map((spec, i) => textKey(spec, last[i]));\n}\n\n/**\n * Reads the collation determinism of the specified columns.\n *\n * `PublishedTableSpec` does not carry this (the published schema strips it\n * during canonicalization), so it is read directly. `null` means the column\n * has no collation, e.g. an integer or uuid column.\n */\nexport async function getKeyCollations(\n  sql: PostgresDB | PostgresTransaction,\n  relationOID: number,\n  columns: readonly string[],\n): Promise<Map<string, boolean | null>> {\n  const rows = await sql<{col: string; deterministic: boolean | null}[]>`\n    SELECT attname AS \"col\", coll.collisdeterministic AS \"deterministic\"\n      FROM pg_attribute\n      LEFT JOIN pg_collation coll ON coll.oid = attcollation\n      WHERE attrelid = ${relationOID} AND attname IN ${sql(columns as string[])}`;\n  return new Map(rows.map(({col, deterministic}) => [col, deterministic]));\n}\n\n/**\n * The minimum `pg_stats.correlation` of a row key's leading column for its\n * table's backfill to be ordered (and therefore resumable).\n *\n * Ordering a backfill COPY by the row key means walking the key's index in\n * order and fetching each row from the heap. When the heap's physical order\n * matches the key order the fetches are sequential and ordering is nearly\n * free; when it does not, each of N rows is a scattered visit into the same\n * pages, and throughput collapses.\n *\n * Measured on 1M rows (~155MB, warm cache, PG 17) with\n * `backfill-resume.bench.pg.ts`, ordered COPY as a fraction of unordered:\n *\n * | correlation | ordered / unordered |\n * | ----------- | ------------------- |\n * | 1.0         | 82%                 |\n * | 0.99995     | 51%                 |\n * | 0.995       | 32%                 |\n * | 0.70        | 22%                 |\n * | 0.0 (uuid)  | 18%                 |\n * | 0.0 (text)  | 17%                 |\n *\n * Correlation saturates near 1, so the threshold has to be tight to hold\n * ordering within ~2x of an unordered COPY. In practice this admits\n * append-mostly tables with a monotonic key, and `CLUSTER`ed tables; a table\n * with a random key (uuid, nanoid) is not ordered, and so is not resumable,\n * and keeps exactly today's behavior.\n */\nexport const MIN_KEY_CORRELATION = 0.9999;\n\n/**\n * Reads `pg_stats.correlation` for the leading column of the row key: the\n * statistical correlation between the column's value order and the physical\n * row order.\n *\n * Returns `null` if the table has never been analyzed, or if the column has\n * no correlation statistic. Both are treated as \"do not order\" by\n * {@link isCheaplyOrderable}, which keeps today's behavior for a table whose\n * cost is unknown.\n */\nexport async function getKeyCorrelation(\n  sql: PostgresDB | PostgresTransaction,\n  relationOID: number,\n  leadingKeyColumn: string,\n): Promise<number | null> {\n  const rows = await sql<{correlation: number | null}[]>`\n    SELECT s.correlation\n      FROM pg_stats s, pg_class c, pg_namespace n\n     WHERE c.oid = ${relationOID}\n       AND n.oid = c.relnamespace\n       AND s.schemaname = n.nspname\n       AND s.tablename = c.relname\n       AND s.attname = ${leadingKeyColumn}`;\n  return rows[0]?.correlation ?? null;\n}\n\n/**\n * Whether ordering a backfill of the table by its row key is cheap enough to\n * be worth doing, based on {@link getKeyCorrelation}.\n */\nexport function isCheaplyOrderable(\n  correlation: number | null,\n  minCorrelation: number = MIN_KEY_CORRELATION,\n): boolean {\n  return correlation !== null && Math.abs(correlation) >= minCorrelation;\n}\n"],"mappings":";;;;;AAuLA,SAAgB,qBAAqB,OAA0C;CAC7E,MAAM,aAAa,OAAO,OAAO,MAAM,YAAY,EAAE,KAClD,EAAC,gBAAe,SACnB;CAIA,IAAI,WAAW,MAAK,WAAU,WAAW,IAAI,GAC3C,OAAO;CAET,MAAM,UAAU,WAAW,QAAQ,WAA6B,CAAC,CAAC,MAAM;CACxE,OAAO,QAAQ,WAAW,IAAI,OAAO,IAAI,QAAQ,KAAK,MAAM,EAAE;AAChE"}