@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/src/postgres/live/database-kinds.e2e.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Extended statistics, foreign data wrappers, foreign servers and
+ * publications against a live server (#3911): applied as declared, they plan
+ * with no change and read back with no drift; a definition changed in the
+ * declaration is altered in place (SQLPG303) or dropped and created
+ * (SQLPG300); an import writes each back as the declaration it came from,
+ * which plans with no change.
+ *
+ * The server: a throwaway one at the pin, skipped cleanly when Docker is not
+ * available. A foreign data wrapper takes a superuser, which the throwaway
+ * server's user is.
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable, startTestPostgres, type TestPostgres } from "../testing/server";
+import { connectPostgres, type PostgresClient, type PostgresEndpoint } from "./client";
+import { readLiveSchema } from "./catalog";
+import { planPgAgainstServer } from "../plan/commands";
+import { observeResourcesDeep, liveProps } from "../plan/deep";
+import { postgresApply } from "../../op/activities/postgres-apply";
+import { objectsToIR } from "../import/ir";
+import { PostgresGenerator, postgresTemplates } from "../import/generator";
+import { declaredObjects } from "../apply/apply";
+
+const SCHEMA = "chant_e2e_3911b";
+const enabled = await dockerAvailable();
+const dir = mkdtempSync(join(tmpdir(), "chant-pg-database-kinds-"));
+let server: TestPostgres | undefined;
+let endpoint: PostgresEndpoint;
+let admin: PostgresClient;
+
+beforeAll(async () => {
+  if (!enabled) return;
+  server = await startTestPostgres();
+  endpoint = server.endpoint();
+  admin = await connectPostgres(endpoint);
+}, 600_000);
+
+afterAll(async () => {
+  await admin?.end();
+  await server?.stop();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+interface Obj {
+  export: string;
+  type: string;
+  ddl: string;
+  dependsOn?: string[];
+}
+
+const MARKER = { stack: "e2e3911b", env: "test" };
+const profile = () => ({
+  config: { ownership: MARKER, sql: { profiles: { e2e: { url: endpoint.url, password: { env: "PG_E2E_PASSWORD" }, schemas: [SCHEMA] } } } },
+  env: { PG_E2E_PASSWORD: endpoint.password ?? "" },
+});
+
+function writeBuild(file: string, objects: Obj[]): string {
+  const path = join(dir, file);
+  writeFileSync(path, JSON.stringify({ dialect: "postgres", postgresMajor: 18, objects: objects.map((o) => ({ dependsOn: [], ...o })) }));
+  return path;
+}
+
+const apply = (path: string) => postgresApply({ buildPath: path, environment: "e2e" }, undefined, { ...profile(), log: () => undefined });
+const plan = (path: string) => planPgAgainstServer("e2e", path, profile());
+
+const S = SCHEMA;
+interface Version {
+  /** The statistics' kinds. */
+  kinds: string;
+  /** The wrapper's options. */
+  fdwOptions: string;
+  /** The server's version and options. */
+  server: string;
+  /** The publication's tables and options. */
+  publication: string;
+}
+
+const objects = (v: Version): Obj[] => [
+  { export: "app", type: "Postgres::Schema", ddl: `CREATE SCHEMA ${S}` },
+  { export: "orders", type: "Postgres::Table", dependsOn: ["app"], ddl: `CREATE TABLE ${S}.orders (id int PRIMARY KEY, user_id int, status text)` },
+  { export: "events", type: "Postgres::Table", dependsOn: ["app"], ddl: `CREATE TABLE ${S}.events (id int PRIMARY KEY)` },
+  { export: "ordersStats", type: "Postgres::Statistics", dependsOn: ["orders"], ddl: `CREATE STATISTICS ${S}.orders_stats ${v.kinds} ON user_id, status FROM ${S}.orders;\nCOMMENT ON STATISTICS ${S}.orders_stats IS 'Correlated'` },
+  { export: "appFdw", type: "Postgres::ForeignDataWrapper", ddl: `CREATE FOREIGN DATA WRAPPER app_fdw_3911 ${v.fdwOptions};\nCOMMENT ON FOREIGN DATA WRAPPER app_fdw_3911 IS 'Remote'` },
+  { export: "replica", type: "Postgres::ForeignServer", dependsOn: ["appFdw"], ddl: `CREATE SERVER replica_3911 ${v.server} FOREIGN DATA WRAPPER app_fdw_3911 OPTIONS (host 'db.internal');\nCOMMENT ON SERVER replica_3911 IS 'The replica'` },
+  { export: "pub", type: "Postgres::Publication", dependsOn: ["orders", "events"], ddl: `CREATE PUBLICATION pub_3911 ${v.publication};\nCOMMENT ON PUBLICATION pub_3911 IS 'Order changes'` },
+];
+
+const V1: Version = {
+  kinds: "(dependencies)",
+  fdwOptions: "OPTIONS (debug 'true')",
+  server: "TYPE 'pg' VERSION '16'",
+  publication: `FOR TABLE ${S}.orders WITH (publish = 'insert, update')`,
+};
+// Each kind changed: the statistics' kinds (drop and create), the wrapper's options, the server's version and the publication's tables and options (in place).
+const V2: Version = {
+  kinds: "(ndistinct)",
+  fdwOptions: "OPTIONS (debug 'false', trace 'on')",
+  server: "TYPE 'pg' VERSION '17'",
+  publication: `FOR TABLE ${S}.events WITH (publish = 'insert')`,
+};
+
+describe.skipIf(!enabled)("statistics, foreign servers and publications on a live server", () => {
+  test("apply, plan, drift, change and import", async () => {
+    const v1 = writeBuild("v1.json", objects(V1));
+    const first = await apply(v1);
+    expect(first.failed).toEqual([]);
+    expect(first.applied.map((a) => [a.name, a.action])).toEqual([
+      [S, "created"],
+      [`${S}.orders`, "created"],
+      [`${S}.events`, "created"],
+      [`${S}.orders_stats`, "created"],
+      ["app_fdw_3911", "created"],
+      ["replica_3911", "created"],
+      ["pub_3911", "created"],
+    ]);
+
+    // As declared: no change, and no drift.
+    expect((await plan(v1)).changes).toEqual([]);
+    const declared = declaredObjects(JSON.stringify({ dialect: "postgres", objects: objects(V1).map((o) => ({ dependsOn: [], ...o })) }));
+    const entities = new Map(declared.map((o) => [o.exportName, { entityType: o.type, props: o.props }]));
+    const deep = await observeResourcesDeep({ environment: "e2e", entityNames: [...entities.keys()], entities, ...profile() });
+    expect(deep.unobserved ?? {}).toEqual({});
+
+    // Changed by hand: drift, in the plan.
+    await admin.query(`ALTER SERVER replica_3911 OPTIONS (SET host 'elsewhere')`);
+    expect((await plan(v1)).changes.map((c) => [c.object, c.field, c.rule])).toEqual([["replica (replica_3911)", "options", "SQLPG303"]]);
+    await admin.query(`ALTER SERVER replica_3911 OPTIONS (SET host 'db.internal')`);
+
+    // Changed in the declaration: the statistics are dropped and created; the rest altered in place.
+    const v2 = writeBuild("v2.json", objects(V2));
+    const planned = await plan(v2);
+    expect(planned.changes.map((c) => [c.object, c.rule])).toEqual([
+      [`ordersStats (${S}.orders_stats)`, "SQLPG300"],
+      ["appFdw (app_fdw_3911)", "SQLPG303"],
+      ["replica (replica_3911)", "SQLPG303"],
+      ["pub (pub_3911)", "SQLPG303"],
+      ["pub (pub_3911)", "SQLPG303"],
+      ["pub (pub_3911)", "SQLPG303"],
+    ]);
+    expect(planned.refused).toEqual([]);
+    const second = await apply(v2);
+    expect(second.failed).toEqual([]);
+    expect((await plan(v2)).changes).toEqual([]);
+    expect((await admin.query<{ n: number }>(`SELECT count(*)::int AS n FROM pg_publication_rel r JOIN pg_publication p ON p.oid = r.prpubid WHERE p.pubname = 'pub_3911'`))[0]!.n).toBe(1);
+
+    // Import: the server's own printing, written back as declarations that parse and plan with no change.
+    const live = await readLiveSchema(admin, { schemas: [S] });
+    for (const o of live) liveProps(o);
+    const ir = objectsToIR(live.map((o) => ({ type: o.type, ...(o.schema ? { schema: o.schema } : {}), name: o.name, ddl: o.statement })));
+    const [file] = new PostgresGenerator().generate(ir);
+    expect(file!.content).toContain("export const ordersStats = statistics`");
+    expect(file!.content).toContain("export const appFdw3911 = foreignDataWrapper`");
+    expect(file!.content).toContain("FOREIGN DATA WRAPPER ${appFdw3911}");
+    expect(file!.content).toContain("export const pub3911 = publication`");
+    const items = ir.resources.map((r) => ({ exportName: r.logicalId, type: r.type, ...(r.properties.schema ? { schema: String(r.properties.schema) } : {}), name: String(r.properties.name), ddl: String(r.properties.ddl) }));
+    const { order } = postgresTemplates(items);
+    const imported = writeBuild("imported.json", order.map((it) => ({ export: it.exportName, type: it.type, ddl: it.ddl })));
+    expect((await plan(imported)).changes).toEqual([]);
+  }, 600_000);
+});

package/src/postgres/live/describe-resources.ts

@@ -34,6 +34,14 @@ interface Bound {
   byKey: Map<string, LivePgObject>;
 }
 
+/** The entity types that belong to the database, not a schema. */
+const UNPLACED: ReadonlySet<string> = new Set([
+  POSTGRES_ENTITY_TYPES.eventTrigger,
+  POSTGRES_ENTITY_TYPES.foreignDataWrapper,
+  POSTGRES_ENTITY_TYPES.foreignServer,
+  POSTGRES_ENTITY_TYPES.publication,
+]);
+
 /**
  * The schema and name a declared entity is created as; a bare name is in the
  * default schema. A routine's parameter types and a trigger's table tell it
@@ -41,7 +49,7 @@ interface Bound {
  */
 export function declaredAddress(entity: { type: string; props: Record<string, unknown> }, defaultSchema: string): { schema?: string; name: string; signature?: string } {
   const name = String(entity.props.name ?? "");
-  if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role || entity.type === POSTGRES_ENTITY_TYPES.eventTrigger) return { name };
+  if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role || UNPLACED.has(entity.type)) return { name };
   // A cast is named by its two types, as the catalog prints them.
   if (entity.type === POSTGRES_ENTITY_TYPES.cast) return { name: canonicalPgObject(entity.type, entity.props, defaultSchema).name };
   const schema = typeof entity.props.schema === "string" ? entity.props.schema : identValue(defaultSchema);
@@ -49,6 +57,9 @@ export function declaredAddress(entity: { type: string; props: Record<string, un
     entity.type === POSTGRES_ENTITY_TYPES.function ||
     entity.type === POSTGRES_ENTITY_TYPES.procedure ||
     entity.type === POSTGRES_ENTITY_TYPES.aggregate ||
+    entity.type === POSTGRES_ENTITY_TYPES.operator ||
+    entity.type === POSTGRES_ENTITY_TYPES.operatorClass ||
+    entity.type === POSTGRES_ENTITY_TYPES.operatorFamily ||
     entity.type === POSTGRES_ENTITY_TYPES.trigger ||
     entity.type === POSTGRES_ENTITY_TYPES.policy
   ) {
@@ -79,7 +90,7 @@ export function scopeFor(target: PostgresTarget, entities: ReadonlyArray<{ type:
   if (entities.length === 0) return undefined;
   const out = new Set<string>([target.defaultSchema]);
   // The schema alone: the rest of an address (a routine's parameter types) needs props a caller may not have.
-  const unplaced = new Set<string>([POSTGRES_ENTITY_TYPES.extension, POSTGRES_ENTITY_TYPES.role, POSTGRES_ENTITY_TYPES.cast, POSTGRES_ENTITY_TYPES.eventTrigger]);
+  const unplaced = new Set<string>([POSTGRES_ENTITY_TYPES.extension, POSTGRES_ENTITY_TYPES.role, POSTGRES_ENTITY_TYPES.cast, ...UNPLACED]);
   for (const e of entities) {
     if (e.type === POSTGRES_ENTITY_TYPES.schema) out.add(String(e.props.name ?? ""));
     else if (!unplaced.has(e.type)) out.add(typeof e.props.schema === "string" ? e.props.schema : identValue(target.defaultSchema));

package/src/postgres/live/undeclarable.e2e.test.ts

@@ -1,10 +1,12 @@
 /**
  * Import against a real Postgres server never leaves an object out without a
  * word (#3911): a database holding a rewrite rule, an encoding conversion, an
- * access method and a shell type beside a table fails the import, which
- * names all four; with `skipUndeclarable` the rest is imported and the four
- * are warnings. A composite type, an aggregate, a collation, a cast and an
- * event trigger are declared kinds, so they are imported, not refused. What
+ * access method, a shell type, a user mapping and a subscription (the last
+ * two carry credentials) beside a table fails the import, which names all
+ * six; with `skipUndeclarable` the rest is imported and the six are warnings.
+ * A composite type, an aggregate, a collation, a cast, an event trigger, a
+ * foreign data wrapper, a foreign server and a publication are declared
+ * kinds, so they are imported, not refused. What
  * an extension brings (hstore's casts and operators) is the extension's, and
  * is not refused.
  *
@@ -36,6 +38,11 @@ CREATE RULE users_notify AS ON INSERT TO app.users DO ALSO NOTIFY users;
 CREATE CONVERSION app.latin1_utf8 FOR 'LATIN1' TO 'UTF8' FROM iso8859_1_to_utf8;
 CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
 CREATE TYPE app.later;
+CREATE FOREIGN DATA WRAPPER app_fdw;
+CREATE SERVER app_remote FOREIGN DATA WRAPPER app_fdw OPTIONS (host 'db.internal');
+CREATE USER MAPPING FOR PUBLIC SERVER app_remote OPTIONS (user 'reader');
+CREATE PUBLICATION app_pub FOR TABLE app.users;
+CREATE SUBSCRIPTION app_sub CONNECTION 'host=127.0.0.1 dbname=elsewhere' PUBLICATION elsewhere WITH (connect = false);
 `;
 
 beforeAll(async () => {
@@ -58,7 +65,7 @@ const profile = () => ({
   env: { PG_UD_PASSWORD: server!.endpoint("source").password },
 });
 
-const NAMED = ["rule app.users_notify ON users", "conversion app.latin1_utf8", "access method heap2", "base type app.later"];
+const NAMED = ["rule app.users_notify ON users", "conversion app.latin1_utf8", "access method heap2", "base type app.later", "user mapping for public on server app_remote", "subscription app_sub"];
 
 describe.skipIf(!enabled)("importing a database with objects chant cannot declare", () => {
   test("fails, naming every one of them", async () => {
@@ -75,7 +82,7 @@ describe.skipIf(!enabled)("importing a database with objects chant cannot declar
   test("with skipUndeclarable, imports the rest and lists them as warnings", async () => {
     const ir = await exportResources({ environment: "src", skipUndeclarable: true, ...profile() });
     expect(ir.resources.map((r) => r.properties.name)).toEqual(
-      expect.arrayContaining(["users", "hstore", "add2", "pair_text", "on_ddl", "pair", "total", "ci", "(app.pair AS text)", "audit_ddl"]),
+      expect.arrayContaining(["users", "hstore", "add2", "pair_text", "on_ddl", "pair", "total", "ci", "(app.pair AS text)", "audit_ddl", "app_fdw", "app_remote", "app_pub"]),
     );
     const left = (ir.warnings ?? []).filter((w) => w.includes("is left out (--skip-undeclarable)"));
     expect(left.map((w) => w.split(" is left out")[0]).sort()).toEqual([...NAMED].sort());

package/src/postgres/migrate/backfill.ts

@@ -169,6 +169,8 @@ export interface VerifyResult {
   mismatched: number;
   /** Rows whose new column is NULL. */
   nulls: number;
+  /** A rename with a type change: rows whose old column differs from `reverse` over the new one. */
+  unreversed?: number;
   /** The sum of a 64-bit hash of every new value, and of every value the expression gives. */
   checksum: string;
   expected: string;
@@ -201,6 +203,7 @@ export async function verifyMigration(run: MigrationRun): Promise<VerifyResult>
       exec(
         `SELECT count(*)::text AS rows, count(*) FILTER (WHERE ${nw} IS DISTINCT FROM (${o.expression}))::text AS mismatched,
                 count(*) FILTER (WHERE ${nw} IS NULL)::text AS nulls,
+                ${o.reverse !== undefined ? `count(*) FILTER (WHERE (${o.reverse}) IS DISTINCT FROM ${col(n.source)})::text` : "'0'"} AS unreversed,
                 COALESCE(sum(pg_catalog.hashtextextended(${nw}::text, 0)), 0)::text AS checksum,
                 COALESCE(sum(pg_catalog.hashtextextended((${o.expression})::text, 0)), 0)::text AS expected
          FROM ${n.qualifiedTable}`,
@@ -211,6 +214,14 @@ export async function verifyMigration(run: MigrationRun): Promise<VerifyResult>
   if (r.mismatched > 0 || r.checksum !== r.expected) {
     throw new MigrationVerificationError(n.key, { state: o.state, ...r }, `${r.mismatched} of ${r.rows} row(s) have ${n.newColumn} different from ${o.expression} (checksums ${r.checksum} and ${r.expected})`);
   }
+  const unreversed = Number(row?.unreversed ?? 0);
+  if (o.reverse !== undefined && unreversed > 0) {
+    throw new MigrationVerificationError(
+      n.key,
+      { state: o.state, ...r, unreversed },
+      `${unreversed} of ${r.rows} row(s) have ${n.source} different from ${o.reverse}, which must give the old value back from the new one (it would write ${n.source} wrongly for a writer of ${n.column})`,
+    );
+  }
   if (requiresNotNull(o.column, o.carried) && r.nulls > 0) {
     throw new MigrationVerificationError(n.key, { state: o.state, ...r }, `${r.nulls} of ${r.rows} row(s) have ${n.newColumn} NULL, and ${n.column} is declared NOT NULL or is in the primary key`);
   }
@@ -222,12 +233,13 @@ export async function verifyMigration(run: MigrationRun): Promise<VerifyResult>
     o.carried.length > 0 || o.views.length > 0
       ? `; ${o.carried.map((c) => `${c.kind} ${c.name}${c.target !== c.name ? ` (as ${c.target})` : ""}`).join(", ") || "no index or constraint"} carried over${o.views.length > 0 ? `, view(s) ${o.views.map((v) => v.name).join(", ")} made again at the switch` : ""}`
       : "";
-  const summary = `${n.key}: ${r.rows} row(s), ${n.newColumn} equal to ${o.expression} in every one (checksum ${r.checksum})${carried}`;
+  const summary = `${n.key}: ${r.rows} row(s), ${n.newColumn} equal to ${o.expression} in every one (checksum ${r.checksum})${o.reverse !== undefined ? `, ${n.source} equal to ${o.reverse} in every one` : ""}${carried}`;
   run.log(`-- ${summary}`);
   return {
     state: o.state,
     planDigest: computePlanDigest("postgres-migration", { plan: migrationPlanSubject(o), table: o.oid, column: o.newColumn.attnum, verified: { mismatched: 0 } }),
     ...r,
+    ...(o.reverse !== undefined ? { unreversed } : {}),
     summary,
   };
 }

package/src/postgres/migrate/carry.ts

@@ -10,6 +10,7 @@
  * | On the old column | Before the switch | In the switch's transaction |
  * |---|---|---|
  * | an index | `CREATE INDEX CONCURRENTLY` on the new column | the old one dropped (a type change) or kept as `<name>__chant_old` (a rename), the new one renamed to the name |
+ * | an index on a partitioned table | `CREATE INDEX ... ON ONLY` the table, `CONCURRENTLY` on each partition, `ALTER INDEX ... ATTACH PARTITION` | as an index; the partitions' indexes go with the old one |
  * | a primary key or unique constraint | its unique index built `CONCURRENTLY` | the old constraint dropped (or a rename's unique one kept as `__chant_old`), `ADD CONSTRAINT ... USING INDEX` |
  * | a check or foreign key, this table's or another's that references the column | added `NOT VALID`, then `VALIDATE` | the old one dropped, the new one renamed to the name |
  * | a view (and the views that read it) | nothing | dropped, then created again from its declaration once the columns are swapped, with its grants and owner |
@@ -33,7 +34,8 @@
  * key or index the build declares on the new column takes the declared name.
  *
  * Refused, each named with what to do: exclusion constraints and constraint
- * triggers (no `USING INDEX` form), materialized views (made again only by
+ * triggers (no `USING INDEX` form), a key or foreign key on a partitioned table,
+ * a partitioned index over a foreign-table partition, materialized views (made again only by
  * a full scan in the switch), rules, triggers, policies and statistics on the
  * column, a generated column computed from it, an INVALID index on it, a view
  * the build does not declare, a view something other than a view depends on.
@@ -84,6 +86,12 @@ export interface CarriedObject {
   indexComment?: string;
   replicaIdentity?: boolean;
   clustered?: boolean;
+  /**
+   * An index on a partitioned table (#3333): `definition` is the `CREATE INDEX ... ON ONLY` that makes the
+   * partitioned index without building anything. Each partition's index is built `CONCURRENTLY` on its own and
+   * attached (`partitionIndexStatement`, `carryPartitionedIndex` in `./steps.ts`).
+   */
+  partitioned?: boolean;
 }
 
 /** A view on the old column (or on such a view), made again at the switch from its declaration. */
@@ -187,6 +195,73 @@ export function carriedIndexStatement(def: string, working: string, from: string
   return `CREATE ${m[1] ?? ""}INDEX CONCURRENTLY ${quoteIdent(working)} ON ${replaceColumn(m[2]!, from, to)}`;
 }
 
+/**
+ * A partitioned index (`pg_get_indexdef` prints it `ON ONLY`) as the
+ * `CREATE INDEX ... ON ONLY` of `working` on the new column: it builds nothing
+ * and stays INVALID until every partition's index is attached.
+ */
+export function carriedPartitionedIndexStatement(def: string, working: string, from: string, to: string): string {
+  const m = /^CREATE (UNIQUE )?INDEX (?:"(?:[^"]|"")+"|\S+) ON (?:ONLY )?(.*)$/s.exec(def);
+  if (!m) throw new Error(`unexpected index definition: ${def}`);
+  return `CREATE ${m[1] ?? ""}INDEX ${quoteIdent(working)} ON ONLY ${replaceColumn(m[2]!, from, to)}`;
+}
+
+/** One table of a partition tree. */
+export interface PartitionNode {
+  oid: string;
+  schema: string;
+  name: string;
+  /** Quoted and qualified. */
+  ident: string;
+  /** The partitioned table (or partition) it is a partition of; absent for the root. */
+  parent?: string;
+  /** Not partitioned further: the tables that hold rows. */
+  leaf: boolean;
+  /** `r` (ordinary), `p` (partitioned) or `f` (foreign). */
+  kind: string;
+  level: number;
+}
+
+/** The partition tree under a partitioned table, the table itself first (level 0). */
+export async function partitionTree(client: Pick<PostgresClient, "query">, tableOid: string): Promise<PartitionNode[]> {
+  const rows = await client.query<{ oid: string; schema: string; name: string; parent: string | null; leaf: boolean; kind: string; level: number }>(
+    `SELECT t.relid::oid::text AS oid, n.nspname AS schema, c.relname AS name, t.parentrelid::oid::text AS parent, t.isleaf AS leaf, c.relkind::text AS kind, t.level
+     FROM pg_catalog.pg_partition_tree($1::oid::pg_catalog.regclass) t JOIN pg_catalog.pg_class c ON c.oid = t.relid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+     ORDER BY t.level, n.nspname, c.relname`,
+    [tableOid],
+  );
+  return rows.map((r) => ({
+    oid: String(r.oid),
+    schema: r.schema,
+    name: r.name,
+    ident: `${quoteIdent(r.schema)}.${quoteIdent(r.name)}`,
+    ...(r.parent !== null ? { parent: String(r.parent) } : {}),
+    leaf: r.leaf === true,
+    kind: r.kind,
+    level: Number(r.level),
+  }));
+}
+
+/** The name of the index a partitioned index's working copy has on one partition. */
+export const partitionIndexName = (partition: Pick<PartitionNode, "name">, working: string): string => pgName(`${partition.name}_${working}`);
+
+/**
+ * The statement that makes a partitioned index's working copy on one
+ * partition. A partition that is partitioned further gets `ON ONLY` (it is
+ * valid once its own partitions are attached); one that holds rows gets the
+ * `CONCURRENTLY` build, so writes go on.
+ */
+export function partitionIndexStatement(c: Pick<CarriedObject, "definition">, node: Pick<PartitionNode, "ident" | "leaf">, indexName: string): string {
+  const m = /^CREATE (UNIQUE )?INDEX (?:"(?:[^"]|"")+"|\S+) ON ONLY (.*)$/s.exec(c.definition);
+  if (!m) throw new Error(`unexpected partitioned index definition: ${c.definition}`);
+  const using = m[2]!.indexOf(" USING ");
+  if (using < 0) throw new Error(`unexpected partitioned index definition: ${c.definition}`);
+  const tail = m[2]!.slice(using);
+  return node.leaf
+    ? `CREATE ${m[1] ?? ""}INDEX CONCURRENTLY ${quoteIdent(indexName)} ON ${node.ident}${tail}`
+    : `CREATE ${m[1] ?? ""}INDEX ${quoteIdent(indexName)} ON ONLY ${node.ident}${tail}`;
+}
+
 /**
  * The name Postgres gives an object it names after its columns
  * (`users_email_key`, `orders_user_id_fkey`, `users_email_idx`), when `name`
@@ -214,12 +289,26 @@ interface DiscoverInput {
   defaultSchema: string;
   /** The table is partitioned: its indexes cannot be built CONCURRENTLY, nor its keys attached USING INDEX. */
   partitioned?: boolean;
+  /** A rename keeps the column's sequence on the old column until the contract (`defaultAtContract`), instead of being refused. */
+  keepSequence?: boolean;
 }
 
 interface Row {
   [key: string]: unknown;
 }
 
+/** The sequence that belongs to a column (an identity's, or a `serial`'s), if it has one. */
+export async function columnSequence(client: PostgresClient, tableOid: string, attnum: number): Promise<ColumnSequence | undefined> {
+  const [row] = await client.query<{ schema: string; name: string; deptype: string }>(
+    `SELECT n.nspname AS schema, c.relname AS name, d.deptype::text AS deptype
+     FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON c.oid = d.objid AND d.classid = 'pg_catalog.pg_class'::pg_catalog.regclass JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+     WHERE d.refclassid = 'pg_catalog.pg_class'::pg_catalog.regclass AND d.refobjid = $1::oid AND d.refobjsubid = $2 AND d.deptype IN ('a', 'i') AND c.relkind = 'S'`,
+    [tableOid, attnum],
+  );
+  if (!row) return undefined;
+  return { kind: row.deptype === "i" ? "identity" : "serial", schema: row.schema, name: row.name, ident: `${quoteIdent(row.schema)}.${quoteIdent(row.name)}` };
+}
+
 /** What uses the column the values come from, sorted into what the Op carries over and what it refuses. */
 export async function discoverDependents(input: DiscoverInput): Promise<Dependents> {
   const { client, names: n, oid, attnum } = input;
@@ -343,10 +432,6 @@ export async function discoverDependents(input: DiscoverInput): Promise<Dependen
       const kind = String(r.kind);
       if (kind === "i" || kind === "I") {
         if (keyIndexes.has(String(r.oid))) continue;
-        if (kind === "I") {
-          refused.push(`index ${r.schema}.${name} is a partitioned index, which cannot be built CONCURRENTLY; drop it, migrate, then declare it again (chant #3333)`);
-          continue;
-        }
         if (r.valid !== true) {
           refused.push(`index ${r.schema}.${name} is INVALID (a failed CONCURRENTLY build); drop it, or REINDEX it, first`);
           continue;
@@ -375,6 +460,14 @@ export async function discoverDependents(input: DiscoverInput): Promise<Dependen
                 });
           target = declaredIndex?.canonical.name ?? (r.has_exprs === true ? undefined : renamedDefault(name, table, oldCols, cols, "idx")) ?? name;
         }
+        if (kind === "I") {
+          // A partition the index cannot be built on (a foreign table) stops the carry before anything is made.
+          const foreign = (await partitionTree(client, oid)).filter((p) => p.kind === "f");
+          if (foreign.length > 0) {
+            refused.push(`partitioned index ${r.schema}.${name}: ${foreign.map((p) => `${p.schema}.${p.name}`).join(", ")} is a foreign table, which holds no index to attach; drop the index, migrate, then declare it again`);
+            continue;
+          }
+        }
         carried.push({
           kind: "index",
           name,
@@ -384,7 +477,8 @@ export async function discoverDependents(input: DiscoverInput): Promise<Dependen
           schema: String(r.schema),
           working,
           target,
-          definition: carriedIndexStatement(String(r.def), working, from, to),
+          definition: kind === "I" ? carriedPartitionedIndexStatement(String(r.def), working, from, to) : carriedIndexStatement(String(r.def), working, from, to),
+          ...(kind === "I" ? { partitioned: true } : {}),
           validated: true,
           ...(r.comment !== null ? { comment: String(r.comment) } : {}),
           ...(r.replident === true ? { replicaIdentity: true } : {}),
@@ -393,9 +487,10 @@ export async function discoverDependents(input: DiscoverInput): Promise<Dependen
       } else if (kind === "S") {
         const dep = deps.find((d) => d.kind === "class" && d.objid === String(r.oid));
         const seq: ColumnSequence = { kind: dep?.deptype === "i" ? "identity" : "serial", schema: String(r.schema), name, ident: `${quoteIdent(String(r.schema))}.${quoteIdent(name)}` };
-        if (rename) {
+        if (rename && !input.keepSequence) {
           refused.push(
-            `sequence ${r.schema}.${name} gives the column its values (${seq.kind === "identity" ? "an identity column" : "a serial column's default"}); during a rename a writer that names the new column would be given the old one's next value by the trigger, which it cannot tell from a value the writer chose; a rename that keeps its sequence needs versioned views (chant #3331)`,
+            `sequence ${r.schema}.${name} gives the column its values (${seq.kind === "identity" ? "an identity column" : "a serial column's default"}); during a rename a writer that names the new column would get the old one's next value, and the trigger would take it over the writer's, ` +
+              `because it cannot tell a defaulted value from one the writer gave. Set defaultAtContract: true to leave the new column without the default until the contract (see the Op's reference), or drop the default first`,
           );
         } else sequence = seq;
       } else {