@intentius/chant-lexicon-sql 0.114.0 → 0.114.1

package/dist/clickhouse/rebuild/backfill.d.ts

@@ -41,6 +41,21 @@
  * With a replica down (#3270) the kill goes on without it, and each sync
  * either finds nothing that replica alone has and returns, or stops the step
  * naming it (`./replicas.ts`).
+ *
+ * In materialized-view mode a partition is copied in two parts
+ * (INTENTIUS/sql-yodeler#45). The rows before the cut-over are copied as
+ * above. The rows at or after it are the view's only when they were written
+ * after the view was made; the ones the old table already held (a booking
+ * next month, an expiry date) reach the new table only through the backfill.
+ * The two kinds cannot be told apart by their values, so the second part
+ * copies the difference: for each distinct row at or after the cut-over, as
+ * many copies as the old table has more of it than the new one. That copy
+ * converges on its own, so a run killed during it, or a partition copied
+ * again, copies only what is still missing. A row the view is a moment from
+ * committing can be copied by both: the copy is followed by a check for rows
+ * the new table holds more often than the old one, which deletes and copies
+ * those again. Whatever is left, the verification finds, and the swap does
+ * not go ahead.
  */
 import { type ClickHouseReceiptStore } from "./receipts.js";
 import { type RebuildObservation } from "./observe.js";
@@ -55,6 +70,8 @@ export interface BackfillResult {
     skipped: number;
     /** Partitions this run found partly copied and cleared before copying again. */
     cleared: number;
+    /** Distinct rows at or after the cut-over found in the new table too often (copied while the view was writing them), deleted and copied again. */
+    repaired: number;
 }
 /** The effect a partition's copy is, and its receipt's address suffix. */
 export declare const partitionEffect: (key: string, partition: string) => string;

package/dist/clickhouse/rebuild/backfill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backfill.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAKH,OAAO,EAA0C,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAGpE,OAAO,EAAkE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1G,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,0EAA0E;AAC1E,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,KAAG,MAAuC,CAAC;AAEzG,6DAA6D;AAC7D,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CASlH;AAED,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,0GAA0G;IAC1G,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9D;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoFhG"}
+{"version":3,"file":"backfill.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAKH,OAAO,EAA0C,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAIpE,OAAO,EAAkE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1G,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAC;IAChB,kJAAkJ;IAClJ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,0EAA0E;AAC1E,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,KAAG,MAAuC,CAAC;AAEzG,6DAA6D;AAC7D,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAiBlH;AAED,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,0GAA0G;IAC1G,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9D;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAwFhG"}

package/dist/clickhouse/rebuild/observe.d.ts

@@ -46,9 +46,10 @@ export type DualWrite = {
     /**
      * A materialized view on the old table writes every row whose
      * `cutoverColumn` is at or after the cut-over into the new table; the
-     * backfill copies the rows before it. The cut-over is the server's time
-     * when the view is made plus `cutoverDelay` (default `1m`), and the
-     * backfill starts once it has passed. The column must be a time
+     * backfill copies the rows before it, and the rows at or after it that
+     * the table held before the view was made. The cut-over is the server's
+     * time when the view is made plus `cutoverDelay` (default `1m`), rounded
+     * up to a whole second, and the backfill starts once it has passed. The column must be a time
      * (`Date`, `DateTime`, `DateTime64`) that rows arrive in order of, give
      * or take the delay; a row that arrives later than that is caught by
      * the verification, which then fails the run.

package/dist/clickhouse/rebuild/observe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/observe.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/observe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAGlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAe,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAKxD,OAAO,EAAE,KAAK,EAAwC,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEvG,gFAAgF;AAChF,MAAM,MAAM,SAAS,GACjB;IACE;;;;;;;;;;OAUG;IACH,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GACD;IACE;;;;;OAKG;IACH,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AAEN,iGAAiG;AACjG,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAI5B;AAED,uDAAuD;AACvD,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAgBzE;AAED,+DAA+D;AAC/D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAED,2DAA2D;AAC3D,MAAM,WAAW,YAAY;IAC3B,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IACtC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,cAAc,CAAC;IACzB,oCAAoC;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,mEAAmE;IACnE,aAAa,EAAE,eAAe,CAAC;IAC/B,yEAAyE;IACzE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,GAAG,CAAC,EAAE,YAAY,CAAC;IACnB,wGAAwG;IACxG,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,uGAAuG;IACvG,SAAS,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAID,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,cAAc,CAO9F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG,YAAY,EAAE,CAS9F;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOrE;AAgBD,4EAA4E;AAC5E,wBAAsB,UAAU,CAAC,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAGtG;AAED,2HAA2H;AAC3H,wBAAsB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGzI;AAmBD,+DAA+D;AAC/D,wBAAsB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,eAAe,GAAG,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA2EzJ;AAoCD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,kBAAkB,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASvG;AAED,eAAO,MAAM,iBAAiB,GAAI,GAAG,kBAAkB,EAAE,WAAW,SAAS,KAAG,MAAmF,CAAC;AAEpK,mEAAmE;AACnE,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/clickhouse/rebuild/steps.d.ts

@@ -73,7 +73,8 @@ export interface DualWriteResult {
  * old table that writes every row at or after the cut-over into the new
  * table. The cut-over is the server's time now plus the delay, kept in the
  * view's own comment (`cutover=`), so a later run and the backfill read it
- * back from the server. App mode creates nothing; its gate is the Op's.
+ * back from the server. The rows at or after the cut-over that the old table
+ * already held are the backfill's (`./backfill.ts`). App mode creates nothing; its gate is the Op's.
  */
 export declare function startDualWrite(run: RebuildRun): Promise<DualWriteResult>;
 /** The cut-over in milliseconds, from the dual-write view; undefined in app mode. */
@@ -88,8 +89,9 @@ export interface SwapResult {
     retainUntil?: string;
 }
 /**
- * Swap the new table in: `EXCHANGE TABLES`, then drop the dual-write view,
- * rename the old table (now under the new table's name) to `t__chant_old`
+ * Swap the new table in: compare every row of the two tables once more, as
+ * the verification does, and stop on any difference; then `EXCHANGE TABLES`,
+ * drop the dual-write view, rename the old table (now under the new table's name) to `t__chant_old`
  * with its retention date, recreate the materialized views that read the
  * table, and stamp the table's own comment as declared.
  *

package/dist/clickhouse/rebuild/steps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/steps.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAGlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAyE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIjI,OAAO,EAML,KAAK,SAAS,EACd,KAAK,kBAAkB,EACxB,MAAM,WAAW,CAAC;AAEnB,gCAAgC;AAChC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,wCAAwC;IACxC,QAAQ,EAAE,cAAc,CAAC;IACzB,wEAAwE;IACxE,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,6HAA6H;IAC7H,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,sHAAsH;AACtH,wBAAsB,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzE;AAED,0EAA0E;AAC1E,eAAO,MAAM,MAAM,GAAI,IAAI,MAAM,KAAG,MAAuE,CAAC;AAE5G,qCAAqC;AACrC,eAAO,MAAM,UAAU,GAAI,IAAI,MAAM,KAAG,MAA4D,CAAC;AAErG,eAAO,MAAM,OAAO,GAAI,KAAK,UAAU,KAAG,OAAO,CAAC,kBAAkB,CAAyD,CAAC;AAe9H,wBAAsB,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM5F;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5I;AAOD,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAoB3E;AAID,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACxB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,CAyB9E;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAKpF;AAID,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,iFAAiF;IACjF,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAuCrE;AAeD,uFAAuF;AACvF,wBAAsB,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAOtI;AASD,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qCAAqC;IACrC,GAAG,EAAE,OAAO,CAAC;IACb,oHAAoH;IACpH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,sFAAsF;AACtF,wBAAsB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAavE;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,2GAA2G;AAC3G,wBAAsB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAUvE;AAID,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAoBtI"}
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/steps.ts"],"names":[],"mappings":"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"}

package/dist/clickhouse/rebuild/verify.d.ts

@@ -1,20 +1,36 @@
 /**
- * The verification (#3198): row counts and checksums per partition, the old
- * table against the new one, before anyone is asked to approve the swap.
+ * The verification (#3198, INTENTIUS/sql-yodeler#45): row counts and
+ * checksums per partition, the old table against the new one, before anyone
+ * is asked to approve the swap.
  *
  * Per partition of the old table: the number of rows and the sum of a
  * 64-bit hash of each row's copied columns, read in one grouped query on
  * each side. The old side casts each column to its type in the new table
  * first, so a column whose type the rebuild changes hashes the same when
- * its values survived the change. In materialized-view mode both sides are
- * limited to the rows before the cut-over, which are the backfill's; the
- * rows after it were written by the dual-write view and keep arriving.
+ * its values survived the change.
+ *
+ * Every row is compared, in both modes. In materialized-view mode the rows
+ * at or after the cut-over are in the new table twice over: those the old
+ * table held before the view existed, which the backfill copies, and those
+ * written since, which the view writes. Comparing only the rows before the
+ * cut-over let a swap go ahead without the first kind (sql-yodeler#45).
+ * Writes go on while the tables are read, and a row the old table has
+ * committed may be a moment from committing in the new one through the view,
+ * so the old table is read first and a difference is read again a few times
+ * before it counts.
+ *
+ * The same comparison runs again in the Swap step just before the
+ * `EXCHANGE`, so rows that reach the old table alone after this step (a row
+ * later than the cut-over delay, with a time before the cut-over) stop the
+ * swap too, rather than stay behind in the old table.
  *
  * Any difference fails the run, naming the partitions; the run's onFailure
  * then drops the new table. On a match the result carries the digest the
- * swap gate binds: the rebuild's plan and the verification together, so an
- * approval is for this plan with these counts, and a changed count needs a
- * new approval.
+ * swap gate binds: the rebuild's plan and the counts and checksums of the
+ * rows before the cut-over, which no later write changes, so an approval
+ * is for this plan with these counts, and a changed count needs a new
+ * approval. The rows at or after the cut-over keep arriving through the view
+ * and are compared, not bound.
  */
 import { type RebuildObservation } from "./observe.js";
 import { type RebuildRun } from "./steps.js";
@@ -27,25 +43,32 @@ export interface VerifyResult {
     state: RebuildObservation["state"];
     /** The digest the swap gate binds: plan plus verification. Absent once the swap has run: there is nothing left for that gate to approve. */
     planDigest?: string;
+    /** Partitions of the old table compared. */
     partitions: number;
+    /** Rows compared: every row of the old table. */
     rows: number;
     /** One line for the run record and the gate. */
     summary: string;
+    /** Per partition, the rows before the cut-over (every row in app mode): what the swap gate binds. */
     verification: PartitionCheck[];
 }
 /** A verification that found the tables different. */
 export declare class RebuildVerificationError extends Error {
     readonly table: string;
-    readonly mismatches: Array<{
-        partition: string;
-        old?: PartitionCheck;
-        new?: PartitionCheck;
-    }>;
-    constructor(table: string, mismatches: Array<{
-        partition: string;
-        old?: PartitionCheck;
-        new?: PartitionCheck;
-    }>);
+    readonly mismatches: Mismatch[];
+    constructor(table: string, mismatches: Mismatch[]);
 }
+export type Mismatch = {
+    partition: string;
+    old?: PartitionCheck;
+    new?: PartitionCheck;
+};
+/** The 64-bit hash of a row's copied columns, as the backfill and the verification compute it. */
+export declare const rowHash: (columns: readonly string[]) => string;
+/**
+ * Before the swap: the new table holds every row the old one does. Throws a
+ * {@link RebuildVerificationError} when it does not, so nothing is swapped.
+ */
+export declare function assertSameRows(run: RebuildRun, o: RebuildObservation): Promise<void>;
 export declare function verifyRebuild(run: RebuildRun): Promise<VerifyResult>;
 //# sourceMappingURL=verify.d.ts.map

package/dist/clickhouse/rebuild/verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,EAAsC,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAExF,OAAO,EAAuD,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE/F,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,4IAA4I;IAC5I,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,sDAAsD;AACtD,qBAAa,wBAAyB,SAAQ,KAAK;IAE/C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAA;KAAE,CAAC;gBADpF,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAA;KAAE,CAAC;CAYhG;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CA8D1E"}
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAKH,OAAO,EAAsC,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAExF,OAAO,EAAuD,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE/F,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,4IAA4I;IAC5I,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,YAAY,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,sDAAsD;AACtD,qBAAa,wBAAyB,SAAQ,KAAK;IAE/C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,UAAU,EAAE,QAAQ,EAAE;gBADtB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,QAAQ,EAAE;CAalC;AAyED,MAAM,MAAM,QAAQ,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,cAAc,CAAC;IAAC,GAAG,CAAC,EAAE,cAAc,CAAA;CAAE,CAAC;AAYzF,kGAAkG;AAClG,eAAO,MAAM,OAAO,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,MAA8D,CAAC;AAEpH;;;GAGG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1F;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CA2B1E"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "4d4b3853d5595af4a169a82b6c45f87a103adace1fdff4e61181bcf34aa0a0e2",
+    "manifest.json": "82beced7beffe2bdd0dcf24728910539758d9d4dc85c94fe6418167bcbea9636",
     "meta.json": "5b7a5d171aa8bd21c0d55cfbe421143d67da02b7ef924a9b66166790c3fc7b22",
     "types/index.d.ts": "0286ebb367773e84c76818b0f69cb14cff8328fd2f8c65ed87563c8d5815458c",
     "rules/postgres-templates.ts": "f7244417426c441180ccb5c52da32cd812960d6d4eaba1fbdb17f47fcae707b2",
@@ -57,5 +57,5 @@
     "rules/sqlpg117.ts": "3d5c2d57ccdee3cf91c3ba3cb6363750787a850df8ebd75e9cc3f33113303827",
     "rules/sqlpg118.ts": "e2a40a88a9374c4d99d02118ca4c60877ba0c6eb1ce603a93b24f5fd23d81dde"
   },
-  "composite": "8d565dbc9a455095b5d5e81aac886a7af1b2cb1f3a6e21d0a4ed513b08e1b52a"
+  "composite": "619bc77b9a85523857c04bc2fd6ab9a538a97bca5c6824aadf06c3b58a517b76"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "sql",
-  "version": "0.114.0",
+  "version": "0.114.1",
   "chantVersion": ">=0.1.0",
   "namespace": "SQL",
   "intrinsics": [],

package/dist/postgres/plan/deep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deep.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/deep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAmB,KAAK,qBAAqB,EAAgC,MAAM,mCAAmC,CAAC;AAE9H,OAAO,EAAyC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACvF,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7E,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErG,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAcrC,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAGhD;AA6CD,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,KAAK,CAwCpH;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/E,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAwChC"}
+{"version":3,"file":"deep.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/deep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAmB,KAAK,qBAAqB,EAAgC,MAAM,mCAAmC,CAAC;AAE9H,OAAO,EAAyC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACvF,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7E,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErG,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAcrC,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAGhD;AA6CD,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,KAAK,CAmDpH;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/E,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAwChC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-sql",
-  "version": "0.114.0",
+  "version": "0.114.1",
   "description": "SQL lexicon for chant — database schema as typed declarations, one dialect at a time; ClickHouse first, with types read from a pinned server's catalog",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -70,7 +70,7 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.114.0",
+    "@intentius/chant": "^0.114.1",
     "typescript": "^5.9.3"
   }
 }

package/src/clickhouse/rebuild/backfill.ts

@@ -41,6 +41,21 @@
  * With a replica down (#3270) the kill goes on without it, and each sync
  * either finds nothing that replica alone has and returns, or stops the step
  * naming it (`./replicas.ts`).
+ *
+ * In materialized-view mode a partition is copied in two parts
+ * (INTENTIUS/sql-yodeler#45). The rows before the cut-over are copied as
+ * above. The rows at or after it are the view's only when they were written
+ * after the view was made; the ones the old table already held (a booking
+ * next month, an expiry date) reach the new table only through the backfill.
+ * The two kinds cannot be told apart by their values, so the second part
+ * copies the difference: for each distinct row at or after the cut-over, as
+ * many copies as the old table has more of it than the new one. That copy
+ * converges on its own, so a run killed during it, or a partition copied
+ * again, copies only what is still missing. A row the view is a moment from
+ * committing can be copied by both: the copy is followed by a check for rows
+ * the new table holds more often than the old one, which deletes and copies
+ * those again. Whatever is left, the verification finds, and the swap does
+ * not go ahead.
  */
 
 import { EffectReceipt, receiptExpectation } from "@intentius/chant/effect-receipt";
@@ -50,6 +65,7 @@ import { clickhouseReceiptStore, receiptAddress, type ClickHouseReceiptStore } f
 import { RebuildRefusal, type RebuildObservation } from "./observe";
 import { DDL_SETTINGS } from "./replicas";
 import { sourcePartitionExpression, sourcePartitions } from "./partitions";
+import { rowHash } from "./verify";
 import { cutoverOf, observe, serverNow, syncReplica, utcLiteral, waitOn, type RebuildRun } from "./steps";
 
 export interface BackfillResult {
@@ -62,6 +78,8 @@ export interface BackfillResult {
   skipped: number;
   /** Partitions this run found partly copied and cleared before copying again. */
   cleared: number;
+  /** Distinct rows at or after the cut-over found in the new table too often (copied while the view was writing them), deleted and copied again. */
+  repaired: number;
 }
 
 /** The effect a partition's copy is, and its receipt's address suffix. */
@@ -74,7 +92,15 @@ export function partitionExpectation(o: RebuildObservation, partition: string, c
     EffectReceipt(effect, {
       effect,
       flavor: "hash",
-      inputs: { table: o.names.key, newTable: o.newTable!.uuid, partition, copied: o.copied, cutover: cutover === undefined ? null : new Date(cutover).toISOString() },
+      inputs: {
+        table: o.names.key,
+        newTable: o.newTable!.uuid,
+        partition,
+        copied: o.copied,
+        cutover: cutover === undefined ? null : new Date(cutover).toISOString(),
+        // The rows at or after the cut-over the old table held are copied too (sql-yodeler#45); a receipt from before that copied fewer.
+        ...(cutover === undefined ? {} : { after: "difference" }),
+      },
     }),
   );
 }
@@ -88,7 +114,7 @@ export interface BackfillDeps {
 
 export async function backfill(run: RebuildRun, deps: BackfillDeps = {}): Promise<BackfillResult> {
   const o = await observe(run);
-  const result: BackfillResult = { state: o.state, partitions: 0, copied: 0, skipped: 0, cleared: 0 };
+  const result: BackfillResult = { state: o.state, partitions: 0, copied: 0, skipped: 0, cleared: 0, repaired: 0 };
   if (o.state !== "rebuild") return result;
   if (!o.newTable) throw new RebuildRefusal(`${o.names.key}: the new table is not there yet; the Create phase makes it`);
   const n = o.names;
@@ -113,6 +139,7 @@ export async function backfill(run: RebuildRun, deps: BackfillDeps = {}): Promis
   const fromOld = sourcePartitionExpression(o.live.partitionKey, o.newTable.partitionKey, o.copied);
   const columns = o.copied.map((c) => ident(c.name)).join(", ");
   const select = o.copied.map((c) => ident(c.source)).join(", ");
+  const later = cutColumn && cutover !== undefined ? await laterRowsCopy(run, o, cutColumn, cutover, fromOld) : undefined;
 
   const identity = { ...(run.marker?.stack ? { stack: run.marker.stack } : {}), ...(run.marker?.env ? { env: run.marker.env } : {}) };
   const receipts =
@@ -137,17 +164,19 @@ export async function backfill(run: RebuildRun, deps: BackfillDeps = {}): Promis
     }
 
     const queryId = `chant-rebuild-${o.newTable.uuid}-${p}`;
+    const laterQueryId = `${queryId}-after`;
+    const killWhere = `query_id IN (${sqlString(queryId)}, ${sqlString(laterQueryId)})`;
     if (o.replicated) {
       // On every replica that answers: the copy may be running on another one
       // than this run's. A replica that is down is skipped once Keeper sees it
       // inactive; nothing of its can be running a copy that still writes,
       // and a part it wrote before going down is waited for by the sync below.
-      await clickhouseQuery(run.target.endpoint, `KILL QUERY ON CLUSTER ${sqlString(n.database)} WHERE query_id = ${sqlString(queryId)} SYNC`, {
+      await clickhouseQuery(run.target.endpoint, `KILL QUERY ON CLUSTER ${sqlString(n.database)} WHERE ${killWhere} SYNC`, {
         settings: DDL_SETTINGS,
       });
       await syncReplica(run, o, n.database, n.newName);
     } else {
-      await clickhouseQuery(run.target.endpoint, `KILL QUERY WHERE query_id = ${sqlString(queryId)} SYNC`);
+      await clickhouseQuery(run.target.endpoint, `KILL QUERY WHERE ${killWhere} SYNC`);
     }
     const mine = `${fromOld} = ${sqlString(p)}${targetRange}`;
     const [left] = await clickhouseQuery<{ n: string | number }>(run.target.endpoint, `SELECT count() AS n FROM ${n.newTable} WHERE ${mine}`);
@@ -163,15 +192,107 @@ export async function backfill(run: RebuildRun, deps: BackfillDeps = {}): Promis
     const sql = `INSERT INTO ${n.newTable} (${columns}) SELECT ${select} FROM ${n.table} WHERE _partition_id = ${sqlString(p)}${sourceRange}`;
     run.log(sql);
     await clickhouseQuery(run.target.endpoint, sql, { queryId, settings: { async_insert: "0", insert_deduplicate: "0" }, ...(run.signal ? { signal: run.signal } : {}) });
+    if (later) result.repaired += await copyAfterCutover(run, o, later, p, laterQueryId);
     // The receipt, last, on success only.
     await receipts.write({ name: effect, effect, flavor: "hash", inputs: {} }, expectation);
     result.copied++;
     await deps.afterPartition?.(p);
   }
-  run.log(`-- backfill of ${n.key}: ${result.partitions} partition(s), ${result.copied} copied, ${result.skipped} already copied, ${result.cleared} cleared first`);
+  run.log(`-- backfill of ${n.key}: ${result.partitions} partition(s), ${result.copied} copied, ${result.skipped} already copied, ${result.cleared} cleared first${result.repaired > 0 ? `, ${result.repaired} row(s) after the cut-over copied twice and repaired` : ""}`);
   return result;
 }
 
+/** The statements that copy one old partition's rows at or after the cut-over. */
+interface LaterRows {
+  /**
+   * Per distinct row (by its hash), the old table's copies past the number
+   * the new table holds, into the new table.
+   */
+  copy: (partition: string) => string;
+  /** The hashes of the rows the new table holds more copies of than the old one. */
+  extras: (partition: string) => string;
+  /** Delete every copy of those rows from the new table. */
+  drop: (partition: string, hashes: readonly string[]) => string;
+}
+
+/** The most extra rows one partition's repair deletes and copies again; past that the verification decides. */
+const REPAIR_LIMIT = 1000;
+const REPAIR_ROUNDS = 3;
+
+/**
+ * The statements for the rows at or after the cut-over. The old side casts
+ * each column to its type in the new table before hashing, as the
+ * verification does, so a row and its copy hash the same.
+ */
+async function laterRowsCopy(
+  run: RebuildRun,
+  o: RebuildObservation,
+  cut: RebuildObservation["copied"][number],
+  cutover: number,
+  fromOld: string,
+): Promise<LaterRows> {
+  const n = o.names;
+  const types = new Map(
+    (
+      await clickhouseQuery<{ name: string; type: string }>(
+        run.target.endpoint,
+        `SELECT name, type FROM system.columns WHERE database = ${sqlString(n.database)} AND table = ${sqlString(n.newName)}`,
+      )
+    ).map((c) => [c.name, c.type]),
+  );
+  const oldHash = rowHash(o.copied.map((c) => `CAST(${ident(c.source)}, ${sqlString(types.get(c.name) ?? "String")})`));
+  const newHash = rowHash(o.copied.map((c) => ident(c.name)));
+  const columns = o.copied.map((c) => ident(c.name)).join(", ");
+  const aliases = o.copied.map((_, i) => `__chant_c${i}`);
+  const fromOldSide = o.copied.map((c, i) => `${ident(c.source)} AS ${aliases[i]}`).join(", ");
+  const oldRows = (p: string) => `FROM ${n.table} WHERE _partition_id = ${sqlString(p)} AND ${ident(cut.source)} >= ${utcLiteral(cutover)}`;
+  const newRows = (p: string) => `FROM ${n.newTable} WHERE ${fromOld} = ${sqlString(p)} AND ${ident(cut.name)} >= ${utcLiteral(cutover)}`;
+  return {
+    copy: (p) =>
+      `INSERT INTO ${n.newTable} (${columns}) SELECT ${aliases.join(", ")} FROM (` +
+      `SELECT ${fromOldSide}, ${oldHash} AS __chant_h, row_number() OVER (PARTITION BY __chant_h) AS __chant_k ${oldRows(p)}` +
+      `) AS old_rows LEFT JOIN (SELECT ${newHash} AS __chant_h, count() AS __chant_n ${newRows(p)} GROUP BY __chant_h) AS new_rows ` +
+      `USING (__chant_h) WHERE __chant_k > ifNull(__chant_n, 0)`,
+    extras: (p) =>
+      `SELECT toString(__chant_h) AS h FROM (SELECT ${newHash} AS __chant_h, count() AS __chant_n ${newRows(p)} GROUP BY __chant_h) AS new_rows ` +
+      `LEFT JOIN (SELECT ${oldHash} AS __chant_h, count() AS __chant_o ${oldRows(p)} GROUP BY __chant_h) AS old_rows ` +
+      `USING (__chant_h) WHERE __chant_n > ifNull(__chant_o, 0) LIMIT ${REPAIR_LIMIT + 1}`,
+    drop: (p, hashes) => `ALTER TABLE ${n.newTable} DELETE WHERE ${fromOld} = ${sqlString(p)} AND ${ident(cut.name)} >= ${utcLiteral(cutover)} AND ${newHash} IN (${hashes.join(", ")})`,
+  };
+}
+
+/**
+ * Copy one old partition's rows at or after the cut-over that the new table
+ * lacks. A row the view had written to the old table but not yet to the new
+ * one when the copy read them is copied by both, and is then in the new
+ * table once too often: every copy of such a row is deleted from the new
+ * table and the difference copied again, a few rounds at most. What is left
+ * after that, the verification finds. Returns the rows repaired.
+ */
+async function copyAfterCutover(run: RebuildRun, o: RebuildObservation, later: LaterRows, p: string, queryId: string): Promise<number> {
+  const n = o.names;
+  const insert = async () => {
+    const sql = later.copy(p);
+    run.log(sql);
+    await clickhouseQuery(run.target.endpoint, sql, { queryId, settings: { async_insert: "0", insert_deduplicate: "0" }, ...(run.signal ? { signal: run.signal } : {}) });
+  };
+  await insert();
+  let repaired = 0;
+  for (let round = 0; round < REPAIR_ROUNDS; round++) {
+    await syncReplica(run, o, n.database, n.newName);
+    const extras = (await clickhouseQuery<{ h: string }>(run.target.endpoint, later.extras(p))).map((r) => r.h);
+    if (extras.length === 0 || extras.length > REPAIR_LIMIT) break;
+    run.log(`-- partition ${p}: ${extras.length} row(s) after the cut-over in the new table more often than in the old one; deleting them and copying again`);
+    const sql = later.drop(p, extras);
+    run.log(sql);
+    await clickhouseQuery(run.target.endpoint, sql);
+    await waitOn(run, n.database, n.newName);
+    repaired += extras.length;
+    await insert();
+  }
+  return repaired;
+}
+
 function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   return new Promise((resolve, reject) => {
     const t = setTimeout(resolve, ms);

package/src/clickhouse/rebuild/observe.ts

@@ -55,9 +55,10 @@ export type DualWrite =
       /**
        * A materialized view on the old table writes every row whose
        * `cutoverColumn` is at or after the cut-over into the new table; the
-       * backfill copies the rows before it. The cut-over is the server's time
-       * when the view is made plus `cutoverDelay` (default `1m`), and the
-       * backfill starts once it has passed. The column must be a time
+       * backfill copies the rows before it, and the rows at or after it that
+       * the table held before the view was made. The cut-over is the server's
+       * time when the view is made plus `cutoverDelay` (default `1m`), rounded
+       * up to a whole second, and the backfill starts once it has passed. The column must be a time
        * (`Date`, `DateTime`, `DateTime64`) that rows arrive in order of, give
        * or take the delay; a row that arrives later than that is caught by
        * the verification, which then fails the run.

package/src/clickhouse/rebuild/rebuild.e2e.test.ts

@@ -7,6 +7,9 @@
  *   table, keeps the old table, and drops it at the second gate.
  * - A failure: rows that land in the old table after the backfill fail the
  *   verification, and onFailure drops the new table.
+ * - Rows dated after the cut-over (sql-yodeler#45): the ones the table held
+ *   before the view are copied by the backfill, the ones written during the
+ *   rebuild arrive through the view, and the swap leaves none behind.
  * - An interrupted backfill: stopped after three partitions, then killed
  *   between a partition's INSERT and its receipt, then resumed: the receipts
  *   skip what was copied, the half-copied partition is cleared first, and the
@@ -174,7 +177,7 @@ describe.skipIf(!enabled)("a sorting-key change, rebuilt through its gates", ()
     expect(outcome(r, "RebuildState")).toBe("rebuild");
     expect(outcome(r, "VerifiedRows")).toBe(1600);
     expect(outcome(r, "VerifiedPartitions")).toBe(4);
-    expect(String(outcome(r, "Verification"))).toMatch(/4 partition\(s\), 1600 row\(s\) before the cut-over/);
+    expect(String(outcome(r, "Verification"))).toMatch(/4 partition\(s\), 1600 row\(s\) \(1600 of them before the cut-over/);
     expect(await count("shop.events__chant_new")).toBe(1600);
     expect(await exists("shop", "events__chant_dual")).toBe(true);
     // Nothing visible to a plan or an apply: the working objects are left out.
@@ -235,6 +238,108 @@ describe.skipIf(!enabled)("a sorting-key change, rebuilt through its gates", ()
   }, 300_000);
 });
 
+describe.skipIf(!enabled)("rows dated after the cut-over that the table already held (sql-yodeler#45)", () => {
+  const bookingsDdl = (orderBy: string) => `CREATE TABLE shop.bookings
+(
+  id UInt64,
+  kind LowCardinality(String),
+  at DateTime
+)
+ENGINE = MergeTree
+PARTITION BY toYYYYMM(at)
+ORDER BY ${orderBy}`;
+  const V1: Obj = { export: "bookings", type: "ClickHouse::Table", dependsOn: ["shop"], ddl: bookingsDdl("(kind, at)") };
+  const V2: Obj = { ...V1, ddl: bookingsDdl("(kind, id)") };
+  const config = (): ClickHouseRebuildOpConfig => ({
+    name: "rebuild-bookings",
+    env: "e2e",
+    table: "shop.bookings",
+    dualWrite: { mode: "materialized-view", cutoverColumn: "at", cutoverDelay: "2s" },
+    build: false,
+    path: dir,
+    output: "bookings-v2.json",
+    retain: "0s",
+    stack: MARKER.stack,
+    ownershipEnv: MARKER.env,
+  });
+
+  test("every row is copied and compared, those written during the rebuild too, and the swap leaves none behind", async () => {
+    await clickhouseApply({ buildPath: join(dir, writeBuild("bookings-v1.json", [DB, V1])), environment: "e2e" }, undefined, deps());
+    // 600 rows seven hours apart, from four months ago to about two months
+    // ahead, with an identical pair among the future ones.
+    await q(
+      "INSERT INTO shop.bookings SELECT number, ['view','cart','buy'][number % 3 + 1], toStartOfHour(now()) - toIntervalDay(120) + toIntervalHour(number * 7) FROM numbers(600)",
+    );
+    await q("INSERT INTO shop.bookings VALUES (599, 'buy', toStartOfHour(now()) - toIntervalDay(120) + toIntervalHour(599 * 7))");
+    const future = Number((await q<{ n: string }>("SELECT count() AS n FROM shop.bookings WHERE at > now() + 60"))[0]!.n);
+    expect(future).toBeGreaterThan(150);
+    writeBuild("bookings-v2.json", [DB, V2]);
+
+    const ledger = new Ledger();
+    const first = await runOp(config(), ledger.port);
+    expect(first.status).toBe("gated");
+    expect(first.gate).toMatchObject({ gate: "approve-rebuild-bookings" });
+    expect(outcome(first, "VerifiedRows")).toBe(601);
+    expect(await count("shop.bookings__chant_new")).toBe(601);
+
+    // Written during the rebuild, after the cut-over: through the view.
+    await q("INSERT INTO shop.bookings VALUES (1000, 'buy', now() + toIntervalDay(40)), (1001, 'cart', now())");
+    const again = await runOp(config(), ledger.port);
+    expect(again.status).toBe("gated");
+    expect(outcome(again, "VerifiedRows")).toBe(603);
+    // The rows before the cut-over are what the approval binds; later rows do not change it.
+    expect(again.gate!.planDigest).toBe(first.gate!.planDigest);
+
+    ledger.approveLast();
+    await q("INSERT INTO shop.bookings VALUES (1002, 'view', now() + toIntervalDay(70))");
+    const swapped = await runOp(config(), ledger.port);
+    expect(swapped.status).toBe("gated");
+    expect(swapped.gate).toMatchObject({ gate: "approve-rebuild-bookings-drop" });
+    expect(await showCreate("shop.bookings")).toMatch(/ORDER BY \(kind, id\)/);
+    expect(await count("shop.bookings")).toBe(604);
+    expect(await count("shop.bookings__chant_old")).toBe(604);
+    const diff = await q("SELECT * FROM shop.bookings__chant_old EXCEPT ALL SELECT * FROM shop.bookings");
+    expect(diff).toEqual([]);
+  }, 300_000);
+
+  test("a row that reaches the old table alone after the verification stops the swap", async () => {
+    const clicksDdl = (orderBy: string) => `CREATE TABLE shop.visits
+(
+  id UInt64,
+  at DateTime
+)
+ENGINE = MergeTree
+PARTITION BY toYYYYMM(at)
+ORDER BY ${orderBy}`;
+    const W1: Obj = { export: "visits", type: "ClickHouse::Table", dependsOn: ["shop"], ddl: clicksDdl("at") };
+    const W2: Obj = { ...W1, ddl: clicksDdl("(id, at)") };
+    await clickhouseApply({ buildPath: join(dir, writeBuild("visits-v1.json", [DB, W1])), environment: "e2e" }, undefined, deps());
+    await q("INSERT INTO shop.visits SELECT number, now() - toIntervalDay(number % 90) FROM numbers(300)");
+    writeBuild("visits-v2.json", [DB, W2]);
+    const args = {
+      table: "shop.visits",
+      buildPath: "visits-v2.json",
+      environment: "e2e",
+      dualWrite: { mode: "materialized-view" as const, cutoverColumn: "at", cutoverDelay: "2s" },
+      stack: MARKER.stack,
+      ownershipEnv: MARKER.env,
+      cwd: dir,
+    };
+    await rebuildActivities.clickhouseRebuildCreate(args, undefined, deps());
+    await rebuildActivities.clickhouseRebuildDualWrite(args, undefined, deps());
+    await rebuildActivities.clickhouseRebuildBackfill(args, undefined, deps());
+    expect(await rebuildActivities.clickhouseRebuildVerify(args, undefined, deps())).toMatchObject({ rows: 300 });
+
+    // Late: a time well before the cut-over, written after the verification.
+    await q("INSERT INTO shop.visits VALUES (9999, now() - toIntervalDay(30))");
+    await expect(rebuildActivities.clickhouseRebuildSwap(args, undefined, deps())).rejects.toThrow(/does not match the old one in 1 partition/);
+    expect(await showCreate("shop.visits")).toMatch(/ORDER BY at/);
+    expect(await count("shop.visits")).toBe(301);
+    expect(await count("shop.visits__chant_new")).toBe(300);
+    await rebuildActivities.clickhouseRebuildCompensate(args, undefined, deps());
+  }, 300_000);
+});
+
 describe.skipIf(!enabled)("a failure runs onFailure, which drops the new table", () => {
   const clicksDdl = (orderBy: string) => `CREATE TABLE shop.clicks (id UInt64, url String) ENGINE = MergeTree ORDER BY ${orderBy}`;
   const V1: Obj = { export: "clicks", type: "ClickHouse::Table", dependsOn: ["shop"], ddl: clicksDdl("id") };

package/src/clickhouse/rebuild/steps.ts

@@ -16,6 +16,7 @@ import { createStatement, ident, qualifiedIdent, renamedDeclaration, sqlString,
 import { waitForMutations } from "../apply/mutations";
 import { renderFor } from "../topology";
 import { DDL_SETTINGS, syncReplicaWithin } from "./replicas";
+import { assertSameRows } from "./verify";
 import {
   changesBetween,
   observeRebuild,
@@ -155,7 +156,8 @@ export interface DualWriteResult {
  * old table that writes every row at or after the cut-over into the new
  * table. The cut-over is the server's time now plus the delay, kept in the
  * view's own comment (`cutover=`), so a later run and the backfill read it
- * back from the server. App mode creates nothing; its gate is the Op's.
+ * back from the server. The rows at or after the cut-over that the old table
+ * already held are the backfill's (`./backfill.ts`). App mode creates nothing; its gate is the Op's.
  */
 export async function startDualWrite(run: RebuildRun): Promise<DualWriteResult> {
   const o = await observe(run);
@@ -172,7 +174,10 @@ export async function startDualWrite(run: RebuildRun): Promise<DualWriteResult>
         `(copied: ${o.copied.map((c) => c.name).join(", ")})`,
     );
   }
-  const cutover = (await serverNow(run.target)) + parseDuration(run.dualWrite.cutoverDelay ?? "1m");
+  // On a whole second: a DateTime column holds whole seconds, and a row written
+  // during the cut-over's second would otherwise carry a time before it and
+  // reach the old table after the backfill has started.
+  const cutover = Math.ceil(((await serverNow(run.target)) + parseDuration(run.dualWrite.cutoverDelay ?? "1m")) / 1000) * 1000;
   const iso = new Date(cutover).toISOString();
   const select = o.copied.map((c) => (c.source === c.name ? ident(c.name) : `${ident(c.source)} AS ${ident(c.name)}`)).join(", ");
   const comment = stampedComment(`chant rebuild of ${o.names.key}: rows at or after the cut-over`, run.marker, working(o.names.key, "dual", { cutover: iso }));
@@ -205,8 +210,9 @@ export interface SwapResult {
 }
 
 /**
- * Swap the new table in: `EXCHANGE TABLES`, then drop the dual-write view,
- * rename the old table (now under the new table's name) to `t__chant_old`
+ * Swap the new table in: compare every row of the two tables once more, as
+ * the verification does, and stop on any difference; then `EXCHANGE TABLES`,
+ * drop the dual-write view, rename the old table (now under the new table's name) to `t__chant_old`
  * with its retention date, recreate the materialized views that read the
  * table, and stamp the table's own comment as declared.
  *
@@ -238,6 +244,10 @@ export async function swapTables(run: RebuildRun): Promise<SwapResult> {
   }
   if (!o.exchanged) {
     if (!o.newTable) throw new RebuildRefusal(`${n.key}: there is no new table to swap in`);
+    // The new table holds every row the old one does, or nothing is swapped
+    // (sql-yodeler#45): rows that reached the old table alone since the
+    // verification would stay behind in it.
+    await assertSameRows(run, o);
     await q(run, `EXCHANGE TABLES ${n.table} AND ${n.newTable}`);
   }
   // The dual-write view now reads the new table by name; drop it before

package/src/clickhouse/rebuild/verify.ts

@@ -1,20 +1,36 @@
 /**
- * The verification (#3198): row counts and checksums per partition, the old
- * table against the new one, before anyone is asked to approve the swap.
+ * The verification (#3198, INTENTIUS/sql-yodeler#45): row counts and
+ * checksums per partition, the old table against the new one, before anyone
+ * is asked to approve the swap.
  *
  * Per partition of the old table: the number of rows and the sum of a
  * 64-bit hash of each row's copied columns, read in one grouped query on
  * each side. The old side casts each column to its type in the new table
  * first, so a column whose type the rebuild changes hashes the same when
- * its values survived the change. In materialized-view mode both sides are
- * limited to the rows before the cut-over, which are the backfill's; the
- * rows after it were written by the dual-write view and keep arriving.
+ * its values survived the change.
+ *
+ * Every row is compared, in both modes. In materialized-view mode the rows
+ * at or after the cut-over are in the new table twice over: those the old
+ * table held before the view existed, which the backfill copies, and those
+ * written since, which the view writes. Comparing only the rows before the
+ * cut-over let a swap go ahead without the first kind (sql-yodeler#45).
+ * Writes go on while the tables are read, and a row the old table has
+ * committed may be a moment from committing in the new one through the view,
+ * so the old table is read first and a difference is read again a few times
+ * before it counts.
+ *
+ * The same comparison runs again in the Swap step just before the
+ * `EXCHANGE`, so rows that reach the old table alone after this step (a row
+ * later than the cut-over delay, with a time before the cut-over) stop the
+ * swap too, rather than stay behind in the old table.
  *
  * Any difference fails the run, naming the partitions; the run's onFailure
  * then drops the new table. On a match the result carries the digest the
- * swap gate binds: the rebuild's plan and the verification together, so an
- * approval is for this plan with these counts, and a changed count needs a
- * new approval.
+ * swap gate binds: the rebuild's plan and the counts and checksums of the
+ * rows before the cut-over, which no later write changes, so an approval
+ * is for this plan with these counts, and a changed count needs a new
+ * approval. The rows at or after the cut-over keep arriving through the view
+ * and are compared, not bound.
  */
 
 import { computePlanDigest } from "@intentius/chant/op";
@@ -34,10 +50,13 @@ export interface VerifyResult {
   state: RebuildObservation["state"];
   /** The digest the swap gate binds: plan plus verification. Absent once the swap has run: there is nothing left for that gate to approve. */
   planDigest?: string;
+  /** Partitions of the old table compared. */
   partitions: number;
+  /** Rows compared: every row of the old table. */
   rows: number;
   /** One line for the run record and the gate. */
   summary: string;
+  /** Per partition, the rows before the cut-over (every row in app mode): what the swap gate binds. */
   verification: PartitionCheck[];
 }
 
@@ -45,7 +64,7 @@ export interface VerifyResult {
 export class RebuildVerificationError extends Error {
   constructor(
     readonly table: string,
-    readonly mismatches: Array<{ partition: string; old?: PartitionCheck; new?: PartitionCheck }>,
+    readonly mismatches: Mismatch[],
   ) {
     const shown = mismatches
       .slice(0, 10)
@@ -53,23 +72,38 @@ export class RebuildVerificationError extends Error {
       .join("; ");
     super(
       `${table}: the new table does not match the old one in ${mismatches.length} partition(s): ${shown}${mismatches.length > 10 ? "; ..." : ""}. ` +
-        `Nothing was swapped. In materialized-view mode a row written to the old table later than the cut-over delay, with a time before the cut-over, is the usual cause.`,
+        `Nothing was swapped. In materialized-view mode a row written to the old table later than the cut-over delay, with a time before the cut-over, is the usual cause; ` +
+        `in app mode, a write the application did not stop.`,
     );
     this.name = "RebuildVerificationError";
   }
 }
 
-export async function verifyRebuild(run: RebuildRun): Promise<VerifyResult> {
-  const o = await observe(run);
-  if (o.state !== "rebuild") return { state: o.state, partitions: 0, rows: 0, verification: [], summary: `nothing to verify: ${o.state}` };
+/** How often a difference is read again before it counts, and how long apart. */
+const COMPARE_ATTEMPTS = 5;
+const COMPARE_INTERVAL_MS = 1000;
+
+/** One side's counts per old partition: every row, and the rows before the cut-over. */
+interface SideCounts {
+  all: Map<string, PartitionCheck>;
+  before: Map<string, PartitionCheck>;
+}
+
+/**
+ * Read both tables' counts and checksums per old partition, the old table
+ * first, until they agree or `attempts` reads have disagreed. Returns the
+ * last read and the partitions that differ in it.
+ */
+async function compareTables(
+  run: RebuildRun,
+  o: RebuildObservation,
+  opts: { attempts?: number; intervalMs?: number } = {},
+): Promise<{ old: SideCounts; new: SideCounts; mismatches: Mismatch[] }> {
   if (!o.newTable) throw new RebuildRefusal(`${o.names.key}: the new table is not there yet; the Create phase makes it`);
   const n = o.names;
   const cutover = cutoverOf(run, o);
   await waitOn(run, n.database, n.name);
   await waitOn(run, n.database, n.newName);
-  // In a Replicated database: count what every replica wrote, not what this one has fetched so far.
-  await syncReplica(run, o, n.database, n.name);
-  await syncReplica(run, o, n.database, n.newName);
 
   const types = new Map(
     (
@@ -79,35 +113,81 @@ export async function verifyRebuild(run: RebuildRun): Promise<VerifyResult> {
       )
     ).map((c) => [c.name, c.type]),
   );
-  const oldHash = `sum(cityHash64(toString(tuple(${o.copied.map((c) => `CAST(${ident(c.source)}, ${sqlString(types.get(c.name) ?? "String")})`).join(", ")}))))`;
-  const newHash = `sum(cityHash64(toString(tuple(${o.copied.map((c) => ident(c.name)).join(", ")}))))`;
+  const oldHash = rowHash(o.copied.map((c) => `CAST(${ident(c.source)}, ${sqlString(types.get(c.name) ?? "String")})`));
+  const newHash = rowHash(o.copied.map((c) => ident(c.name)));
   const cut = run.dualWrite.mode === "materialized-view" ? o.copied.find((c) => c.name === (run.dualWrite as { cutoverColumn: string }).cutoverColumn) : undefined;
-  const oldWhere = cut && cutover !== undefined ? ` WHERE ${ident(cut.source)} < ${utcLiteral(cutover)}` : "";
-  const newWhere = cut && cutover !== undefined ? ` WHERE ${ident(cut.name)} < ${utcLiteral(cutover)}` : "";
+  const oldBefore = cut && cutover !== undefined ? `${ident(cut.source)} < ${utcLiteral(cutover)}` : "1";
+  const newBefore = cut && cutover !== undefined ? `${ident(cut.name)} < ${utcLiteral(cutover)}` : "1";
   const fromOld = sourcePartitionExpression(o.live.partitionKey, o.newTable.partitionKey, o.copied);
 
-  const read = async (sql: string) =>
-    new Map(
-      (await clickhouseQuery<{ p: string; rows: string | number; checksum: string }>(run.target.endpoint, sql)).map((r) => [
-        r.p,
-        { partition: r.p, rows: Number(r.rows), checksum: r.checksum },
-      ]),
+  const read = async (table: string, partition: string, hash: string, before: string): Promise<SideCounts> => {
+    const rows = await clickhouseQuery<{ p: string; rows: string | number; checksum: string; brows: string | number; bchecksum: string }>(
+      run.target.endpoint,
+      `SELECT ${partition} AS p, count() AS rows, toString(sum(${hash})) AS checksum, countIf(${before}) AS brows, toString(sumIf(${hash}, ${before})) AS bchecksum ` +
+        `FROM ${table} GROUP BY p`,
     );
-  const before = await read(`SELECT _partition_id AS p, count() AS rows, toString(${oldHash}) AS checksum FROM ${n.table}${oldWhere} GROUP BY p`);
-  const after = await read(`SELECT ${fromOld} AS p, count() AS rows, toString(${newHash}) AS checksum FROM ${n.newTable}${newWhere} GROUP BY p`);
+    const side: SideCounts = { all: new Map(), before: new Map() };
+    for (const r of rows) {
+      side.all.set(r.p, { partition: r.p, rows: Number(r.rows), checksum: r.checksum });
+      // A partition with no row before the cut-over is left out, as a WHERE would leave it out.
+      if (Number(r.brows) > 0) side.before.set(r.p, { partition: r.p, rows: Number(r.brows), checksum: r.bchecksum });
+    }
+    return side;
+  };
+
+  const attempts = Math.max(1, opts.attempts ?? COMPARE_ATTEMPTS);
+  for (let attempt = 1; ; attempt++) {
+    // In a Replicated database: count what every replica wrote, not what this one has fetched so far.
+    await syncReplica(run, o, n.database, n.name);
+    await syncReplica(run, o, n.database, n.newName);
+    // The old table first: a row the view has yet to commit in the new one is read as missing there, never the other way round.
+    const before = await read(n.table, "_partition_id", oldHash, oldBefore);
+    const after = await read(n.newTable, fromOld, newHash, newBefore);
+    const mismatches = differences(before.all, after.all);
+    if (mismatches.length === 0 || attempt >= attempts) return { old: before, new: after, mismatches };
+    run.log(`-- ${n.key}: ${mismatches.length} partition(s) differ (${mismatches.map((m) => m.partition).slice(0, 5).join(", ")}); reading again (${attempt}/${attempts})`);
+    await sleep(opts.intervalMs ?? COMPARE_INTERVAL_MS, run.signal);
+  }
+}
+
+export type Mismatch = { partition: string; old?: PartitionCheck; new?: PartitionCheck };
 
-  const mismatches: Array<{ partition: string; old?: PartitionCheck; new?: PartitionCheck }> = [];
+function differences(before: Map<string, PartitionCheck>, after: Map<string, PartitionCheck>): Mismatch[] {
+  const out: Mismatch[] = [];
   for (const p of [...new Set([...before.keys(), ...after.keys()])].sort()) {
     const a = before.get(p);
     const b = after.get(p);
-    if (!a || !b || a.rows !== b.rows || a.checksum !== b.checksum) mismatches.push({ partition: p, ...(a ? { old: a } : {}), ...(b ? { new: b } : {}) });
+    if (!a || !b || a.rows !== b.rows || a.checksum !== b.checksum) out.push({ partition: p, ...(a ? { old: a } : {}), ...(b ? { new: b } : {}) });
   }
-  if (mismatches.length > 0) throw new RebuildVerificationError(n.key, mismatches);
+  return out;
+}
+
+/** The 64-bit hash of a row's copied columns, as the backfill and the verification compute it. */
+export const rowHash = (columns: readonly string[]): string => `cityHash64(toString(tuple(${columns.join(", ")})))`;
+
+/**
+ * Before the swap: the new table holds every row the old one does. Throws a
+ * {@link RebuildVerificationError} when it does not, so nothing is swapped.
+ */
+export async function assertSameRows(run: RebuildRun, o: RebuildObservation): Promise<void> {
+  const { mismatches } = await compareTables(run, o);
+  if (mismatches.length > 0) throw new RebuildVerificationError(o.names.key, mismatches);
+}
+
+export async function verifyRebuild(run: RebuildRun): Promise<VerifyResult> {
+  const o = await observe(run);
+  if (o.state !== "rebuild") return { state: o.state, partitions: 0, rows: 0, verification: [], summary: `nothing to verify: ${o.state}` };
+  const cutover = cutoverOf(run, o);
+  const compared = await compareTables(run, o);
+  if (compared.mismatches.length > 0) throw new RebuildVerificationError(o.names.key, compared.mismatches);
 
-  const verification = [...before.values()].sort((x, y) => x.partition.localeCompare(y.partition));
-  const rows = verification.reduce((s, v) => s + v.rows, 0);
-  const range = cutover !== undefined ? ` before the cut-over at ${new Date(cutover).toISOString()}` : "";
-  const summary = `${n.key}: ${verification.length} partition(s), ${rows} row(s)${range}, counts and checksums equal in the old and new tables`;
+  const all = [...compared.old.all.values()];
+  const rows = all.reduce((s, v) => s + v.rows, 0);
+  // What the approval binds: the rows before the cut-over (every row in app mode), which later writes do not change.
+  const verification = [...compared.old.before.values()].sort((x, y) => x.partition.localeCompare(y.partition));
+  const bound = verification.reduce((s, v) => s + v.rows, 0);
+  const range = cutover !== undefined ? ` (${bound} of them before the cut-over at ${new Date(cutover).toISOString()})` : "";
+  const summary = `${o.names.key}: ${all.length} partition(s), ${rows} row(s)${range}, counts and checksums equal in the old and new tables`;
   run.log(`-- ${summary}`);
   return {
     state: o.state,
@@ -116,9 +196,24 @@ export async function verifyRebuild(run: RebuildRun): Promise<VerifyResult> {
       cutover: cutover === undefined ? null : new Date(cutover).toISOString(),
       verification,
     }),
-    partitions: verification.length,
+    partitions: all.length,
     rows,
     summary,
     verification,
   };
 }
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    signal?.throwIfAborted();
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        reject(signal.reason);
+      },
+      { once: true },
+    );
+  });
+}

package/src/postgres/plan/deep.test.ts

@@ -0,0 +1,76 @@
+/**
+ * The Postgres deep reader's columns (INTENTIUS/sql-yodeler#47): matched by
+ * name, not by position, because Postgres keeps a table's columns in the
+ * order they were added and a column renamed by expand and contract is last
+ * on the server.
+ */
+
+import { describe, expect, test } from "vitest";
+import * as pg from "../entities";
+import { POSTGRES_ENTITY_TYPES } from "../entity-types";
+import type { LivePgObject } from "../live/catalog";
+import { inDeclaredVocabulary, liveProps } from "./deep";
+import { canonicalPgObject } from "./normalize";
+
+type Props = Record<string, unknown>;
+
+const declared = (pg.table`
+  CREATE TABLE shop.orders (
+      id bigint GENERATED ALWAYS AS IDENTITY,
+      email text NOT NULL, -- previously: customer_email
+      status text DEFAULT 'placed'::text NOT NULL,
+      amount numeric(12,2) NOT NULL,
+      refunded_at timestamp with time zone,
+      CONSTRAINT orders_pkey PRIMARY KEY (id)
+  )` as unknown as { props: Props }).props;
+
+/** What the deep reader makes of the server's definition of the table. */
+function observe(statement: string): Props {
+  const o = { type: POSTGRES_ENTITY_TYPES.table, schema: "shop", name: "orders", oid: "1", statement } as unknown as LivePgObject;
+  const live = liveProps(o);
+  return inDeclaredVocabulary(declared, live, canonicalPgObject(POSTGRES_ENTITY_TYPES.table, declared), canonicalPgObject(POSTGRES_ENTITY_TYPES.table, live));
+}
+
+const names = (p: Props) => (p.columns as Array<{ name: string }>).map((c) => c.name);
+
+describe("Postgres deep observation of a table's columns", () => {
+  test("a column the server holds last and the declaration earlier is not drift", () => {
+    const props = observe(`CREATE TABLE shop.orders (
+    id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+    status text DEFAULT 'placed'::text NOT NULL,
+    amount numeric(12,2) NOT NULL,
+    refunded_at timestamp with time zone,
+    email text NOT NULL,
+    CONSTRAINT orders_pkey PRIMARY KEY (id)
+)`);
+    expect(props.columns).toEqual(declared.columns);
+  });
+
+  test("a column that differs is reported at its declared place, and an undeclared one comes after the declared ones", () => {
+    const props = observe(`CREATE TABLE shop.orders (
+    id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+    note text,
+    status text DEFAULT 'placed'::text NOT NULL,
+    amount numeric(12,2) NOT NULL,
+    refunded_at timestamp with time zone,
+    email character varying(200) NOT NULL,
+    CONSTRAINT orders_pkey PRIMARY KEY (id)
+)`);
+    expect(names(props)).toEqual(["id", "email", "status", "amount", "refunded_at", "note"]);
+    const columns = props.columns as Props[];
+    const declaredColumns = declared.columns as Props[];
+    expect(columns[1]).not.toEqual(declaredColumns[1]);
+    expect(columns.slice(2, 5)).toEqual(declaredColumns.slice(2, 5));
+  });
+
+  test("a declared column the server does not have leaves the others matched by name", () => {
+    const props = observe(`CREATE TABLE shop.orders (
+    id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+    status text DEFAULT 'placed'::text NOT NULL,
+    amount numeric(12,2) NOT NULL,
+    email text NOT NULL,
+    CONSTRAINT orders_pkey PRIMARY KEY (id)
+)`);
+    expect(names(props)).toEqual(["id", "email", "status", "amount"]);
+  });
+});

package/src/postgres/plan/deep.ts

@@ -108,11 +108,22 @@ export function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalP
   if (d.kind === "table") {
     const declaredColumns = (declared.columns as unknown[] | undefined) ?? [];
     const liveColumns = (live.columns as unknown[] | undefined) ?? [];
-    out.columns = liveColumns.map((c, i) => {
+    // Columns are matched by name and listed in the declaration's order, the
+    // live columns the declaration does not name after them. Postgres keeps a
+    // table's columns in the order they were added, and no ALTER moves one: a
+    // column renamed by expand and contract is last on the server and where
+    // the old one was in the declaration (INTENTIUS/sql-yodeler#47). The plan
+    // compares columns by name too, so an order the server cannot be brought
+    // to is not drift.
+    const read = liveColumns.map((c, i) => {
       const lc = l.columns[i];
       const dc = lc ? d.columns.find((x) => x.name === lc.name) : undefined;
-      return lc && dc && columnShape(lc) === columnShape(dc) ? declaredColumns[dc.position] : c;
+      return { at: dc?.position, value: lc && dc && columnShape(lc) === columnShape(dc) ? declaredColumns[dc.position] : c };
     });
+    out.columns = [
+      ...read.filter((c) => c.at !== undefined).sort((a, b) => a.at! - b.at!),
+      ...read.filter((c) => c.at === undefined),
+    ].map((c) => c.value);
   }
   if (d.kind === "table" || d.kind === "domain") {
     // A constraint the declaration says the same as the server is the declaration's (its name included or left out).

package/src/postgres/plan/plan.e2e.test.ts

@@ -91,6 +91,32 @@ describe.skipIf(!enabled)("planning the getting-started example against a server
     expect((await planPgAgainstServer("e2e", file, profile("star"))).changes.map((c) => `${c.field}: ${c.before} -> ${c.after}`)).toEqual([]);
   }, 600_000);
 
+  test("a column renamed by expand and contract, last on the server, plans and reads back with no drift (sql-yodeler#47)", async () => {
+    const admin = await server!.connect();
+    await admin.query("CREATE DATABASE renamed");
+    await admin.end();
+    const orders = pg.table`CREATE TABLE public.orders (
+      id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+      email text NOT NULL, -- previously: customer_email
+      status text DEFAULT 'placed'::text NOT NULL,
+      refunded_at timestamp with time zone
+    )`;
+    const out = sqlSerializer.serialize(new Map<string, unknown>([["orders", orders]]) as never) as SerializerResult;
+    const file = join(dir, "renamed.json");
+    writeFileSync(file, out.primary);
+    const client = await server!.connect("renamed");
+    await client.query(
+      "CREATE TABLE public.orders (id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, customer_email text NOT NULL, status text DEFAULT 'placed'::text NOT NULL, refunded_at timestamp with time zone);" +
+        "ALTER TABLE public.orders ADD COLUMN email text; UPDATE public.orders SET email = customer_email; ALTER TABLE public.orders ALTER COLUMN email SET NOT NULL; ALTER TABLE public.orders DROP COLUMN customer_email",
+    );
+    expect((await planPgAgainstServer("e2e", file, profile("renamed"))).changes).toEqual([]);
+
+    const props = (orders as unknown as { props: Record<string, unknown> }).props;
+    const deep = await observeResourcesDeep({ environment: "e2e", entityNames: ["orders"], entities: new Map([["orders", { entityType: "Postgres::Table", props }]]), ...profile("renamed") });
+    expect(deep.resources.orders!.properties.columns).toEqual(props.columns);
+    await client.end();
+  }, 600_000);
+
   test("a serial table plans with no changes after apply; serial to bigserial is integer to bigint, unqualified", async () => {
     const admin = await server!.connect();
     await admin.query("CREATE DATABASE serials");