@happyvertical/smrt-core 0.50.0 → 0.51.1

package/dist/migrations/differ.d.ts

@@ -156,6 +156,40 @@ export declare class SchemaComparer {
     private liveSchemas;
     /** Convergence plan for this run; `null` on non-PostgreSQL engines. */
     private uuidConvergence;
+    /**
+     * Rename-pending advisory findings for this `compare()` run, keyed by
+     * table name (#2878). `compareTable()` reads from here when it is being
+     * driven by `compare()` over the full manifest, which lets the probe be
+     * batched *across every table in one round trip* instead of paying at
+     * least one round trip per table (#2876 batched a table's own columns
+     * into one round trip but never batched across tables — with a
+     * realistic 71-table schema that per-table floor was itself the entire
+     * residual). `null` means "not precomputed for this run" (a standalone
+     * `compareTable()` call outside `compare()`, or a non-PostgreSQL/SQLite
+     * engine), in which case `detectRenameDataPending()` falls back to the
+     * original single-table probe so standalone callers keep working
+     * unchanged. Cleared every `compare()` call, same as `liveSchemas` —
+     * this is a per-run cache, never reused across runs, so a live schema
+     * change is always seen on the next comparison (no invalidation story
+     * needed because nothing survives past one `compare()` call).
+     */
+    private renameDataPendingCache;
+    /**
+     * Cross-table batch queries stay bounded regardless of schema shape: this
+     * caps how many scalar-subquery columns one probe statement packs into a
+     * single row. Conservative relative to PostgreSQL's ~1600 column limit
+     * per result row, and SQLite has no such ceiling but benefits from the
+     * same bound for query-text size. Applied twice (PR #2888 review): once
+     * per table, so a single pathologically wide table (more probed columns
+     * than this cap) is itself sliced across more than one statement rather
+     * than landing in one oversized chunk; and again across tables, packing
+     * every (possibly sliced) entry into as few chunks as this cap allows.
+     * A schema with no single table wider than this cap needs more than
+     * `MAX_CROSS_TABLE_PROBE_COLUMNS` probed columns *in total* before a
+     * second statement is needed at all — still O(1)-ish round trips for a
+     * realistic schema.
+     */
+    private static readonly MAX_CROSS_TABLE_PROBE_COLUMNS;
     constructor(db: DatabaseInterface, options?: DiffOptions);
     /**
      * Compare manifest schemas to database and return differences
@@ -226,6 +260,15 @@ export declare class SchemaComparer {
      *    that orphan gets an executable `DROP NOT NULL` where the engine allows.
      */
     private compareColumns;
+    /**
+     * Detect a pending rename backfill (#2752) for one table. Reads
+     * `renameDataPendingCache` when `compare()` has already batched this
+     * table's probe across the whole manifest (#2878); otherwise falls back
+     * to {@link detectRenameDataPendingSingleTable}, so a standalone
+     * `compareTable()` call (outside `compare()`) still gets a correct
+     * answer, just without the cross-table batching.
+     */
+    private detectRenameDataPending;
     /**
      * Detect a pending rename backfill (#2752): a manifest-declared column
      * that exists live but holds no data, paired with an orphan (undeclared)
@@ -238,26 +281,89 @@ export declare class SchemaComparer {
      * `DO $$ ... $$` block); SQLite has no conditional-DDL construct, so its
      * repair is operator-mediated instead — a guard query plus instructions,
      * not a blind-rerun-safe statement. See {@link describeRenameDataPending}.
-     */
-    private detectRenameDataPending;
-    /**
-     * Live-data probe: does the column hold any non-null, non-empty value?
-     * Used by {@link detectRenameDataPending}. Errors propagate to the
-     * caller, which skips the pair rather than guessing (#2752).
-     */
-    private columnHasNonEmptyValue;
-    /**
-     * Live-data probe: are every one of a column's non-empty values
-     * UUID-shaped ({@link CANONICAL_UUID_PATTERN})? PostgreSQL pushes the
-     * check into the query with its regex operator; SQLite has no regex
-     * operator, but its case-sensitive `GLOB` can still express the fixed
-     * 36-character canonical shape ({@link CANONICAL_UUID_SQLITE_GLOB_PATTERN}
-     * against `LOWER(...)`, guarded by an exact `LENGTH(...) = 36` check), so
-     * both engines run one server-side aggregate `count(*)` rather than
-     * fetching every non-empty value into JS to test in a loop — important on
-     * a production table with many rows (#2767 review).
-     */
-    private allNonEmptyValuesUuidShaped;
+     *
+     * Single-table probe: at least one round trip for this table alone.
+     * `compare()` does not call this directly — see
+     * {@link precomputeRenameDataPending} for the cross-table batched path
+     * that every ordinary `compare()` run takes instead (#2878). This stays
+     * as the fallback for a standalone `compareTable()` call.
+     */
+    private detectRenameDataPendingSingleTable;
+    /**
+     * Batch every table's rename-pending advisory probe (#2752/#2878) into a
+     * small, table-count-independent number of round trips, and populate
+     * {@link renameDataPendingCache} so `compareTable()`'s per-table
+     * `detectRenameDataPending()` call becomes a cache read for the rest of
+     * this `compare()` run.
+     *
+     * Mirrors {@link detectRenameDataPendingSingleTable}'s phases exactly —
+     * same gates, same type-compatibility rules, same per-column `LIMIT 1`
+     * early exit — just resequenced so each phase's *query* covers every
+     * table that needs it in one statement, instead of one statement per
+     * table. With a 71-table schema this is the difference between a
+     * 71-statement floor (#2878) and a handful of statements for the whole
+     * schema, independent of table count.
+     *
+     * No caching beyond this: the cache this populates is cleared at the top
+     * of every `compare()` call, so a live schema change is always visible
+     * on the next comparison.
+     */
+    private precomputeRenameDataPending;
+    /**
+     * Cross-table variant of {@link columnsHaveNonEmptyValueBatch}: the same
+     * uncorrelated-scalar-subquery, per-column `LIMIT 1` shape, but packed
+     * into one row *per query* across every named table's columns instead of
+     * one row per table — the #2878 lever. Chunks at
+     * {@link MAX_CROSS_TABLE_PROBE_COLUMNS} columns per statement so a very
+     * large schema still issues a small, bounded number of round trips
+     * rather than one arbitrarily wide row.
+     *
+     * Falls back to the existing per-table batch (itself falling back
+     * further to per-column) for any chunk whose combined statement fails,
+     * so one bad table never discards another table's detection — the same
+     * failure-isolation guarantee {@link columnsHaveNonEmptyValueBatch}
+     * already gives per-column, extended one level up.
+     */
+    private crossTableColumnsHaveNonEmptyValueBatch;
+    /**
+     * Cross-table variant of {@link columnsAllValuesUuidShapedBatch} — same
+     * shape as {@link crossTableColumnsHaveNonEmptyValueBatch}, engine-aware
+     * invalid-shape predicate included.
+     */
+    private crossTableColumnsAllValuesUuidShapedBatch;
+    /**
+     * Shared cross-table batching engine for the two probes above. Builds one
+     * `SELECT` per chunk with a scalar subquery per (table, column) pair,
+     * globally aliased `t{tableIndex}_c{colIndex}` — PostgreSQL truncates a
+     * `name` identifier to 63 bytes, so a positional alias is used instead of
+     * the real column name for the same reason the single-table batch does
+     * (#2874 review finding F2'). On a chunk's query failure, that chunk's
+     * tables fall back to the single-table batch path individually (each of
+     * which falls back further to per-column) rather than discarding every
+     * table's result.
+     *
+     * Known lock-footprint change (#2878 final review F2, deferred to
+     * #2887): one chunked statement takes `ACCESS SHARE` on every
+     * table in that chunk *simultaneously*, where the pre-#2878 per-table
+     * probe held at most one table's `ACCESS SHARE` at a time (each
+     * autocommitted statement releases its lock before the next one runs).
+     * That is a materially different PostgreSQL locking pattern: it is now
+     * possible, in principle, for this session to be one side of a deadlock
+     * with a concurrent multi-table DDL transaction (e.g. a `db:migrate` in
+     * flight) in a way the old per-table probe structurally could not be.
+     * PostgreSQL's deadlock detector resolves any such cycle by aborting one
+     * side with a loud `deadlock detected` error — never silently, and never
+     * with partial/corrupt state — so if this session is the victim, the
+     * `catch` above already degrades it to the safe per-table fallback; if
+     * the *other* side (the migration) is the victim, that transaction rolls
+     * back cleanly and is safe to re-run. No test in this repository exercises
+     * concurrent DDL against the probed tables, so this risk is unverified by
+     * suite rather than disproven. Bounding it further — chunking by table
+     * count as well as column count, and/or a short `lock_timeout` on these
+     * statements so this session always yields first — is deferred to #2887
+     * rather than fixed here.
+     */
+    private crossTableProbeBatch;
     /**
      * Render the repair for one rename-data-pending pair (#2752): copy
      * non-empty `oldColumn` into `newColumn` only where `newColumn` is still
@@ -272,7 +378,7 @@ export declare class SchemaComparer {
      *   for `integer`/`boolean`/`timestamp`/etc. before a same-type rename
      *   pair of one of those types ever copies anything. Fixed by comparing
      *   `CAST(col AS TEXT) = ''` instead, mirroring the same portable
-     *   emptiness check {@link columnHasNonEmptyValue} already uses for
+     *   emptiness check {@link columnsHaveNonEmptyValueBatch} already uses for
      *   detection, so the predicate is valid for every column type.
      * - (P2) An `UPDATE` unconditionally naming `oldColumn` fails once that
      *   column is gone, on either engine, regardless of the DROP's own

package/dist/migrations/differ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"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"}