Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

53.8 KB
Raw Blame
import * as api from "@/lib/backend/api";
import { BackendErrorException } from "@/lib/backend/errorUtils";
import { freezeSourceIdentities } from "@/lib/table/objectSourceIdentity";
import { invalidateObjectDdlCache } from "@/lib/metadata/objectDdlCache";
import { invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";
import type { DatabaseType, OracleViewRenameIssue, QueryResult } from "@/types/database";

type DependentType = "VIEW" | "PROCEDURE" | "FUNCTION" | "TRIGGER";
type RewriteableDependentType = Exclude<DependentType, "VIEW">;
type ObjectType = "TABLE" | "OPERATOR" | "PACKAGE BODY" | "TYPE BODY" | "SEQUENCE" | "SYNONYM" | "PACKAGE" | "MATERIALIZED VIEW" | "TYPE" | DependentType;

export interface OracleTableRenameTarget {
  connectionId: string;
  database: string;
  databaseType: Extract<DatabaseType, "oracle" | "oceanbase-oracle">;
  schema: string;
  oldName: string;
  newName: string;
}

export interface OracleTableRenameIssue {
  code: string;
  message: string;
  objectName?: string;
  location?: { line: number; column: number };
  repairable: boolean;
}

export interface OracleTableRenameDependent {
  name: string;
  objectType: DependentType;
  objectId: string;
  source: string;
  executionSource: string;
  status: string;
  grants: string;
  errors: string;
  triggerStatus?: string;
  triggerTable?: string;
  draft: string;
  rewrittenSource: string;
  fingerprint: string;
  originalFingerprint: string;
  rewriteRequired: boolean;
}

export interface OracleTableRenameStep {
  kind: "rename" | "replace" | "compile";
  objectName: string;
  objectType: ObjectType;
  sql: string;
}

export interface OracleTableRenamePlan {
  target: OracleTableRenameTarget;
  canonicalNewName: string;
  tableObjectId: string;
  tableSnapshot: OracleTableSnapshot | null;
  dependents: OracleTableRenameDependent[];
  dependencyEdges: string[];
  issues: OracleTableRenameIssue[];
  metadataComplete: boolean;
  executable: boolean;
  steps: OracleTableRenameStep[];
  statements: string[];
}

interface OracleTableSnapshot {
  source: string;
  grants: string;
  indexes: string;
  indexColumns: string;
  constraints: string;
  constraintColumns: string;
  incomingForeignKeys: string;
  boundTriggers: string;
}

export class OracleTableRenameFailure extends Error {
  constructor(
    public readonly plan: OracleTableRenamePlan,
    public readonly completed: string[],
    public readonly uncertain: string,
    public readonly reconciliation: "confirmed" | "not-confirmed" | "unknown",
    cause: unknown,
  ) {
    super(`Table rename stopped. Confirmed: ${completed.join(", ") || "none"}. ${uncertain} is ${reconciliation}. ${cause instanceof Error ? cause.message : String(cause)}`);
  }
}

const metadataLimit = 5000;
const sourceLimit = 1_000_000;
const literal = (value: string) => `'${value.replaceAll("'", "''")}'`;
const identifier = (value: string) => `"${value.replaceAll('"', '""')}"`;
const acceptedTypes = new Set<DependentType>(["VIEW", "PROCEDURE", "FUNCTION", "TRIGGER"]);
const tableNamespaceTypes: ObjectType[] = ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "SYNONYM", "PACKAGE", "MATERIALIZED VIEW", "TYPE", "OPERATOR"];

function errorMessage(error: unknown) {
  return error instanceof Error ? error.message : String(error);
}

async function query(target: OracleTableRenameTarget, sql: string): Promise<QueryResult> {
  const result = await api.executeQuery(target.connectionId, target.database, sql, target.schema, undefined, { maxRows: metadataLimit + 1 });
  if (result.execution_error) throw new BackendErrorException(result.error || "Metadata query failed.");
  if (result.truncated || result.has_more || result.rows.length > metadataLimit || result.large_value_cells?.length) {
    throw new Error("Metadata is incomplete; refresh the table rename plan before execution.");
  }
  return result;
}

async function checkOwner(target: OracleTableRenameTarget) {
  const result = await query(target, "SELECT USER, SYS_CONTEXT('USERENV','CURRENT_SCHEMA') FROM DUAL");
  if (result.rows.length !== 1 || result.rows[0][0] !== target.schema || result.rows[0][1] !== target.schema) {
    throw new Error("Table rename requires the object's owner and matching current schema.");
  }
}

async function objectStates(target: OracleTableRenameTarget, name: string, types: ObjectType[]) {
  if (!types.length) return [] as unknown[][];
  const objectTypes = types.map(literal).join(",");
  return (await query(target, `SELECT OBJECT_TYPE, OBJECT_ID, STATUS FROM USER_OBJECTS WHERE OBJECT_NAME=${literal(name)} AND OBJECT_TYPE IN (${objectTypes}) ORDER BY OBJECT_TYPE`)).rows;
}

async function readSource(target: OracleTableRenameTarget, objectType: ObjectType, name: string) {
  const metadataType = objectType === "TABLE" ? "TABLE" : objectType;
  const ddl = `DBMS_METADATA.GET_DDL(${literal(metadataType)},${literal(name)},${literal(target.schema)})`;
  const lengthRows = (await query(target, `SELECT DBMS_LOB.GETLENGTH(${ddl}) FROM DUAL`)).rows;
  const length = Number(lengthRows[0]?.[0]);
  if (lengthRows.length !== 1 || !Number.isSafeInteger(length) || length <= 0 || length > sourceLimit) throw new Error(`Complete ${objectType} DDL is unavailable for ${name}.`);
  let source = "";
  for (let firstOffset = 1; firstOffset <= length; firstOffset += 32_000) {
    const offsets: number[] = [];
    for (let offset = firstOffset; offset <= length && offsets.length < 32; offset += 1000) offsets.push(offset);
    const rows = (await query(target, offsets.map((offset) => `SELECT ${offset} CHUNK_OFFSET, DBMS_LOB.SUBSTR(${ddl},1000,${offset}) CHUNK_TEXT FROM DUAL`).join(" UNION ALL "))).rows;
    const chunks = new Map(rows.map((row) => [Number(row[0]), row[1]]));
    if (rows.length !== offsets.length || chunks.size !== offsets.length) throw new Error(`Complete DDL is unavailable for ${name}.`);
    for (const offset of offsets) {
      const chunk = chunks.get(offset);
      if (typeof chunk !== "string" || Array.from(chunk).length !== Math.min(1000, length - offset + 1)) throw new Error(`Complete DDL is unavailable for ${name}.`);
      source += chunk;
    }
  }
  return source;
}

async function readGrants(target: OracleTableRenameTarget, name: string) {
  const tables = await query(target, `SELECT GRANTOR, GRANTEE, PRIVILEGE, GRANTABLE FROM ALL_TAB_PRIVS WHERE TABLE_SCHEMA=${literal(target.schema)} AND TABLE_NAME=${literal(name)}`);
  const schemaColumn = target.databaseType === "oracle" ? "TABLE_SCHEMA" : "OWNER";
  const columns = await query(target, `SELECT GRANTOR, GRANTEE, COLUMN_NAME, PRIVILEGE, GRANTABLE FROM ALL_COL_PRIVS WHERE ${schemaColumn}=${literal(target.schema)} AND TABLE_NAME=${literal(name)}`);
  return JSON.stringify([tables.rows.map((row) => JSON.stringify(row)).sort(), columns.rows.map((row) => JSON.stringify(row)).sort()]);
}

async function readErrors(target: OracleTableRenameTarget, name: string, objectType: DependentType) {
  const rows = (await query(target, `SELECT ATTRIBUTE, LINE, POSITION, TEXT FROM USER_ERRORS WHERE NAME=${literal(name)} AND TYPE=${literal(objectType)} ORDER BY SEQUENCE`)).rows;
  return JSON.stringify(rows.map((row) => row.map((value) => (value === null ? null : String(value)))));
}

async function readTrigger(target: OracleTableRenameTarget, name: string) {
  const rows = (await query(target, `SELECT STATUS, TABLE_NAME FROM USER_TRIGGERS WHERE TRIGGER_NAME=${literal(name)}`)).rows;
  if (rows.length !== 1 || typeof rows[0][0] !== "string" || typeof rows[0][1] !== "string") throw new Error(`Trigger metadata for ${name} is incomplete.`);
  return { status: rows[0][0] as string, table: rows[0][1] as string };
}

async function readBoundTriggers(target: OracleTableRenameTarget, tableName: string) {
  const rows = (await query(target, `SELECT TRIGGER_NAME, STATUS FROM USER_TRIGGERS WHERE TABLE_NAME=${literal(tableName)} ORDER BY TRIGGER_NAME`)).rows;
  if (rows.some((row) => typeof row[0] !== "string" || !["ENABLED", "DISABLED"].includes(String(row[1])))) throw new Error(`Bound trigger metadata for ${tableName} is incomplete.`);
  return rows;
}

async function readTableSnapshot(target: OracleTableRenameTarget, name: string): Promise<OracleTableSnapshot> {
  const [source, grants, indexes, indexColumns, constraints, constraintColumns, incomingForeignKeys, boundTriggers] = await Promise.all([
    readSource(target, "TABLE", name),
    readGrants(target, name),
    query(target, `SELECT INDEX_NAME, INDEX_TYPE, UNIQUENESS, STATUS, TABLESPACE_NAME FROM USER_INDEXES WHERE TABLE_NAME=${literal(name)} ORDER BY INDEX_NAME`),
    query(target, `SELECT INDEX_NAME, COLUMN_NAME, COLUMN_POSITION, DESCEND FROM USER_IND_COLUMNS WHERE TABLE_NAME=${literal(name)} ORDER BY INDEX_NAME, COLUMN_POSITION`),
    query(target, `SELECT CONSTRAINT_NAME, CONSTRAINT_TYPE, STATUS, VALIDATED, DEFERRABLE, DEFERRED, DELETE_RULE, R_OWNER, R_CONSTRAINT_NAME FROM USER_CONSTRAINTS WHERE TABLE_NAME=${literal(name)} ORDER BY CONSTRAINT_NAME`),
    query(target, `SELECT CONSTRAINT_NAME, COLUMN_NAME, POSITION FROM USER_CONS_COLUMNS WHERE TABLE_NAME=${literal(name)} ORDER BY CONSTRAINT_NAME, POSITION`),
    query(
      target,
      `SELECT c.OWNER, c.TABLE_NAME, c.CONSTRAINT_NAME, c.STATUS, c.VALIDATED, c.DELETE_RULE, c.R_OWNER, c.R_CONSTRAINT_NAME FROM ALL_CONSTRAINTS c JOIN ALL_CONSTRAINTS r ON r.OWNER=c.R_OWNER AND r.CONSTRAINT_NAME=c.R_CONSTRAINT_NAME WHERE c.CONSTRAINT_TYPE='R' AND r.OWNER=${literal(target.schema)} AND r.TABLE_NAME=${literal(name)} ORDER BY c.OWNER, c.CONSTRAINT_NAME`,
    ),
    readBoundTriggers(target, name),
  ]);
  return {
    source,
    grants,
    indexes: JSON.stringify(indexes.rows),
    indexColumns: JSON.stringify(indexColumns.rows),
    constraints: JSON.stringify(constraints.rows),
    constraintColumns: JSON.stringify(constraintColumns.rows),
    incomingForeignKeys: JSON.stringify(incomingForeignKeys.rows),
    boundTriggers: JSON.stringify(boundTriggers),
  };
}

function maskTriggerCommentsAndStrings(source: string) {
  const output = source.split("");
  const mask = (start: number, end: number) => {
    for (let index = start; index < end; index++) if (source[index] !== "\n" && source[index] !== "\r") output[index] = " ";
  };
  for (let index = 0; index < source.length;) {
    if (source.startsWith("--", index)) {
      const newline = source.indexOf("\n", index + 2);
      const end = newline < 0 ? source.length : newline;
      mask(index, end);
      index = end;
    } else if (source.startsWith("/*", index)) {
      const close = source.indexOf("*/", index + 2);
      if (close < 0) return "";
      mask(index, close + 2);
      index = close + 2;
    } else if ((source[index] === "q" || source[index] === "Q") && source[index + 1] === "'") {
      const opener = source[index + 2];
      if (!opener) return "";
      const closer = ({ "[": "]", "{": "}", "(": ")", "<": ">" } as Record<string, string>)[opener] || opener;
      const end = source.indexOf(`${closer}'`, index + 3);
      if (end < 0) return "";
      mask(index, end + 2);
      index = end + 2;
    } else if (source[index] === "'") {
      const start = index++;
      while (index < source.length) {
        if (source[index] === "'" && source[index + 1] === "'") index += 2;
        else if (source[index++] === "'") break;
      }
      mask(start, index);
    } else index++;
  }
  return output.join("");
}

function executableTriggerSource(source: string, schema: string, name: string, status: string) {
  const escaped = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const suffix = new RegExp(`\\s*ALTER\\s+TRIGGER\\s+"?${escaped(schema)}"?\\s*\\.\\s*"?${escaped(name)}"?\\s+(ENABLE|DISABLE)\\s*;?\\s*$`, "i");
  const match = suffix.exec(source);
  if (!match) throw new Error(`Trigger ${name} DDL has an unsupported state clause.`);
  let create = source.slice(0, match.index).trimEnd();
  const disabled = status === "DISABLED";
  if (disabled) {
    const syntax = maskTriggerCommentsAndStrings(create);
    if (!/\bFOR\s+EACH\s+ROW\b/i.test(syntax)) throw new Error(`Disabled trigger ${name} is outside the supported row-trigger subset.`);
    if (!/\bFOR\s+EACH\s+ROW\s+DISABLE\b/i.test(syntax)) {
      const header = /\bFOR\s+EACH\s+ROW\b/i.exec(syntax)!;
      const insertion = header.index + header[0].length;
      create = `${create.slice(0, insertion)} DISABLE${create.slice(insertion)}`;
    }
  } else if (status !== "ENABLED") {
    throw new Error(`Trigger ${name} has an unknown enabled state.`);
  }
  return create;
}

function sourceIdentifier(value: string) {
  return value.startsWith('"') ? value.slice(1, -1).replaceAll('""', '"') : value.toUpperCase();
}

function tableDefinitionFingerprint(source: string, schema: string, name: string) {
  const syntax = maskTriggerCommentsAndStrings(source);
  const identifierToken = '("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*)';
  const declaration = new RegExp(`^(\\s*CREATE\\s+(?:(?:GLOBAL|PRIVATE)\\s+TEMPORARY\\s+)?TABLE\\s+)${identifierToken}(?:\\s*\\.\\s*${identifierToken})?`, "i").exec(syntax);
  if (!declaration) throw new Error(`Table source for ${name} has no verifiable CREATE declaration.`);
  const qualified = declaration[3] !== undefined;
  const declaredOwner = qualified ? sourceIdentifier(declaration[2]!) : schema;
  const declaredName = sourceIdentifier(qualified ? declaration[3]! : declaration[2]!);
  if (declaredOwner !== schema || declaredName !== name) throw new Error(`Table source declares ${declaredOwner}.${declaredName}, not ${schema}.${name}.`);
  return source.slice(0, declaration.index) + `${declaration[1]}<TABLE>` + source.slice(declaration.index + declaration[0].length);
}

function tableSnapshotsMatch(expected: OracleTableSnapshot, actual: OracleTableSnapshot, schema: string, expectedName: string, actualName: string) {
  return (
    tableDefinitionFingerprint(expected.source, schema, expectedName) === tableDefinitionFingerprint(actual.source, schema, actualName) &&
    expected.grants === actual.grants &&
    expected.indexes === actual.indexes &&
    expected.indexColumns === actual.indexColumns &&
    expected.constraints === actual.constraints &&
    expected.constraintColumns === actual.constraintColumns &&
    expected.incomingForeignKeys === actual.incomingForeignKeys &&
    expected.boundTriggers === actual.boundTriggers
  );
}

function validateDependentDeclaration(source: string, schema: string, name: string, objectType: RewriteableDependentType) {
  const syntax = maskTriggerCommentsAndStrings(source);
  const identifierToken = '("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*)';
  const declaration = new RegExp(`^\\s*CREATE\\s+(?:OR\\s+REPLACE\\s+)?(?:(?:FORCE|NOFORCE)\\s+)?(?:(?:NON)?EDITIONABLE\\s+)?${objectType}\\s+${identifierToken}(?:\\s*\\.\\s*${identifierToken})?`, "i").exec(syntax);
  if (!declaration) throw new Error(`${objectType} source has no verifiable CREATE declaration.`);
  const qualified = declaration[2] !== undefined;
  const declaredOwner = qualified ? sourceIdentifier(declaration[1]!) : schema;
  const declaredName = sourceIdentifier(qualified ? declaration[2]! : declaration[1]!);
  if (declaredOwner !== schema || declaredName !== name) throw new Error(`${objectType} source declares ${declaredOwner}.${declaredName}, not ${schema}.${name}.`);
  if ((syntax.match(/\bCREATE\b/gi) || []).length !== 1 || !/\bEND(?:\s+(?:"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*))?\s*;\s*\/?\s*$/i.test(syntax)) {
    throw new Error(`${objectType} source must contain one complete CREATE statement for ${name}.`);
  }
  const bodyStart = objectType === "TRIGGER" ? /\bDECLARE\b|\bBEGIN\b/i.exec(syntax) : /\bAS\b|\bIS\b/i.exec(syntax);
  const firstBegin = bodyStart && objectType === "TRIGGER" && /^BEGIN$/i.test(bodyStart[0]) ? bodyStart : bodyStart ? /\bBEGIN\b/i.exec(syntax.slice(bodyStart.index + bodyStart[0].length)) : null;
  if (!bodyStart || !firstBegin) throw new Error(`${objectType} source has no verifiable PL/SQL body for ${name}.`);
  const tokens = [...syntax.matchAll(/\bBEGIN\b|\bEND\b(?:\s+(?:IF|LOOP|CASE)\b)?|[^\s;]+|;/gi)];
  let depth = 0;
  let bodyClosed = false;
  for (let index = 0; index < tokens.length; index++) {
    const token = tokens[index]![0];
    if (/^BEGIN$/i.test(token)) {
      if (bodyClosed) throw new Error(`${objectType} source contains statements after its CREATE body.`);
      depth++;
    } else if (/^END(?:\s+(?:IF|LOOP|CASE))?$/i.test(token) && !/\s+(?:IF|LOOP|CASE)$/i.test(token)) {
      depth--;
      if (depth < 0) throw new Error(`${objectType} source has an invalid PL/SQL block boundary.`);
      if (depth === 0) {
        bodyClosed = true;
        const tail = tokens
          .slice(index + 1)
          .map((entry) => entry[0])
          .filter((entry) => entry !== ";" && entry !== "/");
        if (tail.length > 1 || (tail.length === 1 && !/^(?:"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*)$/.test(tail[0]!))) {
          throw new Error(`${objectType} source contains statements after its CREATE body.`);
        }
        if (tail.length === 1 && index + 2 < tokens.length && tokens[index + 2]![0] !== ";") {
          throw new Error(`${objectType} source contains statements after its CREATE body.`);
        }
      }
    }
  }
  if (!bodyClosed || depth !== 0) throw new Error(`${objectType} source has an incomplete PL/SQL body.`);
}

function tableRelations(source: string) {
  const syntax = maskTriggerCommentsAndStrings(source);
  const relations = new Set<string>();
  const identifierToken = '((?:"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*)(?:\\s*\\.\\s*(?:"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*))?)';
  const canonical = (reference: string) =>
    reference
      .match(/"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*/g)!
      .map((part) => (part.startsWith('"') ? `Q:${part.slice(1, -1).replaceAll('""', '"')}` : `U:${part.toUpperCase()}`))
      .join(".");
  const pattern = new RegExp(`\\b(?:FROM|JOIN|UPDATE|ON)\\s+${identifierToken}`, "gi");
  for (const match of syntax.matchAll(pattern)) relations.add(canonical(match[1]!));
  const dml = new RegExp(`\\b(?:INSERT|MERGE)\\s+INTO\\s+${identifierToken}`, "gi");
  for (const match of syntax.matchAll(dml)) relations.add(canonical(match[1]!));
  const typeReference = new RegExp(`${identifierToken}\\s*%\\s*(?:TYPE|ROWTYPE)`, "gi");
  for (const match of syntax.matchAll(typeReference)) relations.add(canonical(match[1]!));
  return relations;
}

function validateDraftRelations(original: string, draft: string, schema: string, oldName: string, newName: string) {
  const rootSegments = new Set([`U:${oldName.toUpperCase()}`, `U:${newName.toUpperCase()}`, `Q:${oldName}`, `Q:${newName}`]);
  const ownerSegments = new Set([`U:${schema.toUpperCase()}`, `Q:${schema}`]);
  const normalize = (name: string) => {
    const parts = name.split(".");
    const hasAllowedOwner = parts.length === 1 || (parts.length === 2 && ownerSegments.has(parts[0]!));
    return hasAllowedOwner && rootSegments.has(parts[parts.length - 1]!) ? "ROOT_TABLE" : name;
  };
  const expected = new Set([...tableRelations(original)].map(normalize));
  const actual = new Set([...tableRelations(draft)].map(normalize));
  const unexpected = [...actual].filter((name) => !expected.has(name) && name !== "ROOT_TABLE");
  const removed = [...expected].filter((name) => !actual.has(name) && name !== "ROOT_TABLE");
  const calls = (source: string) => {
    const syntax = maskTriggerCommentsAndStrings(source);
    const ignored = new Set([
      "IF",
      "IN",
      "EXISTS",
      "VALUES",
      "CAST",
      "TABLE",
      "SELECT",
      "FROM",
      "AS",
      "CASE",
      "WHEN",
      "OVER",
      "PARTITION",
      "WITH",
      "PRIOR",
      "COUNT",
      "SUM",
      "AVG",
      "MIN",
      "MAX",
      "NVL",
      "NVL2",
      "COALESCE",
      "DECODE",
      "TO_CHAR",
      "TO_DATE",
      "TO_NUMBER",
      "SUBSTR",
      "TRIM",
      "UPPER",
      "LOWER",
      "ROUND",
      "ABS",
      "LENGTH",
      "INSTR",
      "EXTRACT",
      "JSON_VALUE",
      "JSON_QUERY",
      "LISTAGG",
      "ROW_NUMBER",
      "RANK",
      "DENSE_RANK",
    ]);
    const identifier = '(?:"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*)';
    const canonical = (reference: string) =>
      reference
        .match(/"(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$#]*/g)!
        .map((part) => (part.startsWith('"') ? `Q:${part.slice(1, -1).replaceAll('""', '"')}` : `U:${part.toUpperCase()}`))
        .join(".");
    const found = new Set([...syntax.matchAll(new RegExp(`${identifier}(?:\\s*\\.\\s*${identifier})*\\s*\\(`, "g"))].map((match) => canonical(match[0]!.replace(/\s*\($/, ""))));
    const noArgStatement = new Set(
      [...syntax.matchAll(new RegExp(`(?:\\bBEGIN\\b|\\bTHEN\\b|\\bELSE\\b|\\bLOOP\\b|(;))\\s*(${identifier}(?:\\s*\\.\\s*${identifier})*)\\s*(?=;)`, "gi"))]
        .map((match) => canonical(match[2]!))
        .filter((name) => !new Set(["U:END", "U:NULL", "U:RETURN", "U:THEN", "U:ELSE", "U:COMMIT", "U:ROLLBACK"]).has(name)),
    );
    for (const name of noArgStatement) found.add(name);
    return new Set([...found].filter((name) => (!name.includes(".") && name.startsWith("U:") ? !ignored.has(name.slice(2)) : true)));
  };
  const originalCalls = calls(original);
  const draftCalls = calls(draft);
  const changedCalls = [...originalCalls].filter((name) => !draftCalls.has(name)).concat([...draftCalls].filter((name) => !originalCalls.has(name)));
  if (unexpected.length || removed.length || changedCalls.length)
    throw new Error(`The draft changes planned dependencies${unexpected.length ? `; adds ${unexpected.join(", ")}` : ""}${removed.length ? `; removes ${removed.join(", ")}` : ""}${changedCalls.length ? `; changes calls ${changedCalls.join(", ")}` : ""}.`);
}

interface DependentSnapshot extends Omit<OracleTableRenameDependent, "draft" | "rewrittenSource" | "fingerprint" | "originalFingerprint" | "rewriteRequired"> {
  executionSource: string;
}

async function readSnapshot(target: OracleTableRenameTarget, name: string, objectType: DependentType): Promise<DependentSnapshot> {
  const states = await objectStates(target, name, [objectType]);
  if (states.length !== 1 || states[0][0] !== objectType || states[0][1] == null || states[0][2] == null) throw new Error(`${objectType} ${name} is missing or has an ambiguous identity.`);
  const source = await readSource(target, objectType, name);
  const grants = await readGrants(target, name);
  const errors = await readErrors(target, name, objectType);
  const trigger = objectType === "TRIGGER" ? await readTrigger(target, name) : undefined;
  const executionSource = trigger ? executableTriggerSource(source, target.schema, name, trigger.status) : source;
  return {
    name,
    objectType,
    objectId: String(states[0][1]),
    source,
    executionSource,
    status: String(states[0][2]),
    grants,
    errors,
    ...(trigger ? { triggerStatus: trigger.status, triggerTable: trigger.table } : {}),
  };
}

async function readDependents(target: OracleTableRenameTarget, name: string, objectType: ObjectType) {
  const suffix = ` WHERE REFERENCED_OWNER=${literal(target.schema)} AND REFERENCED_NAME=${literal(name)} AND REFERENCED_TYPE=${literal(objectType)}`;
  const columns = "SELECT OWNER, NAME, TYPE, REFERENCED_LINK_NAME FROM ";
  try {
    return (await query(target, `${columns}SYS.DBA_DEPENDENCIES${suffix}`)).rows;
  } catch (error) {
    if (!/ORA-00942|ORA-01031/.test(errorMessage(error))) throw error;
    return (await query(target, `${columns}SYS.ALL_DEPENDENCIES${suffix}`)).rows;
  }
}

function issue(issues: OracleTableRenameIssue[], code: string, message: string, objectName?: string, repairable = false) {
  issues.push({ code, message, objectName, repairable });
}

function objectKey(name: string, type: ObjectType) {
  return `${type}:${name}`;
}

function orderDependents(names: Map<string, { name: string; type: DependentType }>, edges: string[], schema: string) {
  const indegree = new Map([...names.keys()].map((key) => [key, 0]));
  const outgoing = new Map([...names.keys()].map((key) => [key, new Set<string>()]));
  for (const edge of edges) {
    const [referencedName, referencedType, owner, dependentName, dependentType, link] = JSON.parse(edge) as [string, ObjectType, string, string, DependentType, string | null];
    if (owner !== schema || link) continue;
    const from = objectKey(referencedName, referencedType);
    const to = objectKey(dependentName, dependentType);
    if (!indegree.has(to) || !outgoing.has(to)) continue;
    if (indegree.has(from) && from !== to && !outgoing.get(from)!.has(to)) {
      outgoing.get(from)!.add(to);
      indegree.set(to, indegree.get(to)! + 1);
    }
  }
  const compare = (left: string, right: string) => left.localeCompare(right);
  const ready = [...indegree]
    .filter(([, count]) => count === 0)
    .map(([key]) => key)
    .sort(compare);
  const ordered: string[] = [];
  while (ready.length) {
    const key = ready.shift()!;
    ordered.push(key);
    for (const child of outgoing.get(key)!) {
      indegree.set(child, indegree.get(child)! - 1);
      if (indegree.get(child) === 0) {
        ready.push(child);
        ready.sort(compare);
      }
    }
  }
  return ordered;
}

function normalizeEdgesForRenamedTable(edges: string[], oldName: string, newName: string) {
  return edges
    .map((edge) => {
      const [referencedName, referencedType, owner, dependentName, dependentType, link] = JSON.parse(edge) as [string, ObjectType, string, string, DependentType, string | null];
      return JSON.stringify([referencedType === "TABLE" && referencedName === oldName ? newName : referencedName, referencedType, owner, dependentName, dependentType, link]);
    })
    .sort();
}

async function canonicalTableSource(objectType: RewriteableDependentType, source: string, tableName: string, schema: string, databaseType: OracleTableRenameTarget["databaseType"]) {
  const marker = "DBX_TABLE_RENAME_FINGERPRINT_MARKER";
  const marked = await api.rewriteOracleTableReferences({ databaseType, objectType, schema, oldName: tableName, newName: marker, source });
  return api.rewriteOracleTableReferences({ databaseType, objectType, schema, oldName: marker, newName: tableName, source: marked });
}

async function sourceAfterEngineRename(objectType: RewriteableDependentType, source: string, oldName: string, newName: string, schema: string, databaseType: OracleTableRenameTarget["databaseType"]) {
  let withNewName = source;
  try {
    withNewName = await api.rewriteOracleTableReferences({ databaseType, objectType, schema, oldName, newName, source });
  } catch {
    // A trigger may already have its ON binding rewritten by RENAME while
    // remaining source references still use the old table name.
  }
  return canonicalTableSource(objectType, withNewName, newName, schema, databaseType);
}

function planIdentity(plan: OracleTableRenamePlan) {
  return JSON.stringify([
    plan.target,
    plan.canonicalNewName,
    plan.tableObjectId,
    plan.tableSnapshot,
    plan.dependencyEdges,
    plan.issues,
    plan.metadataComplete,
    plan.dependents.map((item) => [item.name, item.objectType, item.objectId, item.source, item.status, item.grants, item.errors, item.triggerStatus, item.triggerTable, item.draft, item.fingerprint, item.originalFingerprint, item.rewriteRequired]),
    plan.steps,
  ]);
}

export async function prepareOracleTableRename(target: OracleTableRenameTarget, drafts: Record<string, string> = {}): Promise<OracleTableRenamePlan> {
  target = { ...target };
  const plan: OracleTableRenamePlan = { target, canonicalNewName: target.newName, tableObjectId: "", tableSnapshot: null, dependents: [], dependencyEdges: [], issues: [], metadataComplete: true, executable: false, steps: [], statements: [] };
  try {
    plan.canonicalNewName = await api.parseOracleObjectName(target.newName);
    if (plan.canonicalNewName === target.oldName) issue(plan.issues, "invalid_name", "The new name matches the existing table name.");
    await checkOwner(target);
    const [oldState, newState] = await Promise.all([objectStates(target, target.oldName, ["TABLE"]), objectStates(target, plan.canonicalNewName, tableNamespaceTypes)]);
    if (oldState.length !== 1 || oldState[0][0] !== "TABLE" || oldState[0][1] == null) throw new Error(`Table ${target.oldName} is missing or has an ambiguous identity.`);
    plan.tableObjectId = String(oldState[0][1]);
    plan.tableSnapshot = await readTableSnapshot(target, target.oldName);
    if (newState.length) issue(plan.issues, "target_conflict", `An object named ${plan.canonicalNewName} already exists.`);
  } catch (error) {
    plan.metadataComplete = false;
    issue(plan.issues, /owner|current schema/i.test(errorMessage(error)) ? "owner_mismatch" : "metadata_incomplete", errorMessage(error));
  }

  const objects = new Map<string, { name: string; type: DependentType }>();
  if (plan.tableSnapshot) {
    for (const [triggerName] of JSON.parse(plan.tableSnapshot.boundTriggers) as unknown[][]) {
      const name = String(triggerName);
      const key = objectKey(name, "TRIGGER");
      if (!objects.has(key)) objects.set(key, { name, type: "TRIGGER" });
    }
  }
  const edges: string[] = [];
  const pending: Array<{ name: string; type: ObjectType }> = [{ name: target.oldName, type: "TABLE" }];
  const visited = new Set<string>();
  while (pending.length && plan.metadataComplete) {
    const reference = pending.shift()!;
    const refKey = objectKey(reference.name, reference.type);
    if (visited.has(refKey)) continue;
    if (visited.size >= metadataLimit) {
      plan.metadataComplete = false;
      issue(plan.issues, "dependency_incomplete", "The visible dependency graph exceeds the safe metadata limit.");
      break;
    }
    visited.add(refKey);
    let rows: unknown[][];
    try {
      rows = await readDependents(target, reference.name, reference.type);
    } catch (error) {
      plan.metadataComplete = false;
      issue(plan.issues, "dependency_read_failed", errorMessage(error), reference.name);
      break;
    }
    for (const row of rows) {
      const [owner, dependentName, dependentType, link] = row;
      if (typeof owner !== "string" || typeof dependentName !== "string" || typeof dependentType !== "string") {
        plan.metadataComplete = false;
        issue(plan.issues, "dependency_incomplete", `Dependency metadata for ${reference.name} is incomplete.`, reference.name);
        continue;
      }
      edges.push(JSON.stringify([reference.name, reference.type, owner, dependentName, dependentType, typeof link === "string" ? link : null]));
      if (owner !== target.schema || link || !acceptedTypes.has(dependentType as DependentType)) {
        issue(plan.issues, "unsupported_dependency", `Cannot automatically update dependent ${owner}.${dependentName} (${dependentType}${link ? `@${String(link)}` : ""}).`, dependentName);
        continue;
      }
      const type = dependentType as DependentType;
      const key = objectKey(dependentName, type);
      if (!objects.has(key)) objects.set(key, { name: dependentName, type });
      pending.push({ name: dependentName, type });
    }
  }
  plan.dependencyEdges = edges.sort();
  const order = orderDependents(objects, plan.dependencyEdges, target.schema);
  if (order.length !== objects.size) issue(plan.issues, "dependency_cycle", "The visible dependent graph contains a cycle that cannot be ordered safely.", target.oldName);

  for (const key of order) {
    const object = objects.get(key)!;
    let snapshot: DependentSnapshot;
    try {
      snapshot = await readSnapshot(target, object.name, object.type);
      if (snapshot.status !== "VALID" || snapshot.errors !== "[]") throw new Error(`${object.type} ${object.name} is not valid or has compilation errors.`);
      if (snapshot.objectType === "TRIGGER" && snapshot.triggerTable !== target.oldName) throw new Error(`Trigger ${object.name} is not bound to ${target.oldName}.`);
    } catch (error) {
      plan.metadataComplete = false;
      issue(plan.issues, "source_read_failed", errorMessage(error), object.name);
      continue;
    }
    const draft = drafts[object.name] ?? snapshot.executionSource;
    let rewrittenSource = "";
    let fingerprint = "";
    let originalFingerprint = "";
    const directDependency = plan.dependencyEdges.some((edge) => {
      const [referencedName, referencedType, owner, name, type] = JSON.parse(edge) as [string, ObjectType, string, string, DependentType];
      return referencedName === target.oldName && referencedType === "TABLE" && owner === target.schema && name === object.name && type === object.type;
    });
    try {
      if (object.type === "VIEW") {
        const originalReview = await api.reviewOracleViewRenameSource({ source: snapshot.source, owner: target.schema, viewName: object.name, oldName: target.oldName, newName: target.oldName });
        const review = await api.reviewOracleViewRenameSource({ source: draft, owner: target.schema, viewName: object.name, oldName: target.oldName, newName: directDependency ? plan.canonicalNewName : target.oldName });
        plan.issues.push(...review.issues.map((entry: OracleViewRenameIssue) => ({ code: entry.code, message: entry.message, objectName: object.name, repairable: entry.repairable })));
        const normalizeReferences = (references: typeof review.references) => references.map((reference) => JSON.stringify([reference.owner, reference.name === plan.canonicalNewName ? target.oldName : reference.name])).sort();
        const originalParseFailed = !originalReview.source && originalReview.issues.some((entry: OracleViewRenameIssue) => entry.code === "invalid_definition" || entry.code === "invalid_declaration");
        if (!review.source) throw new Error(review.issues.map((entry: OracleViewRenameIssue) => entry.message).join("; ") || `Cannot validate ${object.name}.`);
        if (originalReview.source) {
          plan.issues.push(...originalReview.issues.map((entry: OracleViewRenameIssue) => ({ code: entry.code, message: entry.message, objectName: object.name, repairable: entry.repairable })));
          if (JSON.stringify(normalizeReferences(originalReview.references)) !== JSON.stringify(normalizeReferences(review.references))) throw new Error(`The definition of ${object.name} changes its planned dependencies.`);
        } else if (originalParseFailed) {
          if (!directDependency && draft !== snapshot.executionSource) throw new Error(`A manual draft for indirect dependent ${object.name} cannot be applied by the planned compile step.`);
          const plannedNames = new Set([target.oldName, ...order.map((plannedKey) => objects.get(plannedKey)!.name)]);
          const expected = [
            ...new Set(
              edges
                .map((edge) => JSON.parse(edge) as [string, ObjectType, string, string, DependentType, string | null])
                .filter(([, , owner, name]) => owner === target.schema && name === object.name)
                .map(([name, , owner]) => JSON.stringify([owner, name])),
            ),
          ].sort();
          const actual = [
            ...new Set(
              review.references
                .filter((reference) => reference.owner === target.schema && plannedNames.has(reference.name === plan.canonicalNewName ? target.oldName : reference.name))
                .map((reference) => JSON.stringify([reference.owner, reference.name === plan.canonicalNewName ? target.oldName : reference.name])),
            ),
          ].sort();
          if (JSON.stringify(expected) !== JSON.stringify(actual)) issue(plan.issues, "manual_graph", `The proposed definition changes planned dependencies of ${object.name}.`, object.name, true);
        } else {
          plan.issues.push(...originalReview.issues.map((entry: OracleViewRenameIssue) => ({ code: entry.code, message: entry.message, objectName: object.name, repairable: entry.repairable })));
          throw new Error([...originalReview.issues, ...review.issues].map((entry: OracleViewRenameIssue) => entry.message).join("; ") || `Cannot validate ${object.name}.`);
        }
        const bindsOldTable = review.references.some((reference) => reference.owner === target.schema && reference.name === target.oldName);
        if (directDependency !== bindsOldTable) throw new Error(`The definition of ${object.name} does not match its direct table dependency.`);
        rewrittenSource = review.source.source;
        const rewrittenReview = await api.reviewOracleViewRenameSource({ source: rewrittenSource, owner: target.schema, viewName: object.name, oldName: plan.canonicalNewName, newName: plan.canonicalNewName });
        if (!rewrittenReview.source || rewrittenReview.issues.length || JSON.stringify(normalizeReferences(rewrittenReview.references)) !== JSON.stringify(normalizeReferences(review.references))) {
          throw new Error(`The rewritten definition of ${object.name} does not preserve its planned references.`);
        }
        fingerprint = review.source.fingerprint;
        originalFingerprint = originalReview.source?.fingerprint ?? "";
      } else {
        if (directDependency) {
          validateDependentDeclaration(draft, target.schema, object.name, object.type);
          validateDraftRelations(snapshot.executionSource, draft, target.schema, target.oldName, plan.canonicalNewName);
          rewrittenSource = await api.rewriteOracleTableReferences({ databaseType: target.databaseType, objectType: object.type, schema: target.schema, oldName: target.oldName, newName: plan.canonicalNewName, source: draft });
          fingerprint = await canonicalTableSource(object.type, rewrittenSource, plan.canonicalNewName, target.schema, target.databaseType);
        } else {
          rewrittenSource = draft;
          fingerprint = draft;
        }
      }
    } catch (error) {
      const message = errorMessage(error);
      const location = /line (\d+), column (\d+)/i.exec(message);
      plan.issues.push({ code: "source_rewrite_failed", message, objectName: object.name, repairable: true, ...(location ? { location: { line: Number(location[1]), column: Number(location[2]) } } : {}) });
    }
    plan.dependents.push({ ...snapshot, draft, rewrittenSource, fingerprint, originalFingerprint, rewriteRequired: directDependency });
  }

  if (plan.metadataComplete && plan.issues.length === 0) {
    plan.steps = [
      { kind: "rename", objectName: target.oldName, objectType: "TABLE", sql: `RENAME ${identifier(target.oldName)} TO ${identifier(plan.canonicalNewName)};` },
      ...plan.dependents.map((dependent) =>
        dependent.rewriteRequired
          ? { kind: "replace" as const, objectName: dependent.name, objectType: dependent.objectType, sql: dependent.rewrittenSource }
          : { kind: "compile" as const, objectName: dependent.name, objectType: dependent.objectType, sql: `ALTER ${dependent.objectType} ${identifier(target.schema)}.${identifier(dependent.name)} COMPILE;` },
      ),
    ];
    plan.statements = plan.steps.map((step) => step.sql);
    plan.executable = true;
  }
  return plan;
}

async function readTableIdentity(target: OracleTableRenameTarget, name: string) {
  const rows = await objectStates(target, name, ["TABLE"]);
  return rows.length === 1 && rows[0][0] === "TABLE" && rows[0][1] != null ? String(rows[0][1]) : null;
}

async function nameIsOccupied(target: OracleTableRenameTarget, name: string) {
  return (await objectStates(target, name, tableNamespaceTypes)).length > 0;
}

async function verifyGraph(target: OracleTableRenameTarget, plan: OracleTableRenamePlan) {
  const references: Array<{ name: string; type: ObjectType }> = [{ name: plan.canonicalNewName, type: "TABLE" }, ...plan.dependents.map((item) => ({ name: item.name, type: item.objectType }))];
  const actual: string[] = [];
  for (const reference of references) {
    for (const [owner, name, type, link] of await readDependents(target, reference.name, reference.type)) {
      actual.push(JSON.stringify([reference.name, reference.type, owner, name, type, typeof link === "string" ? link : null]));
    }
  }
  const expected = normalizeEdgesForRenamedTable(plan.dependencyEdges, plan.target.oldName, plan.canonicalNewName);
  if (JSON.stringify(actual.sort()) !== JSON.stringify(expected)) throw new Error("The visible dependency graph changed during table rename.");
}

async function verifyOriginalGraph(target: OracleTableRenameTarget, plan: OracleTableRenamePlan) {
  const references: Array<{ name: string; type: ObjectType }> = [{ name: plan.target.oldName, type: "TABLE" }, ...plan.dependents.map((item) => ({ name: item.name, type: item.objectType }))];
  const actual: string[] = [];
  for (const reference of references) {
    for (const [owner, name, type, link] of await readDependents(target, reference.name, reference.type)) {
      actual.push(JSON.stringify([reference.name, reference.type, owner, name, type, typeof link === "string" ? link : null]));
    }
  }
  if (JSON.stringify(actual.sort()) !== JSON.stringify([...plan.dependencyEdges].sort())) throw new Error("The visible dependency graph changed before table rename.");
}

async function verifyOriginalSnapshots(target: OracleTableRenameTarget, plan: OracleTableRenamePlan) {
  if (!plan.tableSnapshot || !tableSnapshotsMatch(plan.tableSnapshot, await readTableSnapshot(target, plan.target.oldName), target.schema, plan.target.oldName, plan.target.oldName)) {
    throw new Error("The original table definition, grants, indexes, constraints, foreign keys, or triggers changed before rename.");
  }
  for (const dependent of plan.dependents) {
    const actual = await readSnapshot(target, dependent.name, dependent.objectType);
    if (
      actual.objectId !== dependent.objectId ||
      actual.source !== dependent.source ||
      actual.status !== dependent.status ||
      actual.grants !== dependent.grants ||
      actual.errors !== dependent.errors ||
      actual.triggerStatus !== dependent.triggerStatus ||
      actual.triggerTable !== dependent.triggerTable
    ) {
      throw new Error(`${dependent.objectType} ${dependent.name} changed before table rename.`);
    }
  }
}

async function verifyFinalSnapshots(target: OracleTableRenameTarget, plan: OracleTableRenamePlan) {
  if (!plan.tableSnapshot || !tableSnapshotsMatch(plan.tableSnapshot, await readTableSnapshot(target, plan.canonicalNewName), target.schema, plan.target.oldName, plan.canonicalNewName)) {
    throw new Error("The renamed table definition, grants, indexes, constraints, foreign keys, or triggers changed before final verification.");
  }
  if ((await readTableIdentity(target, plan.canonicalNewName)) !== plan.tableObjectId || (await readTableIdentity(target, plan.target.oldName)) !== null) {
    throw new Error("The renamed table identity changed before final verification.");
  }
  if (await nameIsOccupied(target, plan.target.oldName)) throw new Error("The old table name was reused before final verification.");
  for (const dependent of plan.dependents) {
    const actual = await readSnapshot(target, dependent.name, dependent.objectType);
    if (actual.objectId !== dependent.objectId || actual.status !== "VALID" || actual.errors !== "[]" || actual.grants !== dependent.grants) {
      throw new Error(`${dependent.objectType} ${dependent.name} changed before final verification.`);
    }
    if (dependent.objectType === "TRIGGER" && (actual.triggerTable !== plan.canonicalNewName || actual.triggerStatus !== dependent.triggerStatus)) {
      throw new Error(`Trigger ${dependent.name} binding or enabled state changed before final verification.`);
    }
    const fingerprint =
      dependent.objectType === "VIEW"
        ? (
            await api.reviewOracleViewRenameSource({
              source: actual.source,
              owner: target.schema,
              viewName: dependent.name,
              oldName: dependent.rewriteRequired ? plan.canonicalNewName : plan.target.oldName,
              newName: dependent.rewriteRequired ? plan.canonicalNewName : plan.target.oldName,
            })
          ).source?.fingerprint
        : dependent.rewriteRequired
          ? await canonicalTableSource(dependent.objectType, actual.executionSource, plan.canonicalNewName, target.schema, target.databaseType)
          : actual.source;
    if (fingerprint !== dependent.fingerprint) throw new Error(`${dependent.objectType} ${dependent.name} definition changed before final verification.`);
  }
  await verifyGraph(target, plan);
}

async function readOnlyReconcile(target: OracleTableRenameTarget, plan: OracleTableRenamePlan, step: OracleTableRenameStep) {
  try {
    if (step.kind === "rename") {
      const newId = await readTableIdentity(target, plan.canonicalNewName);
      const oldId = await readTableIdentity(target, plan.target.oldName);
      if (newId === plan.tableObjectId && oldId === null) return "confirmed" as const;
      if (newId === null && oldId === plan.tableObjectId) return "not-confirmed" as const;
      return "unknown" as const;
    }
    const dependent = plan.dependents.find((item) => item.name === step.objectName && item.objectType === step.objectType)!;
    const actual = await readSnapshot(target, dependent.name, dependent.objectType);
    if (step.kind === "compile") {
      return actual.objectId === dependent.objectId && actual.source === dependent.source && actual.status === "VALID" && actual.errors === "[]" && actual.grants === dependent.grants ? ("confirmed" as const) : ("unknown" as const);
    }
    if (
      actual.status === "VALID" &&
      actual.errors === "[]" &&
      actual.grants === dependent.grants &&
      (dependent.objectType !== "TRIGGER" || (actual.triggerTable === plan.canonicalNewName && actual.triggerStatus === dependent.triggerStatus)) &&
      (dependent.objectType === "VIEW"
        ? (await api.reviewOracleViewRenameSource({ source: actual.source, owner: plan.target.schema, viewName: dependent.name, oldName: plan.canonicalNewName, newName: plan.canonicalNewName })).source?.fingerprint === dependent.fingerprint
        : (await canonicalTableSource(dependent.objectType, actual.executionSource, plan.canonicalNewName, plan.target.schema, plan.target.databaseType)) === dependent.fingerprint)
    )
      return "confirmed" as const;
    if (actual.objectId === dependent.objectId && actual.source === dependent.source) return "not-confirmed" as const;
    return "unknown" as const;
  } catch {
    return "unknown" as const;
  }
}

export async function executeOracleTableRename(plan: OracleTableRenamePlan, drafts: Record<string, string> = {}, isCurrent: () => boolean = () => true): Promise<void> {
  if (!isCurrent()) throw new Error("The table rename target changed. Refresh the preview.");
  if (!plan.executable) throw new Error("Resolve every table dependency issue before execution.");
  const current = await prepareOracleTableRename(plan.target, drafts);
  if (!current.executable || planIdentity(current) !== planIdentity(plan) || !isCurrent()) throw new Error("Table metadata changed. Refresh the rename preview.");
  const frozen = freezeSourceIdentities([
    { connectionId: plan.target.connectionId, database: plan.target.database, schema: plan.target.schema, objectType: "TABLE" as const, name: plan.target.oldName },
    ...plan.dependents.map((item) => ({ connectionId: plan.target.connectionId, database: plan.target.database, schema: plan.target.schema, objectType: item.objectType, name: item.name })),
  ]);
  const completed: string[] = [];
  let dispatched = false;
  let active = plan.steps[0];
  try {
    for (const step of plan.steps) {
      active = step;
      if (!isCurrent()) throw new Error("The rename dialog changed or closed; remaining steps were not sent.");
      const expectedTableId = await readTableIdentity(plan.target, step.kind === "rename" ? plan.target.oldName : plan.canonicalNewName);
      if (expectedTableId !== plan.tableObjectId) throw new Error("The original table identity changed during rename.");
      if (step.kind === "rename") {
        if (await nameIsOccupied(plan.target, plan.canonicalNewName)) throw new Error("The target table name was claimed by another session.");
        await verifyOriginalSnapshots(plan.target, plan);
        await verifyOriginalGraph(plan.target, plan);
      } else {
        if (await nameIsOccupied(plan.target, plan.target.oldName)) throw new Error("The old table name was reused by another object.");
        await verifyGraph(plan.target, plan);
        const dependent = plan.dependents.find((item) => item.name === step.objectName && item.objectType === step.objectType)!;
        const latest = await readSnapshot(plan.target, dependent.name, dependent.objectType);
        const expectedStatus = dependent.objectType === "VIEW" ? "INVALID" : dependent.status;
        if (latest.objectId !== dependent.objectId || latest.grants !== dependent.grants || (step.kind === "replace" && latest.status !== expectedStatus) || (step.kind === "compile" && (!["VALID", "INVALID"].includes(latest.status) || latest.source !== dependent.source)))
          throw new Error(`${dependent.objectType} ${dependent.name} changed after validation.`);
        if (dependent.objectType === "TRIGGER") {
          if (latest.triggerTable !== plan.canonicalNewName || latest.triggerStatus !== dependent.triggerStatus) throw new Error(`Trigger ${dependent.name} binding or enabled state changed after table rename.`);
        }
        const expectedFingerprint = dependent.objectType === "VIEW" ? dependent.originalFingerprint : dependent.fingerprint;
        if (step.kind === "replace" && dependent.objectType === "VIEW" && !expectedFingerprint && latest.source !== dependent.source) throw new Error(`${dependent.objectType} ${dependent.name} source changed after validation.`);
        if (step.kind === "compile") {
          if (latest.source !== dependent.source) throw new Error(`${dependent.objectType} ${dependent.name} source changed after validation.`);
        } else if (dependent.objectType !== "TRIGGER" && latest.source === dependent.source) {
          // RENAME does not rewrite stored routine source. Preserve the exact
          // original snapshot check when its unsupported syntax prevented a
          // canonical reference fingerprint; the validated draft is still
          // the only source sent by the following replace step.
        } else {
          const latestFingerprint =
            dependent.objectType === "VIEW"
              ? ((await api.reviewOracleViewRenameSource({ source: latest.source, owner: plan.target.schema, viewName: dependent.name, oldName: plan.target.oldName, newName: plan.target.oldName })).source?.fingerprint ?? "")
              : await sourceAfterEngineRename(dependent.objectType, latest.executionSource, plan.target.oldName, plan.canonicalNewName, plan.target.schema, plan.target.databaseType);
          if (latestFingerprint !== expectedFingerprint) throw new Error(`${dependent.objectType} ${dependent.name} source changed after validation.`);
        }
      }
      if (!isCurrent()) throw new Error("The rename dialog changed or closed; remaining steps were not sent.");
      if (!dispatched) {
        frozen.markDispatched();
        dispatched = true;
      }
      try {
        await query(plan.target, step.sql);
      } catch (error) {
        const reconciliation = await readOnlyReconcile(plan.target, plan, step);
        throw new OracleTableRenameFailure(plan, completed, `${step.objectType} ${step.objectName}`, reconciliation, error);
      }

      if (step.kind === "rename") {
        const newId = await readTableIdentity(plan.target, plan.canonicalNewName);
        const oldId = await readTableIdentity(plan.target, plan.target.oldName);
        if (newId !== plan.tableObjectId || oldId !== null) throw new Error("The table rename did not preserve the original identity at the new name.");
        await verifyGraph(plan.target, plan);
        completed.push(`TABLE ${plan.canonicalNewName}`);
        continue;
      }

      const dependent = plan.dependents.find((item) => item.name === step.objectName && item.objectType === step.objectType)!;
      const actual = await readSnapshot(plan.target, dependent.name, dependent.objectType);
      if (actual.status !== "VALID" || actual.errors !== "[]" || actual.grants !== dependent.grants) throw new Error(`${dependent.objectType} ${dependent.name} did not preserve validity, errors, and grants.`);
      if (dependent.objectType === "TRIGGER" && (actual.triggerTable !== plan.canonicalNewName || actual.triggerStatus !== dependent.triggerStatus)) throw new Error(`Trigger ${dependent.name} did not preserve table binding and enabled state.`);
      if (step.kind === "compile") {
        if (actual.objectId !== dependent.objectId || actual.source !== dependent.source) throw new Error(`${dependent.objectType} ${dependent.name} did not retain its validated identity and definition after compilation.`);
        await verifyGraph(plan.target, plan);
        completed.push(`${dependent.objectType} ${dependent.name}`);
        continue;
      }
      const actualFingerprint =
        dependent.objectType === "VIEW"
          ? (await api.reviewOracleViewRenameSource({ source: actual.source, owner: plan.target.schema, viewName: dependent.name, oldName: plan.canonicalNewName, newName: plan.canonicalNewName })).source?.fingerprint
          : await canonicalTableSource(dependent.objectType, actual.executionSource, plan.canonicalNewName, plan.target.schema, plan.target.databaseType);
      if (actualFingerprint !== dependent.fingerprint) throw new Error(`${dependent.objectType} ${dependent.name} does not match the approved replacement source.`);
      if (dependent.objectType === "VIEW") dependent.objectId = actual.objectId;
      else if (actual.objectId !== dependent.objectId) throw new Error(`${dependent.objectType} ${dependent.name} identity changed unexpectedly.`);
      await verifyGraph(plan.target, plan);
      completed.push(`${dependent.objectType} ${dependent.name}`);
    }
    await verifyFinalSnapshots(plan.target, plan);
  } catch (error) {
    if (error instanceof OracleTableRenameFailure) throw error;
    if (dispatched) {
      const reconciliation = await readOnlyReconcile(plan.target, plan, active);
      throw new OracleTableRenameFailure(plan, completed, `${active.objectType} ${active.objectName}`, reconciliation, error);
    }
    throw error;
  } finally {
    if (dispatched) {
      const scope = { connectionId: plan.target.connectionId, database: plan.target.database, schema: plan.target.schema };
      invalidateObjectBrowserRowsCache(scope);
      await Promise.allSettled([...new Set([plan.target.oldName, plan.canonicalNewName, ...plan.dependents.map((item) => item.name)])].map((tableName) => invalidateObjectDdlCache({ ...scope, tableName })));
      frozen.finish();
    } else frozen.cancel();
  }
}