@prisma-next/target-postgres 0.16.0-dev.25 → 0.16.0-dev.26

package/src/core/migrations/op-factory-call.ts

@@ -74,7 +74,13 @@ import {
   dropConstraint,
 } from './operations/constraints';
 import { createExtension } from './operations/dependencies';
-import { createIndex, dropIndex } from './operations/indexes';
+import {
+  type CreateIndexElements,
+  type CreateIndexExtras,
+  createIndex,
+  dropIndex,
+  renameIndex,
+} from './operations/indexes';
 import { createNativeEnumType, dropNativeEnumType } from './operations/native-enum-types';
 import {
   createRlsPolicy,
@@ -1137,27 +1143,35 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   readonly schemaName: string;
   readonly tableName: string;
   readonly indexName: string;
-  readonly columns: readonly string[];
+  /** Column tuple when the index is column-based; absent for expression indexes. */
+  readonly columns: readonly string[] | undefined;
+  /** Opaque whole element list when the index is expression-based. */
+  readonly expression: string | undefined;
   // Named indexType (not typeName): `locationForCall` in issue-planner.ts reads
   // a call's `typeName` as a CREATE TYPE target location, which an index is not.
   readonly indexType: string | undefined;
   readonly options: Record<string, unknown> | undefined;
+  readonly where: string | undefined;
+  readonly unique: boolean;
   readonly label: string;
 
   constructor(
     schemaName: string,
     tableName: string,
     indexName: string,
-    columns: readonly string[],
-    extras?: { readonly type?: string; readonly options?: Record<string, unknown> },
+    elements: CreateIndexElements,
+    extras?: CreateIndexExtras,
   ) {
     super();
     this.schemaName = schemaName;
     this.tableName = tableName;
     this.indexName = indexName;
-    this.columns = columns;
+    this.columns = 'columns' in elements ? elements.columns : undefined;
+    this.expression = 'expression' in elements ? elements.expression : undefined;
     this.indexType = extras?.type;
     this.options = extras?.options;
+    this.where = extras?.where;
+    this.unique = extras?.unique === true;
     this.label = `Create index "${indexName}" on "${tableName}"`;
     this.freeze();
   }
@@ -1170,14 +1184,23 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
         { meta: { factory: 'CreateIndexCall' } },
       );
     }
-    const extras: { type?: string; options?: Record<string, unknown> } = {};
+    const extras: {
+      type?: string;
+      options?: Record<string, unknown>;
+      where?: string;
+      unique?: boolean;
+    } = {};
     if (this.indexType !== undefined) extras.type = this.indexType;
     if (this.options !== undefined) extras.options = this.options;
+    if (this.where !== undefined) extras.where = this.where;
+    if (this.unique) extras.unique = true;
     return createIndex(
       this.schemaName,
       this.tableName,
       this.indexName,
-      this.columns,
+      this.columns !== undefined
+        ? { columns: this.columns }
+        : { expression: this.expression ?? '' },
       lowerer,
       extras,
     );
@@ -1190,11 +1213,22 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
     }
     opts.push(`table: ${jsonToTsSource(this.tableName)}`);
     opts.push(`index: ${jsonToTsSource(this.indexName)}`);
-    opts.push(`columns: ${jsonToTsSource(this.columns)}`);
-    if (this.indexType !== undefined || this.options !== undefined) {
+    if (this.columns !== undefined) {
+      opts.push(`columns: ${jsonToTsSource(this.columns)}`);
+    } else {
+      opts.push(`expression: ${jsonToTsSource(this.expression ?? '')}`);
+    }
+    if (
+      this.indexType !== undefined ||
+      this.options !== undefined ||
+      this.where !== undefined ||
+      this.unique
+    ) {
       const extrasParts: string[] = [];
       if (this.indexType !== undefined) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
       if (this.options !== undefined) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
+      if (this.where !== undefined) extrasParts.push(`where: ${jsonToTsSource(this.where)}`);
+      if (this.unique) extrasParts.push('unique: true');
       opts.push(`extras: { ${extrasParts.join(', ')} }`);
     }
     return `this.createIndex({ ${opts.join(', ')} })`;
@@ -1205,6 +1239,62 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   }
 }
 
+export class RenameIndexCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'renameIndex' as const;
+  // `widening` is chosen so the rename plans under every allowance set except
+  // additive-only init — a rename is neither additive-creation nor
+  // destructive, and the class vocabulary has no neutral middle class. It is
+  // NOT that a rename widens anything; this is the accepted typology tradeoff.
+  readonly operationClass = 'widening' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly oldIndexName: string;
+  readonly newIndexName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string, oldIndexName: string, newIndexName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.oldIndexName = oldIndexName;
+    this.newIndexName = newIndexName;
+    this.label = `Rename index "${oldIndexName}" to "${newIndexName}" on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
+        `RenameIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.oldIndexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'RenameIndexCall' } },
+      );
+    }
+    return renameIndex(
+      this.schemaName,
+      this.tableName,
+      this.oldIndexName,
+      this.newIndexName,
+      lowerer,
+    );
+  }
+
+  renderTypeScript(): string {
+    const opts: string[] = [];
+    if (this.schemaName !== UNBOUND_NAMESPACE_ID) {
+      opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+    }
+    opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+    opts.push(`from: ${jsonToTsSource(this.oldIndexName)}`);
+    opts.push(`to: ${jsonToTsSource(this.newIndexName)}`);
+    return `this.renameIndex({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
 export class DropIndexCall extends PostgresOpFactoryCallNode {
   readonly factoryName = 'dropIndex' as const;
   readonly operationClass = 'destructive' as const;
@@ -1824,6 +1914,7 @@ export type PostgresOpFactoryCall =
   | AddCheckConstraintCall
   | DropCheckConstraintCall
   | CreateIndexCall
+  | RenameIndexCall
   | DropIndexCall
   | DropConstraintCall
   | RawSqlCall

package/src/core/migrations/operations/indexes.ts

@@ -1,8 +1,11 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { indexExistsAst } from '../../../contract-free/checks';
-import { postgresError } from '../../errors';
-import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
-import { qualifyTableName } from '../planner-sql-checks';
+import {
+  alterIndexRename as alterIndexRenameDdl,
+  createIndex as createIndexDdl,
+  dropIndex as dropIndexDdl,
+} from '../../../contract-free/ddl';
 import { type Op, step, targetDetails } from './shared';
 
 type CheckStep = { sql: string; params?: readonly unknown[] };
@@ -18,42 +21,51 @@ async function indexExistsSteps(
   return { present, absent };
 }
 
+/** An unbound-namespace object renders unqualified: the DDL node takes no schema. */
+function ddlSchemaOf(schemaName: string): string | undefined {
+  return schemaName === UNBOUND_NAMESPACE_ID ? undefined : schemaName;
+}
+
 export interface CreateIndexExtras {
   readonly type?: string;
   readonly options?: Record<string, unknown>;
+  /**
+   * Partial-index predicate (WHERE body, without the keyword). Inserted
+   * verbatim, never quoted or escaped — the same opaque-SQL stance as RLS
+   * policy predicates.
+   */
+  readonly where?: string;
+  readonly unique?: boolean;
 }
 
-function renderIndexOptionValue(key: string, value: unknown): string {
-  if (typeof value === 'string') return `'${escapeLiteral(value)}'`;
-  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
-  if (typeof value === 'boolean') return value ? 'true' : 'false';
-  throw postgresError(
-    'CONTRACT.INDEX_INVALID',
-    `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`,
-    { meta: { key, valueType: typeof value } },
-  );
-}
-
-function renderIndexOptions(options: Record<string, unknown>): string {
-  return Object.entries(options)
-    .map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`)
-    .join(', ');
-}
+/**
+ * The element list between the parens of CREATE INDEX: either a column
+ * tuple (each identifier quoted) or one opaque expression string covering
+ * the entire list, inserted verbatim.
+ */
+export type CreateIndexElements =
+  | { readonly columns: readonly string[] }
+  | { readonly expression: string };
 
 export async function createIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
-  columns: readonly string[],
+  elements: CreateIndexElements,
   lowerer: ExecuteRequestLowerer,
   extras?: CreateIndexExtras,
 ): Promise<Op> {
-  const qualified = qualifyTableName(schemaName, tableName);
-  const columnList = columns.map(quoteIdentifier).join(', ');
-  const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : '';
-  const options = extras?.options;
-  const withClause =
-    options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : '';
+  const ddlNode = createIndexDdl({
+    schema: ddlSchemaOf(schemaName),
+    table: tableName,
+    name: indexName,
+    unique: extras?.unique === true,
+    elements,
+    type: extras?.type,
+    options: extras?.options,
+    where: extras?.where,
+  });
+  const execute = await lowerer.lowerToExecuteRequest(ddlNode);
   const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   return {
     id: `index.${tableName}.${indexName}`,
@@ -61,22 +73,57 @@ export async function createIndex(
     operationClass: 'additive',
     target: targetDetails('index', indexName, schemaName, tableName),
     precheck: [step(`ensure index "${indexName}" does not exist`, absent.sql, absent.params)],
-    execute: [
-      step(
-        `create index "${indexName}"`,
-        `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`,
-      ),
-    ],
+    execute: [step(`create index "${indexName}"`, execute.sql, execute.params)],
     postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)],
   };
 }
 
+/**
+ * `ALTER INDEX … RENAME TO`. `widening` for the same typology reason as the
+ * RLS policy rename: a rename is neither additive creation nor destructive,
+ * and the class vocabulary has no neutral middle class — it is NOT that a
+ * rename widens anything.
+ */
+export async function renameIndex(
+  schemaName: string,
+  tableName: string,
+  fromName: string,
+  toName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const fromChecks = indexExistsAst(schemaName, fromName);
+  const toChecks = indexExistsAst(schemaName, toName);
+  const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.indexPresent());
+  const toAbsent = await lowerer.lowerToExecuteRequest(toChecks.indexAbsent());
+  const toPresent = await lowerer.lowerToExecuteRequest(toChecks.indexPresent());
+  const ddlNode = alterIndexRenameDdl({
+    schema: ddlSchemaOf(schemaName),
+    from: fromName,
+    to: toName,
+  });
+  const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+  return {
+    id: `index.${schemaName}.${tableName}.${fromName}.rename`,
+    label: `Rename index "${fromName}" to "${toName}" on "${tableName}"`,
+    operationClass: 'widening',
+    target: targetDetails('index', toName, schemaName, tableName),
+    precheck: [
+      step(`ensure index "${fromName}" exists`, fromPresent.sql, fromPresent.params),
+      step(`ensure index "${toName}" does not exist`, toAbsent.sql, toAbsent.params),
+    ],
+    execute: [step(`rename index "${fromName}" to "${toName}"`, execute.sql, execute.params)],
+    postcheck: [step(`verify index "${toName}" exists`, toPresent.sql, toPresent.params)],
+  };
+}
+
 export async function dropIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
   lowerer: ExecuteRequestLowerer,
 ): Promise<Op> {
+  const ddlNode = dropIndexDdl({ schema: ddlSchemaOf(schemaName), name: indexName });
+  const execute = await lowerer.lowerToExecuteRequest(ddlNode);
   const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   return {
     id: `dropIndex.${tableName}.${indexName}`,
@@ -84,9 +131,7 @@ export async function dropIndex(
     operationClass: 'destructive',
     target: targetDetails('index', indexName, schemaName, tableName),
     precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
-    execute: [
-      step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`),
-    ],
+    execute: [step(`drop index "${indexName}"`, execute.sql, execute.params)],
     postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)],
   };
 }

package/src/core/migrations/planner-schema-lookup.ts

@@ -23,9 +23,9 @@ export function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, S
 
 function buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTableLookup {
   const uniqueKeys = new Set(table.uniques.map((u) => u.columns.join(',')));
-  const indexKeys = new Set(table.indexes.map((i) => i.columns.join(',')));
+  const indexKeys = new Set(table.indexes.map((i) => (i.columns ?? []).join(',')));
   const uniqueIndexKeys = new Set(
-    table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),
+    table.indexes.filter((i) => i.unique).map((i) => (i.columns ?? []).join(',')),
   );
   const fkKeys = new Set<string>();
   for (const fk of table.foreignKeys) {

package/src/core/migrations/planner.ts

@@ -24,11 +24,12 @@ import type {
 import { issueOutcome } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { parseWireName } from '@prisma-next/sql-schema-ir/naming';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { SqlIndexIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresRlsPolicy } from '../postgres-rls-policy';
-import { parseRlsPolicyWireName } from '../rls/wire-name';
 import { postgresNodeStorageCoordinate } from '../schema-ir/node-storage-coordinate';
 import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
@@ -46,6 +47,7 @@ import type { PostgresOpFactoryCall } from './op-factory-call';
 import {
   CreatePostgresRlsPolicyCall,
   DropPostgresRlsPolicyCall,
+  RenameIndexCall,
   RenamePostgresRlsPolicyCall,
 } from './op-factory-call';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
@@ -236,6 +238,18 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     });
     const schemaIssues = [...namespaceIssues, ...gated];
 
+    // Index rename post-pass (the policy pass's structure, generalized): a
+    // `not-found` and a `not-expected` index that are one rename collapse
+    // into a single widening `ALTER INDEX … RENAME TO` before the per-issue
+    // mapping turns them into create + drop. Consumed issues never reach
+    // `planIssues`; the rename calls go through the same call-side
+    // control-policy partition the policy ops use.
+    const indexRenames = this.pairIndexRenames(options, schemaIssues);
+    const plannableIssues =
+      indexRenames.consumed.size === 0
+        ? schemaIssues
+        : schemaIssues.filter((issue) => !indexRenames.consumed.has(issue));
+
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
     const storageTypes = options.contract.storage.types ?? {};
     // The strategy layer reads the live schema by bare table name for existence
@@ -253,7 +267,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     // user-visible message survives even when the planner would have failed
     // to model the subject's live shape.
     const issuePartition = partitionIssuesByControlPolicy({
-      issues: schemaIssues,
+      issues: plannableIssues,
       contract: options.contract,
       resolveControlPolicySubject: (issue) =>
         resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),
@@ -282,6 +296,14 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       return plannerFailure(result.failure);
     }
 
+    const indexRenamePartition = partitionCallsByControlPolicy({
+      calls: indexRenames.calls,
+      contract: options.contract,
+      resolveControlPolicySubject: (call) =>
+        resolvePostgresCallControlPolicySubject(call, options.contract),
+      resolveFactoryName: (call) => call.factoryName,
+    });
+
     const schemaDiffCalls = this.planPostgresSchemaDiff(options, policyDiffIssues);
     const schemaDiffPartition = partitionCallsByControlPolicy({
       calls: schemaDiffCalls,
@@ -314,9 +336,15 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         resolvePostgresCallControlPolicySubject(call, options.contract),
       resolveFactoryName: (call) => call.factoryName,
     });
-    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];
+    const calls = [
+      ...result.value.calls,
+      ...indexRenamePartition.kept,
+      ...schemaDiffPartition.kept,
+      ...fieldEventPartition.kept,
+    ];
     const warnings: SqlPlannerConflict[] = [
       ...issuePartition.suppressions,
+      ...indexRenamePartition.suppressions,
       ...schemaDiffPartition.suppressions,
       ...fieldEventPartition.suppressions,
     ].map((record) => renderPostgresSuppression(record, options.contract));
@@ -337,6 +365,128 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     });
   }
 
+  /**
+   * Rename post-pass for indexes, per `(schema, table)`, widening-only,
+   * deterministic by sorted names — the same structure as the policy pass
+   * below (which stays untouched: policies pair by hash only).
+   *
+   * Phase 1 — hash pairing: extras whose live names parse as wire names,
+   * grouped by `(schema, table, hash)`; missing nodes iterated in sorted-name
+   * order consume the sorted-name-first candidate — a prefix-only rename.
+   *
+   * Phase 2 — content pairing: the remaining managed-missing nodes
+   * (`prefix` defined) against the remaining extras of any name shape,
+   * paired iff content-equal (columns ordered-strict both-defined-or-
+   * both-undefined, `unique`/`type` strict, `options` loose, bodies
+   * byte-equal) — exact→managed adoption convergence.
+   *
+   * Leftovers proceed as create/drop exactly as before; without the
+   * widening allowance the pass is skipped and pairing degrades to the
+   * additive half, like the policy pass.
+   */
+  private pairIndexRenames(
+    options: PlannerOptionsWithComponents,
+    issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
+  ): {
+    readonly calls: readonly RenameIndexCall[];
+    readonly consumed: ReadonlySet<SchemaDiffIssue<SqlSchemaDiffNode>>;
+  } {
+    const consumed = new Set<SchemaDiffIssue<SqlSchemaDiffNode>>();
+    const calls: RenameIndexCall[] = [];
+    if (!options.policy.allowedOperationClasses.includes('widening')) {
+      return { calls, consumed };
+    }
+
+    interface IndexFinding {
+      readonly issue: SchemaDiffIssue<SqlSchemaDiffNode>;
+      readonly node: SqlIndexIR;
+      readonly ddlSchema: string;
+      readonly tableName: string;
+    }
+    const missing: IndexFinding[] = [];
+    const extra: IndexFinding[] = [];
+    for (const issue of issues) {
+      const node = issueNode(issue);
+      if (node === undefined || !SqlIndexIR.is(node)) continue;
+      const ddlSchema = issue.path[1];
+      const tableName = issue.path[2];
+      if (ddlSchema === undefined || tableName === undefined) continue;
+      if (issueOutcome(issue) === 'not-found') {
+        missing.push({ issue, node, ddlSchema, tableName });
+      } else if (issueOutcome(issue) === 'not-expected') {
+        extra.push({ issue, node, ddlSchema, tableName });
+      }
+    }
+    if (missing.length === 0 || extra.length === 0) {
+      return { calls, consumed };
+    }
+
+    const byName = (a: IndexFinding, b: IndexFinding): number =>
+      a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0;
+    // DDL emission must stay unqualified for the unbound namespace, exactly
+    // like the per-issue mapping's `emissionSchemaName`.
+    const emissionSchema = (ddlSchema: string): string =>
+      resolveNamespaceIdForDdlSchema(options.contract, ddlSchema) === UNBOUND_NAMESPACE_ID
+        ? UNBOUND_NAMESPACE_ID
+        : ddlSchema;
+    const pairingKey = (finding: IndexFinding, hash: string): string =>
+      JSON.stringify([finding.ddlSchema, finding.tableName, hash]);
+    const rename = (missingFinding: IndexFinding, candidate: IndexFinding): void => {
+      consumed.add(missingFinding.issue);
+      consumed.add(candidate.issue);
+      calls.push(
+        new RenameIndexCall(
+          emissionSchema(missingFinding.ddlSchema),
+          missingFinding.tableName,
+          candidate.node.name,
+          missingFinding.node.name,
+        ),
+      );
+    };
+
+    const sortedMissing = [...missing].sort(byName);
+
+    const extrasByHash = new Map<string, IndexFinding[]>();
+    for (const finding of extra) {
+      const parsed = parseWireName(finding.node.name);
+      if (parsed === undefined) continue;
+      const key = pairingKey(finding, parsed.hash);
+      const group = extrasByHash.get(key) ?? [];
+      group.push(finding);
+      extrasByHash.set(key, group);
+    }
+    for (const group of extrasByHash.values()) {
+      group.sort(byName);
+    }
+    for (const missingFinding of sortedMissing) {
+      const parsed = parseWireName(missingFinding.node.name);
+      if (parsed === undefined) continue;
+      const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
+      if (candidate === undefined) continue;
+      rename(missingFinding, candidate);
+    }
+
+    const sortedExtras = [...extra].sort(byName);
+    for (const missingFinding of sortedMissing) {
+      if (consumed.has(missingFinding.issue)) continue;
+      if (missingFinding.node.prefix === undefined) continue;
+      const candidate = sortedExtras.find(
+        (extraFinding) =>
+          !consumed.has(extraFinding.issue) &&
+          extraFinding.ddlSchema === missingFinding.ddlSchema &&
+          extraFinding.tableName === missingFinding.tableName &&
+          missingFinding.node.contentEquals(extraFinding.node, {
+            columnPresence: 'matching',
+            bodies: 'verbatim',
+          }),
+      );
+      if (candidate === undefined) continue;
+      rename(missingFinding, candidate);
+    }
+
+    return { calls, consumed };
+  }
+
   /**
    * Maps the RLS policy presence findings of the one combined tree diff
    * (`buildPostgresPlanDiff`, already ownership-filtered) into
@@ -412,7 +562,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     if (allowsWidening) {
       const extrasByGroup = new Map<string, PolicyFinding[]>();
       for (const finding of extra) {
-        const parsed = parseRlsPolicyWireName(finding.node.name);
+        const parsed = parseWireName(finding.node.name);
         if (parsed === undefined) continue;
         const key = pairingKey(finding, parsed.hash);
         const group = extrasByGroup.get(key) ?? [];
@@ -427,7 +577,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0,
       );
       for (const missingFinding of sortedMissing) {
-        const parsed = parseRlsPolicyWireName(missingFinding.node.name);
+        const parsed = parseWireName(missingFinding.node.name);
         if (parsed === undefined) continue;
         const candidates = extrasByGroup.get(pairingKey(missingFinding, parsed.hash));
         const candidate = candidates?.shift();

package/src/core/migrations/postgres-migration.ts

@@ -34,6 +34,7 @@ import {
   DropPostgresRlsPolicyCall,
   DropTableCall,
   EnableRowLevelSecurityCall,
+  RenameIndexCall,
   RenamePostgresRlsPolicyCall,
   SetDefaultCall,
   SetNotNullCall,
@@ -392,22 +393,39 @@ export abstract class PostgresMigration<
     );
   }
 
-  protected createIndex(options: {
-    readonly schema: string;
-    readonly table: string;
-    readonly index: string;
-    readonly columns: readonly string[];
-    readonly extras?: CreateIndexExtras;
-  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+  protected createIndex(
+    options: {
+      readonly schema: string;
+      readonly table: string;
+      readonly index: string;
+      readonly extras?: CreateIndexExtras;
+    } & (
+      | { readonly columns: readonly string[]; readonly expression?: never }
+      | { readonly expression: string; readonly columns?: never }
+    ),
+  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     return new CreateIndexCall(
       options.schema,
       options.table,
       options.index,
-      options.columns,
+      options.columns !== undefined
+        ? { columns: options.columns }
+        : { expression: options.expression },
       options.extras,
     ).toOp(this.controlAdapterFor('createIndex'));
   }
 
+  protected renameIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    return new RenameIndexCall(options.schema, options.table, options.from, options.to).toOp(
+      this.controlAdapterFor('renameIndex'),
+    );
+  }
+
   protected dropIndex(options: {
     readonly schema: string;
     readonly table: string;

package/src/core/psl-infer/infer-psl-contract.ts

@@ -748,8 +748,15 @@ function buildModel(
   }
 
   for (const index of table.indexes) {
+    // Expression indexes (no column tuple) and partial indexes (a where
+    // predicate) are not emitted yet — no authoring surface can carry their
+    // bodies, so adopting them name-only would fail its own verify (the
+    // exact-mode body compare). Their inference lands when the authoring
+    // surfaces for those bodies exist.
+    if (index.columns === undefined || index.where !== undefined) continue;
     if (!index.unique) {
-      const indexFieldNames = index.columns.map((columnName) =>
+      const columns = index.columns;
+      const indexFieldNames = columns.map((columnName) =>
         resolveColumnFieldName(fieldNamesByTable, table.name, columnName),
       );
       modelAttributes.push(