From 538aeed99c483923e3be52222f369c640dc04fe6 Mon Sep 17 00:00:00 2001
From: HolyeTyrone <43714994+HolyeTyrone@users.noreply.github.com>
Date: Tue, 8 Sep 2026 16:46:39 +0800
Subject: [PATCH] feat(transfer): add rebuild structure and data mode

---
 .gitignore                                    |    1 +
 .../components/editor/DangerConfirmDialog.vue |    2 +-
 .../transfer/DataTransferDialog.vue           |  261 ++-
 .../__tests__/transferStrategy.spec.ts        |  301 ++++
 .../components/transfer/transferStrategy.ts   |   97 ++
 apps/desktop/src/i18n/locales/en.ts           |   11 +-
 apps/desktop/src/i18n/locales/es.ts           |   13 +-
 apps/desktop/src/i18n/locales/it.ts           |   11 +-
 apps/desktop/src/i18n/locales/ja.ts           |   11 +-
 apps/desktop/src/i18n/locales/ko.ts           |   13 +-
 apps/desktop/src/i18n/locales/pt-BR.ts        |   13 +-
 apps/desktop/src/i18n/locales/zh-CN.ts        |   13 +-
 apps/desktop/src/i18n/locales/zh-TW.ts        |   13 +-
 apps/desktop/src/lib/backend/tauri.ts         |    7 +
 .../__tests__/transferTaskStore.spec.ts       |   31 +
 apps/desktop/src/stores/transferTaskStore.ts  |    9 +-
 apps/desktop/src/types/database.ts            |    4 +
 crates/dbx-core/src/db_admin_sql.rs           |  102 +-
 crates/dbx-core/src/lib.rs                    |    1 +
 crates/dbx-core/src/script_generator.rs       |   21 +
 .../dbx-core/src/sql_dialect/ddl_profile.rs   |  154 +-
 crates/dbx-core/src/transfer.rs               | 1483 +++++++++++++----
 crates/dbx-core/src/transfer/ddl_plan.rs      |  420 +++++
 crates/dbx-core/src/transfer/rebuild_tests.rs |  116 ++
 crates/dbx-core/src/transfer_rebuild.rs       | 1476 ++++++++++++++++
 crates/dbx-core/tests/live_mysql_transfer.rs  |  909 ++++++++++
 .../dbx-core/tests/live_postgres_transfer.rs  |  582 ++++++-
 .../tests/live_sqlserver_completion.rs        |    3 +
 .../dbx-core/tests/live_sqlserver_transfer.rs |  284 ++++
 crates/dbx-web/src/routes/transfer.rs         |  127 +-
 docs/content/docs/data-transfer.cn.mdx        |    3 +
 docs/content/docs/data-transfer.mdx           |    3 +
 docs/content/docs/production-safety.cn.mdx    |    1 +
 docs/content/docs/production-safety.mdx       |    1 +
 .../2026-09-03-transfer-drop-before-create.md |  400 +++++
 .../2026-09-07-transfer-rebuild-hardening.md  |  102 ++
 src-tauri/src/commands/transfer.rs            |  125 +-
 37 files changed, 6720 insertions(+), 404 deletions(-)
 create mode 100644 apps/desktop/src/components/transfer/__tests__/transferStrategy.spec.ts
 create mode 100644 apps/desktop/src/components/transfer/transferStrategy.ts
 create mode 100644 crates/dbx-core/src/transfer/ddl_plan.rs
 create mode 100644 crates/dbx-core/src/transfer/rebuild_tests.rs
 create mode 100644 crates/dbx-core/src/transfer_rebuild.rs
 create mode 100644 crates/dbx-core/tests/live_sqlserver_transfer.rs
 create mode 100644 docs/pips/plans/2026-09-03-transfer-drop-before-create.md
 create mode 100644 docs/pips/plans/2026-09-07-transfer-rebuild-hardening.md

diff --git a/.gitignore b/.gitignore
index 29987aa919..ea8c1f5f91 100644
--- a/.gitignore
+++ b/.gitignore
@@ -70,6 +70,7 @@ tmp/
 .dlp-quarantine/
 outputs/
 target-ai-write-confirmation/
+.serena/
 
 # Code review tool artifacts
 review_diff.json
diff --git a/apps/desktop/src/components/editor/DangerConfirmDialog.vue b/apps/desktop/src/components/editor/DangerConfirmDialog.vue
index b2da011e2e..d3c2464f25 100644
--- a/apps/desktop/src/components/editor/DangerConfirmDialog.vue
+++ b/apps/desktop/src/components/editor/DangerConfirmDialog.vue
@@ -146,7 +146,7 @@ async function copyFullCode() {
 
       <div class="py-4 min-w-0">
         <p class="text-sm text-muted-foreground mb-3">{{ message || t("dangerDialog.message") }}</p>
-        <p v-if="detailsText" class="text-xs text-muted-foreground mb-3 whitespace-pre-line">{{ detailsText }}</p>
+        <p v-if="detailsText" class="text-xs text-muted-foreground mb-3 whitespace-pre-line max-h-40 overflow-auto">{{ detailsText }}</p>
         <slot name="options" />
         <div v-if="code" data-testid="danger-code-container" class="min-w-0">
           <div data-testid="danger-code-actions" class="mb-1 flex items-center justify-end gap-0.5">
diff --git a/apps/desktop/src/components/transfer/DataTransferDialog.vue b/apps/desktop/src/components/transfer/DataTransferDialog.vue
index 2161fa5219..0900b40ae1 100644
--- a/apps/desktop/src/components/transfer/DataTransferDialog.vue
+++ b/apps/desktop/src/components/transfer/DataTransferDialog.vue
@@ -1,11 +1,12 @@
 <script setup lang="ts">
-import { computed, ref, watch } from "vue";
+import { computed, onBeforeUnmount, ref, shallowRef, watch } from "vue";
 import { uuid } from "@/lib/common/utils";
 import { useI18n } from "vue-i18n";
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
 import { Button } from "@/components/ui/button";
 import { buildTransferObjectSelections } from "./transferSelections";
 import { createTaskLoadTracker } from "./taskLoadTracker";
+import { confirmTransferWithProductionSafety, createTransferSubmission, rebuildUnavailableReason, resolveTransferStrategy, transferStrategyOptions, type TransferStrategy } from "./transferStrategy";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
@@ -14,11 +15,13 @@ import SearchableSelect from "@/components/ui/searchable-select/SearchableSelect
 import ConnectionTreeSelect from "@/components/connection/ConnectionTreeSelect.vue";
 import { useConnectionStore } from "@/stores/connectionStore";
 import { ensureReadOnlyWriteAccess } from "@/lib/database/readOnlyWriteAccess";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
 import * as api from "@/lib/backend/api";
-import type { TransferContent, TransferMode, TransferObjectKind, TransferTableNameCase } from "@/lib/backend/api";
+import type { TransferContent, TransferObjectKind, TransferTableNameCase } from "@/lib/backend/api";
 import { crossFamilyTransferableKinds, isSameTransferFamily, transferObjectKindsForDatabase } from "@/lib/database/transferObjectKinds";
 import ObjectSelectionTree from "@/components/transfer/ObjectSelectionTree.vue";
 import TransferTaskTree from "@/components/transfer/TransferTaskTree.vue";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
 import type { DatabaseType } from "@/types/database";
 import type { TransferTask, TransferTaskConfig } from "@/types/database";
 import { isSchemaAware, supportsTransfer } from "@/lib/database/databaseCapabilities";
@@ -37,6 +40,7 @@ const { t } = useI18n();
 const { startDataTransferTask } = useExportTracker();
 const { toast } = useToast();
 const taskStore = useTransferTaskStore();
+const productionSafetyStore = useProductionSafetyStore();
 const open = defineModel<boolean>("open", { default: false });
 
 const props = defineProps<{
@@ -155,17 +159,34 @@ const targetSchema = ref("");
 const pendingTargetSchemaPrefill = ref("");
 
 // Options
-const transferMode = ref<TransferMode>("append");
+const selectedStrategy = ref<TransferStrategy>("append");
+const targetTableStrategy = computed<TransferStrategy>({
+  get: () => (transferContent.value === "structureOnly" && selectedStrategy.value !== "rebuild" ? "append" : selectedStrategy.value),
+  set: (value) => {
+    selectedStrategy.value = value;
+  },
+});
 const targetTableNameCase = ref<TransferTableNameCase>("preserve");
 const quoteTargetColumnNames = ref(true);
 const batchSize = ref(1000);
+const showRebuildConfirm = ref(false);
 const isSubmitting = ref(false);
+const pendingTransferId = ref<string | null>(null);
 const showStartConfirm = ref(false);
+const confirmationRequest = shallowRef<api.TransferRequest | null>(null);
+const confirmationPreview = shallowRef<api.TransferOwnershipPreview | null>(null);
+let resolveTransferConfirmation: ((confirmed: boolean) => void) | undefined;
 const ownershipDialogOpen = ref(false);
 const ownershipMissingOwners = ref<string[]>([]);
 const ownershipTargetOwner = ref("");
-const pendingOwnershipRequest = ref<api.TransferRequest | null>(null);
-const pendingOwnershipRefresh = ref<{ shouldRefreshTargetTree: boolean } | null>(null);
+let resolveOwnershipConfirmation: ((policy: api.TransferOwnershipPolicy | null) => void) | undefined;
+const transferSubmission = createTransferSubmission({
+  ensureWritable: (request) => ensureReadOnlyWriteAccess({ connection: store.getConfig(request.targetConnectionId), source: t("readOnlyUnlock.sourceTransfer"), treatAsMutation: true }),
+  preview: api.previewTransferOwnership,
+  confirmOwnership: requestOwnershipConfirmation,
+  confirm: requestTransferConfirmation,
+  execute: (request) => runTransfer(request, request.content !== "dataOnly"),
+});
 
 // Saved-task state: the form mirrors the active task; a canonical JSON
 // snapshot taken at load/save time drives the unsaved-changes check.
@@ -186,6 +207,13 @@ function isMongoConnection(id: string): boolean {
 
 const showTargetColumnQuoteOption = computed(() => ["gaussdb", "opengauss"].includes(connectionType(targetConnectionId.value) ?? ""));
 
+const rebuildDisabledReason = computed(() => rebuildUnavailableReason(transferContent.value, connectionType(targetConnectionId.value)));
+const rebuildDisabledHint = computed(() => {
+  if (rebuildDisabledReason.value === "dataOnly") return t("transfer.rebuildDataOnlyDisabled");
+  if (rebuildDisabledReason.value === "unsupported") return t("transfer.rebuildUnsupportedDisabled");
+  return "";
+});
+
 function isCatalogCapable(id: string): boolean {
   const config = store.getConfig(id);
   return isDorisFamilyCatalogCapable(config?.db_type, config?.driver_profile);
@@ -225,6 +253,7 @@ const canStart = computed(() => {
     (sourceCatalogs.value.length <= 1 || !!sourceCatalog.value) &&
     (targetCatalogs.value.length <= 1 || !!targetCatalog.value) &&
     (selectedTables.value.size > 0 || Object.values(selectedObjects.value).some((names) => names.size > 0)) &&
+    (targetTableStrategy.value !== "rebuild" || !rebuildDisabledReason.value) &&
     !sameSourceAndTarget
   );
 });
@@ -620,6 +649,7 @@ watch(
 
 function resetState(cancelTaskLoad = true) {
   if (cancelTaskLoad) taskLoadTracker.cancel();
+  cancelPendingTransfer();
   sourceConnectionId.value = "";
   sourceCatalog.value = "";
   sourceCatalogs.value = [];
@@ -642,17 +672,10 @@ function resetState(cancelTaskLoad = true) {
   targetSchema.value = "";
   pendingTargetSchemaPrefill.value = "";
   transferContent.value = "structureAndData";
-  transferMode.value = "append";
+  selectedStrategy.value = "append";
   targetTableNameCase.value = "preserve";
   quoteTargetColumnNames.value = true;
   batchSize.value = 1000;
-  isSubmitting.value = false;
-  showStartConfirm.value = false;
-  ownershipDialogOpen.value = false;
-  ownershipMissingOwners.value = [];
-  ownershipTargetOwner.value = "";
-  pendingOwnershipRequest.value = null;
-  pendingOwnershipRefresh.value = null;
   pendingSelectedObjectsPrefill.value = null;
   activeTaskId.value = null;
   savedConfigSnapshot.value = "";
@@ -740,11 +763,8 @@ function swapSourceAndTarget() {
   void loadObjects();
 }
 
-async function startTransfer() {
+async function requestStartTransfer() {
   if (!canStart.value || isSubmitting.value) return;
-  if (!(await ensureReadOnlyWriteAccess({ connection: store.getConfig(targetConnectionId.value), source: t("readOnlyUnlock.sourceTransfer"), treatAsMutation: true }))) {
-    return;
-  }
   isSubmitting.value = true;
 
   const effectiveSourceSchema = sourceSchema.value || sourceDatabaseName.value;
@@ -752,8 +772,6 @@ async function startTransfer() {
   const sourceDatabase = sourceDatabaseName.value;
   const targetConnection = targetConnectionId.value;
   const targetDatabase = targetDatabaseName.value;
-  const shouldRefreshTargetTree = transferContent.value !== "dataOnly";
-
   const request: api.TransferRequest = {
     transferId: uuid(),
     sourceConnectionId: sourceConnectionId.value,
@@ -768,34 +786,25 @@ async function startTransfer() {
     createTable: transferContent.value !== "dataOnly",
     content: transferContent.value,
     objects: buildTransferObjectSelections(selectedObjects.value, treeDisabledGroups.value),
-    mode: transferMode.value,
+    ...transferStrategyOptions(targetTableStrategy.value),
     targetTableNameCase: targetTableNameCase.value,
     quoteTargetColumnNames: quoteTargetColumnNames.value,
     ownershipPolicy: "preserve",
     batchSize: batchSize.value,
+    dropTargetConfirmed: false,
   };
-
-  if (transferContent.value !== "dataOnly") {
-    try {
-      const preview = await api.previewTransferOwnership(request);
-      if (preview.missingOwners.length > 0) {
-        ownershipMissingOwners.value = preview.missingOwners;
-        ownershipTargetOwner.value = preview.targetOwner;
-        pendingOwnershipRequest.value = request;
-        pendingOwnershipRefresh.value = {
-          shouldRefreshTargetTree,
-        };
-        ownershipDialogOpen.value = true;
-        isSubmitting.value = false;
-        return;
-      }
-    } catch {
+  pendingTransferId.value = request.transferId;
+  try {
+    await transferSubmission.start(request);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    toast(message === "TRANSFER_REBUILD_PREVIEW_UNAVAILABLE" ? t("transfer.rebuildPreviewUnavailable") : t("transfer.previewFailed", { message }), 5000);
+  } finally {
+    if (pendingTransferId.value === request.transferId) {
+      pendingTransferId.value = null;
       isSubmitting.value = false;
-      return;
     }
   }
-
-  runTransfer(request, shouldRefreshTargetTree);
 }
 
 function runTransfer(request: api.TransferRequest, shouldRefreshTargetTree: boolean) {
@@ -812,19 +821,22 @@ function runTransfer(request: api.TransferRequest, shouldRefreshTargetTree: bool
   resetState();
 }
 
+function requestOwnershipConfirmation(preview: api.TransferOwnershipPreview): Promise<api.TransferOwnershipPolicy | null> {
+  ownershipMissingOwners.value = preview.missingOwners;
+  ownershipTargetOwner.value = preview.targetOwner;
+  ownershipDialogOpen.value = true;
+  return new Promise((resolve) => {
+    resolveOwnershipConfirmation = resolve;
+  });
+}
+
 function resolveOwnershipDecision(policy: api.TransferOwnershipPolicy | null) {
-  const request = pendingOwnershipRequest.value;
-  const refresh = pendingOwnershipRefresh.value;
-  pendingOwnershipRequest.value = null;
-  pendingOwnershipRefresh.value = null;
+  const resolve = resolveOwnershipConfirmation;
+  resolveOwnershipConfirmation = undefined;
   ownershipDialogOpen.value = false;
   ownershipMissingOwners.value = [];
   ownershipTargetOwner.value = "";
-  if (!policy || !request || !refresh) {
-    isSubmitting.value = false;
-    return;
-  }
-  runTransfer({ ...request, ownershipPolicy: policy }, refresh.shouldRefreshTargetTree);
+  resolve?.(policy);
 }
 
 function getConnectionName(id: string) {
@@ -854,10 +866,11 @@ function currentConfig(): TransferTaskConfig {
     targetSchema: targetSchema.value || undefined,
     objects,
     content: transferContent.value,
-    mode: transferMode.value,
+    ...transferStrategyOptions(targetTableStrategy.value),
     targetTableNameCase: targetTableNameCase.value,
     quoteTargetColumnNames: quoteTargetColumnNames.value,
     batchSize: batchSize.value,
+    dropTargetConfirmed: false,
   };
 }
 
@@ -875,6 +888,27 @@ const isConfigDirty = computed(() => !!activeTaskId.value && configSnapshot(curr
 const needsDiscardConfirm = computed(() => isConfigDirty.value || (!activeTaskId.value && formHasContent.value));
 const canSaveConfig = computed(() => !!sourceConnectionId.value && isTransferDatabaseSelected(sourceDatabase.value) && !!targetConnectionId.value && isTransferDatabaseSelected(targetDatabase.value));
 
+// Invalidate before asynchronous callbacks can publish a preview for an old form,
+// including a task switch whose new values happen to equal the previous task.
+watch(() => configSnapshot(currentConfig()), cancelPendingTransfer, { flush: "sync" });
+watch(activeTaskId, cancelPendingTransfer, { flush: "sync" });
+watch(
+  open,
+  (isOpen) => {
+    if (!isOpen) cancelPendingTransfer();
+  },
+  { flush: "sync" },
+);
+watch(
+  () => {
+    const connection = store.getConfig(targetConnectionId.value);
+    return JSON.stringify([connection?.read_only, connection?.is_production, connection?.production_databases]);
+  },
+  cancelPendingTransfer,
+  { flush: "sync" },
+);
+onBeforeUnmount(cancelPendingTransfer);
+
 /** Applies a saved task to the form, loading catalogs/databases/schemas/objects with explicit awaits. */
 async function loadTaskIntoForm(task: TransferTask) {
   const taskLoadToken = taskLoadTracker.begin(task.id);
@@ -883,7 +917,7 @@ async function loadTaskIntoForm(task: TransferTask) {
   resetState(false);
   activeTaskId.value = task.id;
   transferContent.value = config.content;
-  transferMode.value = config.mode;
+  selectedStrategy.value = resolveTransferStrategy(config);
   targetTableNameCase.value = config.targetTableNameCase;
   quoteTargetColumnNames.value = config.quoteTargetColumnNames;
   batchSize.value = config.batchSize;
@@ -1000,26 +1034,93 @@ function onSelectedTaskIdUpdate(id: string | null) {
   activeTaskId.value = id;
 }
 
-// ---- start confirmation (guards the only run entry: the footer button) ----
+// ---- confirmation for the immutable, previewed transfer request ----
 
-/** Number of objects currently selected across all kinds. */
-const selectedObjectCount = computed(() => Object.values(selectedObjects.value).reduce((total, names) => total + (names?.size ?? 0), 0));
-
-const startConfirmSource = computed(() => `${getConnectionName(sourceConnectionId.value)}.${databaseOptionLabel(sourceConnectionId.value, sourceDatabase.value)}`);
-const startConfirmTarget = computed(() => `${getConnectionName(targetConnectionId.value)}.${databaseOptionLabel(targetConnectionId.value, targetDatabase.value)}`);
-
-/** Opens the confirmation dialog before starting a transfer. */
-function requestStartTransfer() {
-  if (!canStart.value || isSubmitting.value) return;
-  showStartConfirm.value = true;
+function transferStrategyLabel(request: api.TransferRequest): string {
+  if (request.content === "structureOnly") return t(request.dropTargetBeforeCreate ? "transfer.modeRebuildStructure" : "transfer.modeKeepExisting");
+  const strategy = resolveTransferStrategy(request);
+  const keys = { append: "modeAppend", overwrite: "modeOverwrite", upsert: "modeUpsert", rebuild: "modeRebuild" };
+  return t(`transfer.${keys[strategy]}`);
 }
 
-/** Confirmed: close the prompt and run the normal start flow. */
-function confirmStartTransfer() {
+const confirmationSummary = computed(() => {
+  const request = confirmationRequest.value;
+  if (!request) return "";
+  const source = `${getConnectionName(request.sourceConnectionId)}.${request.sourceDatabase}.${request.sourceSchema}`;
+  const target = `${getConnectionName(request.targetConnectionId)}.${request.targetDatabase}.${request.targetSchema}`;
+  const count = request.objects.reduce((total, selection) => total + selection.names.length, 0);
+  return t("transfer.startConfirmMessage", { source, target, count });
+});
+
+const confirmationStrategy = computed(() => (confirmationRequest.value ? transferStrategyLabel(confirmationRequest.value) : ""));
+const rebuildConfirmationDetails = computed(() => {
+  const rebuild = confirmationPreview.value?.rebuild;
+  if (!rebuild) return "";
+  return [confirmationSummary.value, t("transfer.rebuildSummary", { count: rebuild.tables.length }), ...rebuild.warnings].filter(Boolean).join("\n");
+});
+
+function requestTransferConfirmation(request: api.TransferRequest, preview: api.TransferOwnershipPreview): Promise<boolean> {
+  confirmationRequest.value = request;
+  confirmationPreview.value = preview;
+  const reviewText = preview.rebuild
+    ? [confirmationStrategy.value, rebuildConfirmationDetails.value, preview.rebuild.sql].filter(Boolean).join("\n\n")
+    : [confirmationSummary.value, `${t("transfer.targetTableHandling")}: ${confirmationStrategy.value}`, ...request.objects.map((selection) => selection.names.join(", "))].join("\n");
+  return confirmTransferWithProductionSafety({
+    request,
+    connection: store.getConfig(request.targetConnectionId),
+    reviewText,
+    source: t("transfer.title"),
+    confirm: () =>
+      new Promise((resolve) => {
+        resolveTransferConfirmation = resolve;
+        if (request.dropTargetBeforeCreate) showRebuildConfirm.value = true;
+        else showStartConfirm.value = true;
+      }),
+  });
+}
+
+function resolveStartDecision(confirmed: boolean) {
+  const resolve = resolveTransferConfirmation;
+  resolveTransferConfirmation = undefined;
   showStartConfirm.value = false;
-  void startTransfer();
+  showRebuildConfirm.value = false;
+  resolve?.(confirmed);
 }
 
+function cancelPendingTransfer() {
+  transferSubmission.cancel();
+  const scopeId = pendingTransferId.value;
+  pendingTransferId.value = null;
+  if (scopeId) productionSafetyStore.cancelScope(scopeId);
+  resolveStartDecision(false);
+  resolveOwnershipDecision(null);
+  confirmationRequest.value = null;
+  confirmationPreview.value = null;
+  isSubmitting.value = false;
+}
+
+watch(
+  showStartConfirm,
+  (isOpen) => {
+    if (!isOpen) resolveStartDecision(false);
+  },
+  { flush: "sync" },
+);
+watch(
+  showRebuildConfirm,
+  (isOpen) => {
+    if (!isOpen) resolveStartDecision(false);
+  },
+  { flush: "sync" },
+);
+watch(
+  ownershipDialogOpen,
+  (isOpen) => {
+    if (!isOpen) resolveOwnershipDecision(null);
+  },
+  { flush: "sync" },
+);
+
 /** Saves the form into the active task, or creates a new one and starts its rename. */
 async function saveConfigTask() {
   if (!canSaveConfig.value) return;
@@ -1245,19 +1346,21 @@ async function saveConfigTask() {
                   </label>
                 </div>
               </div>
-              <div v-if="transferContent !== 'structureOnly'" class="flex items-center gap-3">
-                <Label class="text-xs shrink-0">{{ t("transfer.dataWriteMode") }}</Label>
-                <Select v-model="transferMode">
+              <div class="flex items-center gap-3">
+                <Label class="text-xs shrink-0">{{ t("transfer.targetTableHandling") }}</Label>
+                <Select v-model="targetTableStrategy">
                   <SelectTrigger class="h-7 text-xs">
                     <SelectValue />
                   </SelectTrigger>
                   <SelectContent>
-                    <SelectItem value="append">{{ t("transfer.modeAppend") }}</SelectItem>
-                    <SelectItem value="overwrite">{{ t("transfer.modeOverwrite") }}</SelectItem>
-                    <SelectItem value="upsert">{{ t("transfer.modeUpsert") }}</SelectItem>
+                    <SelectItem value="append">{{ t(transferContent === "structureOnly" ? "transfer.modeKeepExisting" : "transfer.modeAppend") }}</SelectItem>
+                    <SelectItem v-if="transferContent !== 'structureOnly'" value="overwrite">{{ t("transfer.modeOverwrite") }}</SelectItem>
+                    <SelectItem v-if="transferContent !== 'structureOnly'" value="upsert">{{ t("transfer.modeUpsert") }}</SelectItem>
+                    <SelectItem value="rebuild" :disabled="!!rebuildDisabledReason">{{ t(transferContent === "structureOnly" ? "transfer.modeRebuildStructure" : "transfer.modeRebuild") }}</SelectItem>
                   </SelectContent>
                 </Select>
               </div>
+              <p v-if="rebuildDisabledHint" class="text-xs text-muted-foreground">{{ rebuildDisabledHint }}</p>
               <div class="flex items-center gap-3">
                 <Label class="text-xs shrink-0">{{ t("transfer.targetTableNameCase") }}</Label>
                 <Select v-model="targetTableNameCase">
@@ -1324,20 +1427,32 @@ async function saveConfigTask() {
       <DialogHeader>
         <DialogTitle>{{ t("transfer.startConfirmTitle") }}</DialogTitle>
         <DialogDescription>
-          {{ t("transfer.startConfirmMessage", { source: startConfirmSource, target: startConfirmTarget, count: selectedObjectCount }) }}
+          {{ confirmationSummary }}
         </DialogDescription>
       </DialogHeader>
+      <p class="text-xs text-muted-foreground">{{ t("transfer.targetTableHandling") }}: {{ confirmationStrategy }}</p>
       <DialogFooter class="gap-2">
-        <Button variant="outline" size="sm" @click="showStartConfirm = false">
+        <Button variant="outline" size="sm" @click="resolveStartDecision(false)">
           {{ t("transfer.cancel") }}
         </Button>
-        <Button size="sm" @click="confirmStartTransfer">
+        <Button size="sm" @click="resolveStartDecision(true)">
           {{ t("transfer.start") }}
         </Button>
       </DialogFooter>
     </DialogContent>
   </Dialog>
 
+  <DangerConfirmDialog
+    v-model:open="showRebuildConfirm"
+    :sql="confirmationPreview?.rebuild?.sql"
+    :title="confirmationStrategy"
+    :message="t('transfer.rebuildDanger')"
+    :details-text="rebuildConfirmationDetails"
+    :confirm-label="t('transfer.start')"
+    :close-on-confirm="false"
+    @confirm="resolveStartDecision(true)"
+  />
+
   <Dialog v-model:open="ownershipDialogOpen">
     <DialogContent class="sm:max-w-[520px]" @interact-outside.prevent>
       <DialogHeader>
diff --git a/apps/desktop/src/components/transfer/__tests__/transferStrategy.spec.ts b/apps/desktop/src/components/transfer/__tests__/transferStrategy.spec.ts
new file mode 100644
index 0000000000..cc627fb934
--- /dev/null
+++ b/apps/desktop/src/components/transfer/__tests__/transferStrategy.spec.ts
@@ -0,0 +1,301 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { TransferOwnershipPreview, TransferRequest } from "@/lib/backend/api";
+import type { ConnectionConfig } from "@/types/database";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import { confirmTransferWithProductionSafety, createTransferSubmission, rebuildUnavailableReason, resolveTransferStrategy, transferStrategyOptions } from "../transferStrategy";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+function request(overrides: Partial<TransferRequest> = {}): TransferRequest {
+  return {
+    transferId: "transfer-1",
+    sourceConnectionId: "source",
+    sourceDatabase: "app",
+    sourceSchema: "public",
+    targetConnectionId: "target",
+    targetDatabase: "warehouse",
+    targetSchema: "reporting",
+    tables: ["Orders"],
+    objects: [{ objectType: "TABLE", names: ["Orders"] }],
+    createTable: true,
+    content: "structureAndData",
+    mode: "append",
+    targetTableNameCase: "lower",
+    quoteTargetColumnNames: true,
+    ownershipPolicy: "preserve",
+    batchSize: 1000,
+    dropTargetBeforeCreate: true,
+    dropTargetConfirmed: false,
+    ...overrides,
+  };
+}
+
+function preview(overrides: Partial<TransferOwnershipPreview> = {}): TransferOwnershipPreview {
+  return {
+    missingOwners: [],
+    targetOwner: "target_user",
+    rebuild: {
+      sql: 'ALTER TABLE "reporting"."orders" RENAME TO "orders__dbx_bak_123";\nCREATE TABLE "reporting"."orders" ("id" INTEGER);',
+      tables: [{ sourceTable: "Orders", targetTable: '"reporting"."orders"', backupTable: '"reporting"."orders__dbx_bak_123"' }],
+      warnings: ["Target-only metadata will be replaced"],
+    },
+    ...overrides,
+  };
+}
+
+describe("transfer strategies", () => {
+  it.each(["append", "overwrite", "upsert"] as const)("loads legacy %s plus rebuild as rebuild", (mode) => {
+    expect(resolveTransferStrategy({ mode, dropTargetBeforeCreate: true })).toBe("rebuild");
+  });
+
+  it.each([
+    ["append", { mode: "append", dropTargetBeforeCreate: false }],
+    ["overwrite", { mode: "overwrite", dropTargetBeforeCreate: false }],
+    ["upsert", { mode: "upsert", dropTargetBeforeCreate: false }],
+    ["rebuild", { mode: "append", dropTargetBeforeCreate: true }],
+  ] as const)("maps %s to one backend strategy", (strategy, options) => {
+    expect(transferStrategyOptions(strategy)).toEqual(options);
+    expect(resolveTransferStrategy(options)).toBe(strategy);
+  });
+
+  it("defaults legacy tasks without strategy fields to append", () => {
+    expect(resolveTransferStrategy({})).toBe("append");
+  });
+
+  it.each([
+    ["dataOnly", "postgres", "dataOnly"],
+    ["structureAndData", "mongodb", "unsupported"],
+    ["structureOnly", "postgres", undefined],
+    ["structureAndData", "sqlite", undefined],
+    ["structureAndData", undefined, "unsupported"],
+  ] as const)("explains rebuild availability for %s and %s", (content, type, reason) => {
+    expect(rebuildUnavailableReason(content, type)).toBe(reason);
+  });
+});
+
+describe("transfer submission", () => {
+  it("reviews backend SQL and executes the frozen request only after confirmation", async () => {
+    const decision = deferred<boolean>();
+    const reviewed: Array<{ request: TransferRequest; preview: TransferOwnershipPreview }> = [];
+    const executions: TransferRequest[] = [];
+    const previews: TransferRequest[] = [];
+    const submission = createTransferSubmission({
+      preview: async (value) => {
+        previews.push(value);
+        return preview();
+      },
+      confirmOwnership: async () => "preserve",
+      confirm: (value, plan) => {
+        reviewed.push({ request: value, preview: plan });
+        return decision.promise;
+      },
+      execute: (value) => {
+        executions.push(value);
+      },
+    });
+    const input = request({ mode: "upsert", dropTargetConfirmed: true });
+
+    const pending = submission.start(input);
+    input.targetDatabase = "changed";
+    input.tables.push("Unreviewed");
+    input.objects[0]!.names.push("Unreviewed");
+    await vi.waitFor(() => expect(reviewed).toHaveLength(1));
+
+    expect(previews[0]).toMatchObject({ transferId: "transfer-1", targetDatabase: "warehouse", mode: "append", tables: ["Orders"], objects: [{ objectType: "TABLE", names: ["Orders"] }], dropTargetConfirmed: false });
+    expect(() => previews[0]!.tables.push("Mutated")).toThrow();
+    expect(reviewed[0]?.preview.rebuild?.sql).toBe('ALTER TABLE "reporting"."orders" RENAME TO "orders__dbx_bak_123";\nCREATE TABLE "reporting"."orders" ("id" INTEGER);');
+    expect(executions).toEqual([]);
+
+    decision.resolve(true);
+    await expect(pending).resolves.toBe(true);
+    expect(executions).toEqual([{ ...previews[0], dropTargetConfirmed: true }]);
+    expect(previews[0]?.dropTargetConfirmed).toBe(false);
+  });
+
+  it("discards a preview after the form or dialog invalidates its submission", async () => {
+    const backend = deferred<TransferOwnershipPreview>();
+    const reviewed: TransferRequest[] = [];
+    const executions: TransferRequest[] = [];
+    const submission = createTransferSubmission({
+      preview: () => backend.promise,
+      confirmOwnership: async () => "preserve",
+      confirm: async (value) => {
+        reviewed.push(value);
+        return true;
+      },
+      execute: (value) => {
+        executions.push(value);
+      },
+    });
+
+    const pending = submission.start(request());
+    submission.cancel();
+    backend.resolve(preview({ missingOwners: ["old_owner"] }));
+
+    await expect(pending).resolves.toBe(false);
+    expect(reviewed).toEqual([]);
+    expect(executions).toEqual([]);
+  });
+
+  it("does not execute an older confirmation after a newer transfer starts", async () => {
+    const decision = deferred<boolean>();
+    const executions: TransferRequest[] = [];
+    let confirmationCount = 0;
+    const submission = createTransferSubmission({
+      preview: async () => preview(),
+      confirmOwnership: async () => "preserve",
+      confirm: async (value) => {
+        confirmationCount++;
+        return value.transferId === "old" ? decision.promise : true;
+      },
+      execute: (value) => {
+        executions.push(value);
+      },
+    });
+
+    const old = submission.start(request({ transferId: "old" }));
+    await vi.waitFor(() => expect(confirmationCount).toBe(1));
+    await expect(submission.start(request({ transferId: "new" }))).resolves.toBe(true);
+    decision.resolve(true);
+
+    await expect(old).resolves.toBe(false);
+    expect(executions.map((value) => value.transferId)).toEqual(["new"]);
+  });
+
+  it("re-previews a changed ownership policy with the same transfer ID before final confirmation", async () => {
+    const previews: TransferRequest[] = [];
+    const reviewed: TransferOwnershipPreview[] = [];
+    const executions: TransferRequest[] = [];
+    const submission = createTransferSubmission({
+      preview: async (value) => {
+        previews.push(value);
+        return preview({ missingOwners: ["old_owner"], rebuild: { ...preview().rebuild!, sql: value.ownershipPolicy === "reassignMissing" ? "REASSIGNED PLAN" : "ORIGINAL PLAN" } });
+      },
+      confirmOwnership: async () => "reassignMissing",
+      confirm: async (_value, plan) => {
+        reviewed.push(plan);
+        return true;
+      },
+      execute: (value) => {
+        executions.push(value);
+      },
+    });
+
+    await expect(submission.start(request())).resolves.toBe(true);
+
+    expect(previews.map((value) => [value.transferId, value.ownershipPolicy, value.dropTargetConfirmed])).toEqual([
+      ["transfer-1", "preserve", false],
+      ["transfer-1", "reassignMissing", false],
+    ]);
+    expect(reviewed.map((value) => value.rebuild?.sql)).toEqual(["REASSIGNED PLAN"]);
+    expect(executions[0]?.ownershipPolicy).toBe("reassignMissing");
+  });
+
+  it("refuses rebuild execution when the backend does not provide a rebuild plan", async () => {
+    const executions: TransferRequest[] = [];
+    const submission = createTransferSubmission({
+      preview: async () => preview({ rebuild: undefined }),
+      confirmOwnership: async () => "preserve",
+      confirm: async () => true,
+      execute: (value) => {
+        executions.push(value);
+      },
+    });
+
+    await expect(submission.start(request())).rejects.toThrow("TRANSFER_REBUILD_PREVIEW_UNAVAILABLE");
+    expect(executions).toEqual([]);
+  });
+
+  it("does not surface errors from a cancelled preview", async () => {
+    const backend = deferred<TransferOwnershipPreview>();
+    const submission = createTransferSubmission({ preview: () => backend.promise, confirmOwnership: async () => null, confirm: async () => false, execute: () => undefined });
+    const pending = submission.start(request());
+    submission.cancel();
+    backend.reject(new Error("old connection failed"));
+
+    await expect(pending).resolves.toBe(false);
+  });
+
+  it.each(["append", "overwrite", "upsert"] as const)("keeps ordinary %s data-only requests free of rebuild authorization", async (mode) => {
+    const executions: TransferRequest[] = [];
+    const submission = createTransferSubmission({
+      preview: async () => {
+        throw new Error("Data-only must not load DDL preview");
+      },
+      confirmOwnership: async () => null,
+      confirm: async () => true,
+      execute: (value) => {
+        executions.push(value);
+      },
+    });
+
+    await submission.start(request({ content: "dataOnly", createTable: false, mode, dropTargetBeforeCreate: false, dropTargetConfirmed: true }));
+
+    expect(executions[0]).toMatchObject({ mode, content: "dataOnly", createTable: false, dropTargetBeforeCreate: false, dropTargetConfirmed: false });
+  });
+});
+
+describe("transfer production confirmation", () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  function connection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+    return { id: "target", name: "Warehouse", db_type: "postgres", host: "localhost", port: 5432, username: "target_user", password: "", ...overrides };
+  }
+
+  it.each([{ is_production: true }, { production_databases: ["warehouse"] }])("uses one shared confirmation for production scope %j", async (scope) => {
+    let ordinaryConfirmations = 0;
+    const pending = confirmTransferWithProductionSafety({
+      request: request(),
+      connection: connection(scope),
+      reviewText: preview().rebuild!.sql,
+      source: "Data Transfer",
+      confirm: async () => {
+        ordinaryConfirmations++;
+        return true;
+      },
+    });
+
+    const store = useProductionSafetyStore();
+    expect(store.pending).toMatchObject({ scopeId: "transfer-1", database: "warehouse", connectionName: "Warehouse", sql: preview().rebuild!.sql });
+    expect(ordinaryConfirmations).toBe(0);
+
+    store.confirm();
+    await expect(pending).resolves.toBe(true);
+    expect(store.pending).toBeUndefined();
+  });
+
+  it("cancels a pending production confirmation with the transfer scope", async () => {
+    const pending = confirmTransferWithProductionSafety({ request: request(), connection: connection({ production_databases: ["warehouse"] }), reviewText: "PLAN", confirm: async () => true });
+
+    useProductionSafetyStore().cancelScope("transfer-1");
+
+    await expect(pending).resolves.toBe(false);
+    expect(useProductionSafetyStore().pending).toBeUndefined();
+  });
+
+  it("uses the transfer confirmation for a non-production target", async () => {
+    let ordinaryConfirmations = 0;
+    const result = await confirmTransferWithProductionSafety({
+      request: request(),
+      connection: connection(),
+      reviewText: "PLAN",
+      confirm: async () => {
+        ordinaryConfirmations++;
+        return false;
+      },
+    });
+
+    expect(result).toBe(false);
+    expect(ordinaryConfirmations).toBe(1);
+    expect(useProductionSafetyStore().pending).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/components/transfer/transferStrategy.ts b/apps/desktop/src/components/transfer/transferStrategy.ts
new file mode 100644
index 0000000000..dd2f25febf
--- /dev/null
+++ b/apps/desktop/src/components/transfer/transferStrategy.ts
@@ -0,0 +1,97 @@
+import type { TransferContent, TransferMode, TransferOwnershipPolicy, TransferOwnershipPreview, TransferRequest } from "@/lib/backend/api";
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+
+export type TransferStrategy = TransferMode | "rebuild";
+
+export function resolveTransferStrategy(options: { mode?: TransferMode; dropTargetBeforeCreate?: boolean }): TransferStrategy {
+  return options.dropTargetBeforeCreate ? "rebuild" : (options.mode ?? "append");
+}
+
+export function transferStrategyOptions(strategy: TransferStrategy): Pick<TransferRequest, "mode" | "dropTargetBeforeCreate"> {
+  return { mode: strategy === "rebuild" ? "append" : strategy, dropTargetBeforeCreate: strategy === "rebuild" };
+}
+
+const REBUILD_TARGET_TYPES = new Set<DatabaseType>(["mysql", "postgres", "sqlserver", "kingbase", "gaussdb", "opengauss", "kwdb", "goldendb", "sqlite", "duckdb", "cloudflare-d1"]);
+
+export function rebuildUnavailableReason(content: TransferContent, targetType: DatabaseType | undefined): "dataOnly" | "unsupported" | undefined {
+  if (content === "dataOnly") return "dataOnly";
+  return targetType && REBUILD_TARGET_TYPES.has(targetType) ? undefined : "unsupported";
+}
+
+/** Snapshot the complete selection before any asynchronous preview or confirmation. */
+function freezeTransferRequest(request: TransferRequest): TransferRequest {
+  const snapshot = {
+    ...request,
+    ...transferStrategyOptions(resolveTransferStrategy(request)),
+    tables: [...request.tables],
+    objects: request.objects.map((selection) => ({ ...selection, names: [...selection.names] })),
+    dropTargetConfirmed: false,
+  };
+  Object.freeze(snapshot.tables);
+  for (const selection of snapshot.objects) {
+    Object.freeze(selection.names);
+    Object.freeze(selection);
+  }
+  Object.freeze(snapshot.objects);
+  return Object.freeze(snapshot);
+}
+
+interface TransferSubmissionOptions {
+  ensureWritable?: (request: TransferRequest) => Promise<boolean>;
+  preview: (request: TransferRequest) => Promise<TransferOwnershipPreview>;
+  confirmOwnership: (preview: TransferOwnershipPreview) => Promise<TransferOwnershipPolicy | null>;
+  confirm: (request: TransferRequest, preview: TransferOwnershipPreview) => Promise<boolean>;
+  execute: (request: TransferRequest) => void;
+}
+
+/** Invalidating a submission prevents every later await from reopening prompts or starting it. */
+export function createTransferSubmission(options: TransferSubmissionOptions) {
+  let generation = 0;
+  return {
+    cancel() {
+      generation += 1;
+    },
+    async start(input: TransferRequest): Promise<boolean> {
+      const token = ++generation;
+      const isCurrent = () => token === generation;
+      let request = freezeTransferRequest(input);
+      try {
+        if (options.ensureWritable && (!(await options.ensureWritable(request)) || !isCurrent())) return false;
+        let preview: TransferOwnershipPreview = request.content === "dataOnly" ? { missingOwners: [], targetOwner: "" } : await options.preview(request);
+        if (!isCurrent()) return false;
+        if (preview.missingOwners.length > 0) {
+          const policy = await options.confirmOwnership(preview);
+          if (!policy || !isCurrent()) return false;
+          if (policy !== request.ownershipPolicy) {
+            request = freezeTransferRequest({ ...request, ownershipPolicy: policy });
+            preview = await options.preview(request);
+            if (!isCurrent()) return false;
+          }
+        }
+        if (request.dropTargetBeforeCreate && !preview.rebuild) throw new Error("TRANSFER_REBUILD_PREVIEW_UNAVAILABLE");
+        if (!(await options.confirm(request, preview)) || !isCurrent()) return false;
+        options.execute(Object.freeze({ ...request, dropTargetConfirmed: request.dropTargetBeforeCreate }));
+        return true;
+      } catch (error) {
+        if (!isCurrent()) return false;
+        throw error;
+      }
+    },
+  };
+}
+
+/** The shared production prompt also serves as the destructive rebuild confirmation. */
+export function confirmTransferWithProductionSafety(options: { request: TransferRequest; connection?: ConnectionConfig; reviewText: string; source?: string; confirm: () => Promise<boolean> }): Promise<boolean> {
+  const context = productionContextForDatabase(options.connection, options.request.targetDatabase);
+  if (!context.active) return options.confirm();
+  return useProductionSafetyStore().requestConfirmation({
+    sql: options.reviewText,
+    connectionName: options.connection?.name,
+    database: options.request.targetDatabase,
+    productionDatabases: context.databases,
+    source: options.source,
+    scopeId: options.request.transferId,
+  });
+}
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 5d0af19b65..1da3b74696 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -5568,7 +5568,7 @@ export default {
     crossFamilyViewHint: "Cross-database view transfer: select the tables the view depends on as well, or make sure they already exist in the target database",
     objectUnsupportedDisabled: "This database does not support transferring this object type",
     skippedExistingObjects: "Skipped {count} existing object(s)",
-    dataWriteMode: "Data write mode",
+    targetTableHandling: "Target table handling",
     source: "Source",
     target: "Target",
     sourceConnection: "Source Connection",
@@ -5596,6 +5596,15 @@ export default {
     tableNameCaseLower: "Lowercase",
     tableNameCaseUpper: "Uppercase",
     batchSize: "Batch size",
+    modeRebuild: "Rebuild structure and data (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "Keep existing tables",
+    modeRebuildStructure: "Rebuild structure (RENAME + CREATE)",
+    rebuildSummary: "Rebuild {count} table(s): existing target tables are renamed to backups first, then rebuilt from the source structure and populated; backups are removed after all steps succeed.",
+    rebuildDanger: "Rebuilding replaces the selected target tables, their existing rows, and target-only metadata. Review the actual targets, backup names, and SQL. Once backups are cleaned up, they cannot be used for recovery.",
+    rebuildDataOnlyDisabled: "Rebuild is unavailable for data-only transfers. Select structure and data or structure only.",
+    rebuildUnsupportedDisabled: "The selected target engine does not support rebuilding target tables.",
+    rebuildPreviewUnavailable: "The backend did not provide a rebuild plan. The transfer has not started; refresh the preview with a backend that supports rebuild.",
+    previewFailed: "Could not prepare the transfer: {message}",
     start: "Start Transfer",
     startConfirmTitle: "Confirm transfer",
     startConfirmMessage: "Transfer {count} selected objects from {source} to {target}. Start now?",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 9a9f99ebff..56883273c6 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -5190,7 +5190,7 @@ export default withEnglishFallback({
   },
   transfer: {
     title: "Transferencia de datos",
-    content: "Modo de transferencia",
+    content: "Contenido de la transferencia",
     contentStructureAndData: "Estructura y datos",
     contentStructureOnly: "Solo estructura",
     contentDataOnly: "Solo datos",
@@ -5212,7 +5212,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "Transferencia de vistas entre bases de datos: seleccione también las tablas de las que depende la vista o asegúrese de que ya existen en la base de datos de destino",
     objectUnsupportedDisabled: "La base de datos actual no admite la transferencia de este tipo de objeto",
     skippedExistingObjects: "Se omitieron {count} objetos existentes",
-    dataWriteMode: "Modo de escritura de datos",
+    targetTableHandling: "Tratamiento de las tablas de destino",
     source: "Origen",
     target: "Destino",
     sourceConnection: "Conexión de origen",
@@ -5233,6 +5233,15 @@ export default withEnglishFallback({
     tableNameCaseLower: "Convertir a minúsculas",
     tableNameCaseUpper: "Convertir a mayúsculas",
     batchSize: "Tamaño de lote",
+    modeRebuild: "Reconstruir estructura y datos (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "Conservar tablas existentes",
+    modeRebuildStructure: "Reconstruir estructura (RENAME + CREATE)",
+    rebuildSummary: "Se reconstruirán {count} tabla(s): las tablas de destino existentes se renombran como copias de seguridad, se recrean con la estructura de origen y se rellenan; las copias se eliminan al finalizar todos los pasos.",
+    rebuildDanger: "La reconstrucción sustituye las tablas de destino seleccionadas, sus filas existentes y los metadatos exclusivos del destino. Revise los destinos reales, los nombres de respaldo y el SQL. Los respaldos eliminados no se pueden usar para recuperar las tablas.",
+    rebuildDataOnlyDisabled: "La reconstrucción no está disponible para transferencias de solo datos. Seleccione estructura y datos o solo estructura.",
+    rebuildUnsupportedDisabled: "El motor de destino seleccionado no permite reconstruir las tablas de destino.",
+    rebuildPreviewUnavailable: "El backend no devolvió un plan de reconstrucción. La transferencia no se ha iniciado; vuelva a obtener la vista previa con un backend compatible.",
+    previewFailed: "No se pudo preparar la transferencia: {message}",
     start: "Iniciar transferencia",
     startConfirmTitle: "Confirmar transferencia",
     startConfirmMessage: "Se transferirán {count} objetos seleccionados de {source} a {target}. ¿Iniciar ahora?",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index ed198711f2..3d32e4a880 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -5210,7 +5210,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "Trasferimento di viste tra database: selezionare anche le tabelle da cui la vista dipende, o assicurarsi che esistano già nel database di destinazione",
     objectUnsupportedDisabled: "Il database corrente non supporta il trasferimento di questo tipo di oggetto",
     skippedExistingObjects: "Saltati {count} oggetti esistenti",
-    dataWriteMode: "Modalità di scrittura dati",
+    targetTableHandling: "Gestione delle tabelle di destinazione",
     source: "Sorgente",
     target: "Destinazione",
     sourceConnection: "Connessione Sorgente",
@@ -5234,6 +5234,15 @@ export default withEnglishFallback({
     tableNameCaseLower: "Converti in minuscolo",
     tableNameCaseUpper: "Converti in maiuscolo",
     batchSize: "Dimensione lotto",
+    modeRebuild: "Ricostruisci struttura e dati (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "Mantieni tabelle esistenti",
+    modeRebuildStructure: "Ricostruisci struttura (RENAME + CREATE)",
+    rebuildSummary: "Verranno ricostruite {count} tabelle: le tabelle di destinazione esistenti vengono prima rinominate come backup, quindi ricreate dalla struttura di origine e popolate; i backup vengono eliminati al termine di tutti i passaggi.",
+    rebuildDanger: "La ricostruzione sostituisce le tabelle di destinazione selezionate, le righe esistenti e i metadati presenti solo nella destinazione. Controllare le destinazioni effettive, i nomi dei backup e il SQL. I backup eliminati non possono essere usati per il ripristino.",
+    rebuildDataOnlyDisabled: "La ricostruzione non è disponibile per i trasferimenti di soli dati. Selezionare struttura e dati oppure solo struttura.",
+    rebuildUnsupportedDisabled: "Il motore di destinazione selezionato non supporta la ricostruzione delle tabelle di destinazione.",
+    rebuildPreviewUnavailable: "Il backend non ha restituito un piano di ricostruzione. Il trasferimento non è iniziato; aggiornare l’anteprima con un backend compatibile.",
+    previewFailed: "Impossibile preparare il trasferimento: {message}",
     start: "Avvia Trasferimento",
     startConfirmTitle: "Conferma trasferimento",
     startConfirmMessage: "Verranno trasferiti {count} oggetti selezionati da {source} a {target}. Avviare ora?",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 77458de50d..63c8d4e2ef 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -5239,7 +5239,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "データベース間ビュー転送：ビューが依存するテーブルも選択するか、ターゲットDBに既に存在することを確認してください",
     objectUnsupportedDisabled: "現在のデータベースは、このオブジェクトタイプの転送をサポートしていません",
     skippedExistingObjects: "既存のオブジェクト {count} 件をスキップしました",
-    dataWriteMode: "データ書き込みモード",
+    targetTableHandling: "ターゲットテーブルの処理",
     source: "ソース",
     target: "対象",
     sourceConnection: "ソース接続",
@@ -5263,6 +5263,15 @@ export default withEnglishFallback({
     tableNameCaseLower: "小文字に変換",
     tableNameCaseUpper: "大文字に変換",
     batchSize: "バッチサイズ",
+    modeRebuild: "構造とデータを再構築 (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "既存テーブルを保持",
+    modeRebuildStructure: "構造を再構築 (RENAME + CREATE)",
+    rebuildSummary: "{count} 件のテーブルを再構築します：既存のターゲットテーブルをまずバックアップにリネームし、ソース構造から再作成してデータを投入します。すべての手順が成功した後にバックアップを削除します。",
+    rebuildDanger: "再構築により、選択したターゲットテーブル、既存の行、ターゲットのみに存在するメタデータが置き換えられます。実際のターゲット、バックアップ名、SQL を確認してください。削除されたバックアップからは復元できません。",
+    rebuildDataOnlyDisabled: "データのみの転送では再構築できません。「構造とデータ」または「構造のみ」を選択してください。",
+    rebuildUnsupportedDisabled: "選択したターゲットエンジンはテーブルの再構築をサポートしていません。",
+    rebuildPreviewUnavailable: "バックエンドから再構築計画が返されなかったため、転送は開始されていません。再構築プレビューに対応したバックエンドで再試行してください。",
+    previewFailed: "転送を準備できませんでした：{message}",
     start: "転送開始",
     startConfirmTitle: "転送の開始確認",
     startConfirmMessage: "{source} で選択した {count} 個のオブジェクトを {target} に転送します。開始しますか？",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index fe74590aeb..80c1f84e7d 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -4882,7 +4882,7 @@ export default withEnglishFallback({
   },
   transfer: {
     title: "데이터 이전",
-    content: "전송 콘텐츠",
+    content: "전송 내용",
     contentStructureAndData: "구조 및 데이터",
     contentStructureOnly: "구조만",
     contentDataOnly: "데이터만",
@@ -4904,7 +4904,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "데이터베이스 간 뷰 전송: 뷰가 의존하는 테이블도 선택하거나 대상 DB에 이미 존재하는지 확인하세요",
     objectUnsupportedDisabled: "현재 데이터베이스는 이 개체 유형의 전송을 지원하지 않습니다",
     skippedExistingObjects: "기존 개체 {count}개 건너뜀",
-    dataWriteMode: "데이터 쓰기 모드",
+    targetTableHandling: "대상 테이블 처리 방식",
     source: "소스",
     target: "대상",
     sourceConnection: "소스 연결",
@@ -4928,6 +4928,15 @@ export default withEnglishFallback({
     tableNameCaseLower: "소문자",
     tableNameCaseUpper: "대문자",
     batchSize: "배치 크기",
+    modeRebuild: "구조 및 데이터 재구축 (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "기존 테이블 유지",
+    modeRebuildStructure: "구조 재구축 (RENAME + CREATE)",
+    rebuildSummary: "{count}개 테이블을 재구축합니다: 기존 대상 테이블을 먼저 백업으로 이름을 바꾸고 소스 구조로 다시 만든 뒤 데이터를 넣습니다. 모든 단계가 성공한 후 백업을 삭제합니다.",
+    rebuildDanger: "재구축하면 선택한 대상 테이블, 기존 행, 대상에만 있는 메타데이터가 교체됩니다. 실제 대상, 백업 이름, SQL을 확인하세요. 삭제된 백업은 복구에 사용할 수 없습니다.",
+    rebuildDataOnlyDisabled: "데이터만 전송할 때는 재구축할 수 없습니다. 구조 및 데이터 또는 구조만을 선택하세요.",
+    rebuildUnsupportedDisabled: "선택한 대상 엔진은 대상 테이블 재구축을 지원하지 않습니다.",
+    rebuildPreviewUnavailable: "백엔드가 재구축 계획을 반환하지 않아 전송을 시작하지 않았습니다. 재구축 미리 보기를 지원하는 백엔드에서 다시 시도하세요.",
+    previewFailed: "전송을 준비할 수 없습니다: {message}",
     start: "이전 시작",
     startConfirmTitle: "전송 시작 확인",
     startConfirmMessage: "{source}에서 선택한 개체 {count}개를 {target}(으)로 전송합니다. 시작하시겠습니까?",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 0e91a26865..e154b674e5 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -5190,7 +5190,7 @@ export default withEnglishFallback({
   },
   transfer: {
     title: "Transferência de Dados",
-    content: "Conteúdo de transferência",
+    content: "Conteúdo da transferência",
     contentStructureAndData: "Estrutura e dados",
     contentStructureOnly: "Apenas estrutura",
     contentDataOnly: "Apenas dados",
@@ -5212,7 +5212,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "Transferência de views entre bancos: selecione também as tabelas das quais a view depende ou garanta que elas já existam no banco de destino",
     objectUnsupportedDisabled: "O banco de dados atual não suporta a transferência deste tipo de objeto",
     skippedExistingObjects: "Ignorado {count} objeto(s) existente(s)",
-    dataWriteMode: "Modo de gravação de dados",
+    targetTableHandling: "Tratamento das tabelas de destino",
     source: "Origem",
     target: "Destino",
     sourceConnection: "Conexão de origem",
@@ -5236,6 +5236,15 @@ export default withEnglishFallback({
     tableNameCaseLower: "Converter para minúsculas",
     tableNameCaseUpper: "Converter para maiúsculas",
     batchSize: "Tamanho do lote",
+    modeRebuild: "Reconstruir estrutura e dados (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "Manter tabelas existentes",
+    modeRebuildStructure: "Reconstruir estrutura (RENAME + CREATE)",
+    rebuildSummary: "{count} tabela(s) serão reconstruídas: as tabelas de destino existentes são renomeadas como backups, recriadas com a estrutura de origem e preenchidas; os backups são removidos após todas as etapas.",
+    rebuildDanger: "A reconstrução substitui as tabelas de destino selecionadas, suas linhas existentes e os metadados exclusivos do destino. Revise os destinos reais, os nomes dos backups e o SQL. Backups removidos não podem ser usados para recuperação.",
+    rebuildDataOnlyDisabled: "A reconstrução não está disponível para transferências apenas de dados. Selecione estrutura e dados ou apenas estrutura.",
+    rebuildUnsupportedDisabled: "O mecanismo de destino selecionado não oferece suporte à reconstrução das tabelas de destino.",
+    rebuildPreviewUnavailable: "O backend não retornou um plano de reconstrução. A transferência não foi iniciada; atualize a prévia com um backend compatível.",
+    previewFailed: "Não foi possível preparar a transferência: {message}",
     start: "Iniciar transferência",
     startConfirmTitle: "Confirmar transferência",
     startConfirmMessage: "{count} objetos selecionados de {source} serão transferidos para {target}. Iniciar agora?",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 6db7acc288..c73614680e 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -5530,7 +5530,7 @@ export default withEnglishFallback({
   },
   transfer: {
     title: "数据传输",
-    content: "传输方式",
+    content: "传输内容",
     contentStructureAndData: "结构和数据",
     contentStructureOnly: "仅结构",
     contentDataOnly: "仅数据",
@@ -5552,7 +5552,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "跨库视图传输：请同时选择视图依赖的表，或确保目标库已存在这些表",
     objectUnsupportedDisabled: "当前数据库不支持该对象类型传输",
     skippedExistingObjects: "跳过 {count} 个已存在对象",
-    dataWriteMode: "数据写入方式",
+    targetTableHandling: "目标表处理方式",
     source: "源",
     target: "目标",
     sourceConnection: "源连接",
@@ -5580,6 +5580,15 @@ export default withEnglishFallback({
     tableNameCaseLower: "转为小写",
     tableNameCaseUpper: "转为大写",
     batchSize: "每批行数",
+    modeRebuild: "重建结构和数据 (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "保留已有表",
+    modeRebuildStructure: "重建结构 (RENAME + CREATE)",
+    rebuildSummary: "将重建 {count} 张表：先将现有目标表改名为备份表，按源结构重建并传输数据，全部成功后清理备份。",
+    rebuildDanger: "重建会替换所选目标表、已有数据和仅目标端存在的元数据。请核对实际目标、备份名和 SQL；备份清理后将无法再用于恢复。",
+    rebuildDataOnlyDisabled: "仅数据模式不支持重建，请选择“结构和数据”或“仅结构”。",
+    rebuildUnsupportedDisabled: "当前目标引擎不支持重建目标表。",
+    rebuildPreviewUnavailable: "后端未返回重建计划，传输尚未开始。请使用支持重建预览的后端后重新预览。",
+    previewFailed: "无法准备传输：{message}",
     start: "开始传输",
     startConfirmTitle: "确认开始传输",
     startConfirmMessage: "将把 {source} 中选中的 {count} 个对象传输到 {target}，确定开始吗？",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 41dd0f7d97..cdd93f42a0 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -4510,7 +4510,7 @@ export default withEnglishFallback({
   },
   transfer: {
     title: "資料傳輸",
-    content: "傳輸方式",
+    content: "傳輸內容",
     contentStructureAndData: "結構和資料",
     contentStructureOnly: "僅結構",
     contentDataOnly: "僅資料",
@@ -4532,7 +4532,7 @@ export default withEnglishFallback({
     crossFamilyViewHint: "跨庫檢視傳輸：請同時選擇檢視依賴的表，或確保目標庫已存在這些表",
     objectUnsupportedDisabled: "目前資料庫不支援該物件類型傳輸",
     skippedExistingObjects: "跳過 {count} 個已存在物件",
-    dataWriteMode: "資料寫入方式",
+    targetTableHandling: "目標表處理方式",
     source: "來源",
     target: "目標",
     sourceConnection: "來源連線",
@@ -4551,6 +4551,15 @@ export default withEnglishFallback({
     modeOverwrite: "覆蓋 (TRUNCATE + INSERT)",
     modeUpsert: "更新插入 (按主鍵 INSERT 或 UPDATE)",
     batchSize: "每批筆數",
+    modeRebuild: "重建結構和資料 (RENAME + CREATE + INSERT)",
+    modeKeepExisting: "保留既有表",
+    modeRebuildStructure: "重建結構 (RENAME + CREATE)",
+    rebuildSummary: "將重建 {count} 張資料表：先將既有目標表改名為備份表，依來源結構重建並傳輸資料，全部成功後清理備份。",
+    rebuildDanger: "重建會取代所選目標表、既有資料和僅目標端存在的中繼資料。請核對實際目標、備份名稱和 SQL；備份清理後將無法再用於還原。",
+    rebuildDataOnlyDisabled: "僅資料模式不支援重建，請選擇「結構和資料」或「僅結構」。",
+    rebuildUnsupportedDisabled: "目前目標引擎不支援重建目標表。",
+    rebuildPreviewUnavailable: "後端未傳回重建計畫，傳輸尚未開始。請使用支援重建預覽的後端後重新預覽。",
+    previewFailed: "無法準備傳輸：{message}",
     start: "開始傳輸",
     startConfirmTitle: "確認開始傳輸",
     startConfirmMessage: "將把 {source} 中選中的 {count} 個物件傳輸到 {target}，確定開始嗎？",
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index c90e84319a..b79fce7e70 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -4626,11 +4626,18 @@ export interface TransferRequest {
   quoteTargetColumnNames: boolean;
   ownershipPolicy?: TransferOwnershipPolicy;
   batchSize: number;
+  dropTargetBeforeCreate: boolean;
+  dropTargetConfirmed: boolean;
 }
 
 export interface TransferOwnershipPreview {
   missingOwners: string[];
   targetOwner: string;
+  rebuild?: {
+    sql: string;
+    tables: Array<{ sourceTable: string; targetTable: string; backupTable?: string }>;
+    warnings: string[];
+  };
 }
 
 export interface TransferProgress {
diff --git a/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts b/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts
index 1b0bdb0af9..ef8d55956c 100644
--- a/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts
+++ b/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts
@@ -82,6 +82,37 @@ describe("transferTaskStore", () => {
     expect(store.tasks[0]?.config.quoteTargetColumnNames).toBe(true);
   });
 
+  it("loads a legacy rebuild task as append without restoring its previous confirmation", async () => {
+    vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
+      version: 1,
+      folders: [],
+      tasks: [{ id: "legacy-rebuild", name: "legacy rebuild", config: makeConfig({ mode: "upsert", dropTargetBeforeCreate: true, dropTargetConfirmed: true }) }],
+    });
+    const store = useTransferTaskStore();
+
+    await store.initFromStorage();
+
+    expect(store.getTask("legacy-rebuild")?.config).toMatchObject({ mode: "append", dropTargetBeforeCreate: true, dropTargetConfirmed: false });
+  });
+
+  it("saves mutually exclusive rebuild options without persisting request confirmation", async () => {
+    const store = useTransferTaskStore();
+
+    const task = await store.saveTask({ name: "rebuild", config: makeConfig({ mode: "overwrite", dropTargetBeforeCreate: true, dropTargetConfirmed: true }) });
+
+    expect(task.config).toMatchObject({ mode: "append", dropTargetBeforeCreate: true, dropTargetConfirmed: false });
+    const persisted = vi.mocked(api.saveTransferTaskLibrary).mock.calls.at(-1)?.[0] as TransferTaskLibrary;
+    expect(persisted.tasks[0]?.config).toMatchObject({ mode: "append", dropTargetBeforeCreate: true, dropTargetConfirmed: false });
+  });
+
+  it.each(["append", "overwrite", "upsert"] as const)("keeps ordinary %s tasks unchanged while dropping stale confirmation", async (mode) => {
+    const store = useTransferTaskStore();
+
+    const task = await store.saveTask({ name: mode, config: makeConfig({ mode, dropTargetBeforeCreate: false, dropTargetConfirmed: true }) });
+
+    expect(task.config).toMatchObject({ mode, dropTargetBeforeCreate: false, dropTargetConfirmed: false });
+  });
+
   it("refuses to overwrite a persisted library with invalid entries", async () => {
     vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
       version: 1,
diff --git a/apps/desktop/src/stores/transferTaskStore.ts b/apps/desktop/src/stores/transferTaskStore.ts
index 5bccad24ff..c52b545e83 100644
--- a/apps/desktop/src/stores/transferTaskStore.ts
+++ b/apps/desktop/src/stores/transferTaskStore.ts
@@ -3,6 +3,7 @@ import { defineStore } from "pinia";
 import { uuid } from "@/lib/common/utils";
 import * as api from "@/lib/backend/api";
 import type { TransferTask, TransferTaskConfig, TransferTaskFolder, TransferTaskLibrary } from "@/types/database";
+import { resolveTransferStrategy, transferStrategyOptions } from "@/components/transfer/transferStrategy";
 
 export class TransferTaskNameConflictError extends Error {
   readonly code = "TRANSFER_TASK_NAME_CONFLICT";
@@ -87,10 +88,11 @@ function normalizeTask(raw: unknown): TransferTask | null {
       targetSchema: config.targetSchema || undefined,
       objects,
       content: config.content ?? "structureAndData",
-      mode: config.mode ?? "append",
+      ...transferStrategyOptions(resolveTransferStrategy(config)),
       targetTableNameCase: config.targetTableNameCase ?? "preserve",
       quoteTargetColumnNames: config.quoteTargetColumnNames ?? true,
       batchSize: typeof config.batchSize === "number" && config.batchSize > 0 ? config.batchSize : 1000,
+      dropTargetConfirmed: false,
     },
     createdAt: candidate.createdAt || nowIso(),
     updatedAt: candidate.updatedAt || nowIso(),
@@ -281,14 +283,15 @@ export const useTransferTaskStore = defineStore("transferTasks", () => {
     const folderId = Object.prototype.hasOwnProperty.call(input, "folderId") ? input.folderId || undefined : existing?.folderId;
     ensureTaskNameAvailable(trimmed, folderId, input.id);
     const timestamp = nowIso();
+    const config: TransferTaskConfig = { ...input.config, ...transferStrategyOptions(resolveTransferStrategy(input.config)), dropTargetConfirmed: false };
     const task: TransferTask = existing
-      ? { ...existing, folderId, name: trimmed, config: input.config, updatedAt: timestamp }
+      ? { ...existing, folderId, name: trimmed, config, updatedAt: timestamp }
       : {
           id: uuid(),
           folderId,
           name: trimmed,
           orderIndex: maxOrderIndex(tasks.value.filter((item) => (item.folderId || "") === (folderId || ""))) + 1,
-          config: input.config,
+          config,
           createdAt: timestamp,
           updatedAt: timestamp,
         };
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 656123737f..cc102fd344 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -1469,6 +1469,10 @@ export interface TransferTaskConfig {
   targetTableNameCase: TransferTableNameCase;
   quoteTargetColumnNames: boolean;
   batchSize: number;
+  /** Legacy-compatible rebuild flag; true takes precedence over the saved DML mode. */
+  dropTargetBeforeCreate?: boolean;
+  /** Legacy field only. Saved confirmation is always ignored and reset to false. */
+  dropTargetConfirmed?: boolean;
 }
 
 export interface TransferTask {
diff --git a/crates/dbx-core/src/db_admin_sql.rs b/crates/dbx-core/src/db_admin_sql.rs
index f91d06081e..56fd0fe778 100644
--- a/crates/dbx-core/src/db_admin_sql.rs
+++ b/crates/dbx-core/src/db_admin_sql.rs
@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use crate::models::connection::DatabaseType;
 use crate::sql_dialect::{
     is_schema_aware, profile_for, qualified_table_name, quote_table_data_identifier, quote_table_identifier,
-    uses_connection_identifier_quote,
+    uses_connection_identifier_quote, DdlDialectProfile,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -415,35 +415,28 @@ pub fn build_drop_table_sql(options: TableAdminSqlOptions) -> String {
         &options.table_name,
         options.identifier_quote.as_deref(),
     );
+    // IoTDB is the one engine whose drop target is a derived path pattern rather than the
+    // qualified name, so it cannot be expressed as a profile template.
     if matches!(options.database_type, Some(DatabaseType::Iotdb)) {
         return format!("DELETE TIMESERIES {};", iotdb_timeseries_pattern(&table));
-    } else if matches!(options.database_type, Some(DatabaseType::InfluxDb)) {
-        return format!("DROP MEASUREMENT {};", table);
     }
-    // CASCADE is valid for PostgreSQL-family dialects; keep default RESTRICT behavior elsewhere.
     let cascade = if options.cascade.unwrap_or(false) && supports_drop_table_cascade(options.database_type) {
         " CASCADE"
     } else {
         ""
     };
-    format!("DROP TABLE {table}{cascade};")
+    // Unknown database type: fall back to the ANSI shape rather than guessing a profile.
+    let Some(database_type) = options.database_type else {
+        return format!("DROP TABLE {table}{cascade};");
+    };
+    DdlDialectProfile::render_template(
+        profile_for(database_type).drop_table_template,
+        &[("table", &table), ("cascade", cascade)],
+    )
 }
 
 fn supports_drop_table_cascade(database_type: Option<DatabaseType>) -> bool {
-    matches!(
-        database_type,
-        Some(
-            DatabaseType::Postgres
-                | DatabaseType::Redshift
-                | DatabaseType::Gaussdb
-                | DatabaseType::Kwdb
-                | DatabaseType::Kingbase
-                | DatabaseType::Highgo
-                | DatabaseType::Uxdb
-                | DatabaseType::Vastbase
-                | DatabaseType::OpenGauss
-        )
-    )
+    database_type.is_some_and(|database_type| profile_for(database_type).drop_table_supports_cascade)
 }
 
 pub fn build_drop_table_child_object_sql(options: DropTableChildObjectSqlOptions) -> Result<String, String> {
@@ -1012,7 +1005,11 @@ fn is_postgres_like_rename(database_type: DatabaseType) -> bool {
 
 fn is_oracle_like_rename(database_type: DatabaseType) -> bool {
     // 神通 Oscar 实测支持 `ALTER TABLE old RENAME TO new`（PG 风格，与 Dameng/Oracle 一致）。
-    matches!(database_type, DatabaseType::Oracle | DatabaseType::Dameng | DatabaseType::Oscar)
+    // OceanBase Oracle 模式同样接受该语法。
+    matches!(
+        database_type,
+        DatabaseType::Oracle | DatabaseType::Dameng | DatabaseType::OceanbaseOracle | DatabaseType::Oscar
+    )
 }
 
 fn is_postgres_like_structure_copy(database_type: DatabaseType) -> bool {
@@ -1803,6 +1800,57 @@ mod tests {
         }
     }
 
+    /// `build_drop_table_sql` renders `DdlDialectProfile::drop_table_template`, so the six
+    /// profile families plus DuckDB (which resolves to `conservative_ansi`, not the SQLite
+    /// family) must all produce a valid statement.
+    #[test]
+    fn builds_drop_table_sql_per_profile_family() {
+        let drop_sql = |database_type: DatabaseType, schema: Option<&str>, cascade: Option<bool>| {
+            build_drop_table_sql(TableAdminSqlOptions {
+                database_type: Some(database_type),
+                schema: schema.map(str::to_string),
+                table_name: "events".to_string(),
+                cascade,
+                identifier_quote: None,
+            })
+        };
+
+        assert_eq!(drop_sql(DatabaseType::Mysql, None, None), "DROP TABLE `events`;");
+        assert_eq!(drop_sql(DatabaseType::Postgres, Some("public"), None), "DROP TABLE \"public\".\"events\";");
+        assert_eq!(drop_sql(DatabaseType::Oracle, Some("APP"), None), "DROP TABLE \"APP\".\"events\";");
+        assert_eq!(drop_sql(DatabaseType::SqlServer, Some("dbo"), None), "DROP TABLE [dbo].[events];");
+        assert_eq!(drop_sql(DatabaseType::Sqlite, None, None), "DROP TABLE \"events\";");
+        assert_eq!(drop_sql(DatabaseType::DuckDb, None, None), "DROP TABLE \"events\";");
+        // No database type: the ANSI shape, with the default double-quote from
+        // `qualified_name_with_quote`, and no CASCADE.
+        assert_eq!(
+            build_drop_table_sql(TableAdminSqlOptions {
+                database_type: None,
+                schema: None,
+                table_name: "events".to_string(),
+                cascade: Some(true),
+                identifier_quote: None,
+            }),
+            "DROP TABLE \"events\";"
+        );
+
+        // CASCADE stays limited to the PostgreSQL-family profiles. Oracle spells it
+        // `CASCADE CONSTRAINTS` and is deliberately excluded; Firebird, Vertica and Exasol
+        // share the PostgreSQL profile but opt out.
+        assert_eq!(
+            drop_sql(DatabaseType::Postgres, Some("public"), Some(true)),
+            "DROP TABLE \"public\".\"events\" CASCADE;"
+        );
+        assert_eq!(drop_sql(DatabaseType::OpenGauss, None, Some(true)), "DROP TABLE \"events\" CASCADE;");
+        assert_eq!(drop_sql(DatabaseType::Firebird, None, Some(true)), "DROP TABLE \"events\";");
+        assert_eq!(drop_sql(DatabaseType::Vertica, None, Some(true)), "DROP TABLE \"events\";");
+        assert_eq!(drop_sql(DatabaseType::Oracle, None, Some(true)), "DROP TABLE \"events\";");
+        assert_eq!(drop_sql(DatabaseType::DuckDb, None, Some(true)), "DROP TABLE \"events\";");
+
+        // InfluxDB drops a measurement; the profile template carries the whole shape.
+        assert_eq!(drop_sql(DatabaseType::InfluxDb, None, None), "DROP MEASUREMENT \"events\";");
+    }
+
     #[test]
     fn builds_mysql_auto_increment_sql_and_rejects_invalid_values() {
         for value in ["1", "9007199254740993", "18446744073709551615"] {
@@ -2614,6 +2662,20 @@ mod tests {
             .unwrap(),
             "ALTER VIEW \"SYSDBA\".\"ACTIVE_USERS\" RENAME TO \"ENABLED_USERS\";"
         );
+        // OceanBase in Oracle mode accepts the same statement; without it the transfer
+        // rename-then-drop path has no way to back up a target table.
+        assert!(supports_object_rename(Some(DatabaseType::OceanbaseOracle), DatabaseObjectType::Table));
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::OceanbaseOracle),
+                object_type: DatabaseObjectType::Table,
+                schema: Some("APP".to_string()),
+                old_name: "ORDERS".to_string(),
+                new_name: "ORDERS__DBX_BAK".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE \"APP\".\"ORDERS\" RENAME TO \"ORDERS__DBX_BAK\";"
+        );
     }
 
     #[test]
diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rs
index ca3e4fecec..570729f798 100644
--- a/crates/dbx-core/src/lib.rs
+++ b/crates/dbx-core/src/lib.rs
@@ -106,6 +106,7 @@ pub mod temporal_format;
 pub mod text_export;
 pub mod token_usage;
 pub mod transfer;
+pub mod transfer_rebuild;
 pub mod two_phase_commit;
 pub mod types;
 pub mod update;
diff --git a/crates/dbx-core/src/script_generator.rs b/crates/dbx-core/src/script_generator.rs
index d1ecd80d6c..ac31d7ef28 100644
--- a/crates/dbx-core/src/script_generator.rs
+++ b/crates/dbx-core/src/script_generator.rs
@@ -436,6 +436,9 @@ fn wrap_if_not_exists(sql: &str, db_type: DatabaseType) -> String {
         let (prefix, suffix) = sql.split_at(idx);
         format!("{prefix} IF NOT EXISTS{suffix}")
     } else if upper.starts_with("DROP TABLE") {
+        if !profile.drop_table_supports_if_exists {
+            return sql.to_string();
+        }
         if upper.contains("IF EXISTS") {
             return sql.to_string();
         }
@@ -1604,6 +1607,24 @@ mod tests {
         assert!(result.contains("DROP TABLE IF EXISTS"), "Got: {result}");
     }
 
+    /// Oracle before 23c rejects `DROP TABLE IF EXISTS`, so the wrapper must leave the
+    /// statement alone instead of generating invalid SQL.
+    #[test]
+    fn idempotent_drop_table_skips_if_exists_where_unsupported() {
+        for db_type in [DatabaseType::Oracle, DatabaseType::Db2, DatabaseType::Access] {
+            let result = apply_idempotent_strategy("DROP TABLE old_users;", db_type, IdempotentStrategy::IfNotExists);
+            assert_eq!(result, "DROP TABLE old_users;", "{db_type:?} must not gain IF EXISTS");
+        }
+        // The ConditionalCheck strategy falls back to the guarded comment form instead.
+        let conditional = apply_idempotent_strategy(
+            "DROP TABLE old_users;",
+            DatabaseType::Oracle,
+            IdempotentStrategy::ConditionalCheck,
+        );
+        assert!(!conditional.contains("IF EXISTS"), "Got: {conditional}");
+        assert!(conditional.contains("-- Conditional"), "Got: {conditional}");
+    }
+
     #[test]
     fn idempotent_drop_index_if_exists() {
         let sql = "DROP INDEX idx_email;";
diff --git a/crates/dbx-core/src/sql_dialect/ddl_profile.rs b/crates/dbx-core/src/sql_dialect/ddl_profile.rs
index cf092ef658..efa125f787 100644
--- a/crates/dbx-core/src/sql_dialect/ddl_profile.rs
+++ b/crates/dbx-core/src/sql_dialect/ddl_profile.rs
@@ -118,6 +118,12 @@ pub struct DdlDialectProfile {
     pub drop_index_uses_on_table: bool,
     /// `DROP FOREIGN KEY` (MySQL) vs `DROP CONSTRAINT`.
     pub drop_fk_as_foreign_key: bool,
+    /// `DROP TABLE t CASCADE` is accepted. Oracle's `CASCADE CONSTRAINTS` is a
+    /// different clause and does not count.
+    pub drop_table_supports_cascade: bool,
+    /// `DROP TABLE IF EXISTS t` is valid grammar. False for Oracle (pre-23c),
+    /// Access, Firebird, Db2, Informix, SAP HANA and Teradata.
+    pub drop_table_supports_if_exists: bool,
     /// Index method placement.
     pub index_type_placement: IndexTypePlacement,
     /// `INCLUDE (cols)` on indexes.
@@ -165,6 +171,9 @@ pub struct DdlDialectProfile {
     pub rule_drop_template: Option<&'static str>,
     /// `ALTER {object_type} {name} OWNER TO {owner};`
     pub owner_alter_template: Option<&'static str>,
+    /// `DROP TABLE {table}{cascade};` — the caller quotes `{table}` itself. Engines
+    /// that drop a differently-named object override the whole shape.
+    pub drop_table_template: &'static str,
     /// Optional session lock-timeout preamble for generated scripts.
     pub lock_timeout_sql: Option<&'static str>,
     /// Data-driven base-type rewrites for this target (empty → rely on matrix / normalize only).
@@ -222,6 +231,9 @@ const SQLSERVER_SEQ_ALTER: &str =
     "ALTER SEQUENCE {name} RESTART WITH {start_value} INCREMENT BY {increment} MINVALUE {min_value} MAXVALUE {max_value} {cycle};";
 const RULE_DROP: &str = "DROP RULE IF EXISTS {rule_name} ON {table_name}{cascade};";
 const OWNER_ALTER: &str = "ALTER {object_type} {name} OWNER TO {owner};";
+/// Shared ANSI `DROP TABLE` shape. `{if_exists}` is deliberately absent: whether a
+/// dialect accepts `IF EXISTS` is a capability flag, not part of the rendered shape.
+const DROP_TABLE: &str = "DROP TABLE {table}{cascade};";
 
 // ---------------------------------------------------------------------------
 // Type maps (data only — no per-database logic at call sites)
@@ -325,6 +337,8 @@ fn mysql_family(db: DatabaseType) -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: true,
         drop_fk_as_foreign_key: true,
+        drop_table_supports_cascade: false,
+        drop_table_supports_if_exists: true,
         index_type_placement: IndexTypePlacement::UsingBeforeOn,
         index_supports_include: false,
         index_supports_filter: false,
@@ -354,6 +368,7 @@ fn mysql_family(db: DatabaseType) -> DdlDialectProfile {
         sequence_drop_template: None,
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: Some("SET SESSION lock_wait_timeout = 3;"),
         type_map: &[],
     }
@@ -371,6 +386,8 @@ fn postgres_family(db: DatabaseType) -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        drop_table_supports_cascade: true,
+        drop_table_supports_if_exists: true,
         index_type_placement: IndexTypePlacement::UsingSuffix,
         index_supports_include: true,
         index_supports_filter: true,
@@ -400,6 +417,7 @@ fn postgres_family(db: DatabaseType) -> DdlDialectProfile {
         sequence_drop_template: Some(SEQ_DROP),
         rule_drop_template: Some(RULE_DROP),
         owner_alter_template: Some(OWNER_ALTER),
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: Some("SET lock_timeout = '3s';"),
         type_map: &[],
     }
@@ -420,6 +438,9 @@ fn oracle_family(db: DatabaseType) -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        // Oracle spells it `CASCADE CONSTRAINTS`, and `IF EXISTS` only landed in 23c.
+        drop_table_supports_cascade: false,
+        drop_table_supports_if_exists: false,
         index_type_placement: IndexTypePlacement::None,
         index_supports_include: false,
         index_supports_filter: false,
@@ -450,6 +471,7 @@ fn oracle_family(db: DatabaseType) -> DdlDialectProfile {
         sequence_drop_template: Some(SEQ_DROP),
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: Some("ALTER SESSION SET DDL_LOCK_TIMEOUT = 3;"),
         type_map: &[],
     }
@@ -467,6 +489,9 @@ fn sqlserver_family(db: DatabaseType) -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        drop_table_supports_cascade: false,
+        // `DROP TABLE IF EXISTS` is valid on SQL Server 2016+.
+        drop_table_supports_if_exists: true,
         index_type_placement: IndexTypePlacement::TypePrefix,
         index_supports_include: true,
         index_supports_filter: true,
@@ -496,6 +521,7 @@ fn sqlserver_family(db: DatabaseType) -> DdlDialectProfile {
         sequence_drop_template: Some(SEQ_DROP),
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: Some("SET LOCK_TIMEOUT 3000;"),
         type_map: &[],
     }
@@ -513,6 +539,8 @@ fn sqlite_family(db: DatabaseType) -> DdlDialectProfile {
         foreign_keys_inline_in_create: true,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        drop_table_supports_cascade: false,
+        drop_table_supports_if_exists: true,
         index_type_placement: IndexTypePlacement::None,
         index_supports_include: false,
         index_supports_filter: true,
@@ -542,6 +570,7 @@ fn sqlite_family(db: DatabaseType) -> DdlDialectProfile {
         sequence_drop_template: None,
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: None,
         type_map: SQLITE_TYPE_MAP,
     }
@@ -559,6 +588,9 @@ fn access_profile() -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        // Jet SQL has neither CASCADE nor IF EXISTS on DROP TABLE.
+        drop_table_supports_cascade: false,
+        drop_table_supports_if_exists: false,
         index_type_placement: IndexTypePlacement::None,
         index_supports_include: false,
         index_supports_filter: false,
@@ -588,6 +620,7 @@ fn access_profile() -> DdlDialectProfile {
         sequence_drop_template: None,
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: None,
         type_map: ACCESS_TYPE_MAP,
     }
@@ -605,6 +638,10 @@ fn h2_profile() -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        // H2 accepts CASCADE, but it stays off to keep the cascade set aligned with
+        // the frontend preview list in `dbAdminSql.ts`.
+        drop_table_supports_cascade: false,
+        drop_table_supports_if_exists: true,
         index_type_placement: IndexTypePlacement::None,
         index_supports_include: false,
         index_supports_filter: false,
@@ -634,6 +671,7 @@ fn h2_profile() -> DdlDialectProfile {
         sequence_drop_template: None,
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: None,
         type_map: &[],
     }
@@ -656,6 +694,10 @@ fn conservative_ansi(db: DatabaseType) -> DdlDialectProfile {
         foreign_keys_inline_in_create: false,
         drop_index_uses_on_table: false,
         drop_fk_as_foreign_key: false,
+        drop_table_supports_cascade: false,
+        // Most engines in this bucket accept `IF EXISTS`; `profile_for` opts out the
+        // ones that do not.
+        drop_table_supports_if_exists: true,
         index_type_placement: IndexTypePlacement::None,
         index_supports_include: false,
         index_supports_filter: false,
@@ -685,6 +727,7 @@ fn conservative_ansi(db: DatabaseType) -> DdlDialectProfile {
         sequence_drop_template: None,
         rule_drop_template: None,
         owner_alter_template: None,
+        drop_table_template: DROP_TABLE,
         lock_timeout_sql: None,
         type_map: &[],
     }
@@ -698,6 +741,14 @@ fn clickhouse_profile() -> DdlDialectProfile {
     p
 }
 
+fn influxdb_profile() -> DdlDialectProfile {
+    let mut p = conservative_ansi(DatabaseType::InfluxDb);
+    // InfluxDB drops a measurement, not a table, and has no IF EXISTS form.
+    p.drop_table_template = "DROP MEASUREMENT {table};";
+    p.drop_table_supports_if_exists = false;
+    p
+}
+
 /// Resolve DDL profile for a concrete target database type.
 ///
 /// This is the **only** place that maps [`DatabaseType`] → profile data.
@@ -709,8 +760,19 @@ pub fn profile_for(db_type: DatabaseType) -> DdlDialectProfile {
         Mysql | Doris | StarRocks | Goldendb | Sundb | Databend | Gbase | ManticoreSearch => mysql_family(db_type),
 
         // PostgreSQL family
-        Postgres | Redshift | Gaussdb | Kingbase | Highgo | Vastbase | OpenGauss | Kwdb | Firebird | Vertica
-        | Exasol | Uxdb => postgres_family(db_type),
+        Postgres | Redshift | Gaussdb | Kingbase | Highgo | Vastbase | OpenGauss | Kwdb | Uxdb => {
+            postgres_family(db_type)
+        }
+
+        // PostgreSQL-shaped DDL, but not the PostgreSQL `DROP TABLE` grammar:
+        // Firebird has neither CASCADE nor IF EXISTS; Vertica and Exasol are kept off
+        // CASCADE so the set stays aligned with the frontend preview list.
+        Firebird | Vertica | Exasol => {
+            let mut profile = postgres_family(db_type);
+            profile.drop_table_supports_cascade = false;
+            profile.drop_table_supports_if_exists = db_type != Firebird;
+            profile
+        }
 
         // Oracle family
         Oracle | Dameng | OceanbaseOracle | Yashandb | Xugu | Iris => oracle_family(db_type),
@@ -728,13 +790,23 @@ pub fn profile_for(db_type: DatabaseType) -> DdlDialectProfile {
 
         ClickHouse => clickhouse_profile(),
 
-        DuckDb | Questdb | SapHana | Teradata | Snowflake | Trino | PrestoSql | Hive | Kyuubi | Impala | Argo
-        | Spark | Db2 | Informix | Bigquery | Spanner | Kylin | Ignite | Ignite3 | Oscar | Tdengine | Iotdb
-        | Databricks | Jdbc => conservative_ansi(db_type),
+        // Engines whose DROP TABLE grammar has no `IF EXISTS`.
+        Db2 | Informix | SapHana | Teradata => {
+            let mut profile = conservative_ansi(db_type);
+            profile.drop_table_supports_if_exists = false;
+            profile
+        }
+
+        DuckDb | Questdb | Snowflake | Trino | PrestoSql | Hive | Kyuubi | Impala | Argo | Spark | Bigquery
+        | Spanner | Kylin | Ignite | Ignite3 | Oscar | Tdengine | Iotdb | Databricks | Jdbc => {
+            conservative_ansi(db_type)
+        }
+
+        InfluxDb => influxdb_profile(),
 
         // Non-tabular / not applicable for relational CREATE TABLE
         Redis | MongoDb | DynamoDb | Elasticsearch | Easysearch | Meilisearch | Qdrant | Milvus | Weaviate
-        | ChromaDb | Neo4j | Cassandra | Etcd | ZooKeeper | Nacos | Consul | InfluxDb | InfluxDb3 | VictoriaMetrics
+        | ChromaDb | Neo4j | Cassandra | Etcd | ZooKeeper | Nacos | Consul | InfluxDb3 | VictoriaMetrics
         | MessageQueue | Mqtt | Hbase => conservative_ansi(db_type),
     }
 }
@@ -810,4 +882,74 @@ mod tests {
         );
         assert_eq!(rendered, "DROP FUNCTION IF EXISTS \"public\".\"f\" CASCADE;");
     }
+
+    #[test]
+    fn drop_table_if_exists_support_matches_dialect_grammar() {
+        for db in [
+            DatabaseType::Mysql,
+            DatabaseType::Postgres,
+            DatabaseType::SqlServer,
+            DatabaseType::Sqlite,
+            DatabaseType::DuckDb,
+            DatabaseType::ClickHouse,
+            DatabaseType::H2,
+            DatabaseType::Snowflake,
+        ] {
+            assert!(profile_for(db).drop_table_supports_if_exists, "{db:?} does support DROP TABLE IF EXISTS");
+        }
+        // Oracle only gained `IF EXISTS` in 23c; the rest have no such grammar at all.
+        for db in [
+            DatabaseType::Oracle,
+            DatabaseType::Dameng,
+            DatabaseType::OceanbaseOracle,
+            DatabaseType::Access,
+            DatabaseType::Firebird,
+            DatabaseType::Db2,
+            DatabaseType::Informix,
+            DatabaseType::SapHana,
+            DatabaseType::Teradata,
+            DatabaseType::InfluxDb,
+        ] {
+            assert!(!profile_for(db).drop_table_supports_if_exists, "{db:?} does not support DROP TABLE IF EXISTS");
+        }
+    }
+
+    #[test]
+    fn drop_table_cascade_support_is_limited_to_the_postgres_grammar() {
+        for db in [
+            DatabaseType::Postgres,
+            DatabaseType::Redshift,
+            DatabaseType::Gaussdb,
+            DatabaseType::Kwdb,
+            DatabaseType::Kingbase,
+            DatabaseType::Highgo,
+            DatabaseType::Uxdb,
+            DatabaseType::Vastbase,
+            DatabaseType::OpenGauss,
+        ] {
+            assert!(profile_for(db).drop_table_supports_cascade, "{db:?} should keep DROP TABLE … CASCADE");
+        }
+        // Oracle's `CASCADE CONSTRAINTS` is a different clause; Firebird, Vertica and Exasol
+        // share the PostgreSQL profile but stay out of the cascade set so the backend matches
+        // the frontend preview list in `dbAdminSql.ts`.
+        for db in [
+            DatabaseType::Oracle,
+            DatabaseType::Firebird,
+            DatabaseType::Vertica,
+            DatabaseType::Exasol,
+            DatabaseType::Mysql,
+            DatabaseType::Sqlite,
+            DatabaseType::DuckDb,
+            DatabaseType::SqlServer,
+            DatabaseType::H2,
+        ] {
+            assert!(!profile_for(db).drop_table_supports_cascade, "{db:?} must not emit DROP TABLE … CASCADE");
+        }
+    }
+
+    #[test]
+    fn drop_table_template_carries_the_whole_statement_shape() {
+        assert_eq!(profile_for(DatabaseType::Postgres).drop_table_template, "DROP TABLE {table}{cascade};");
+        assert_eq!(profile_for(DatabaseType::InfluxDb).drop_table_template, "DROP MEASUREMENT {table};");
+    }
 }
diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rs
index 22bdf31a15..9d7f81b36c 100644
--- a/crates/dbx-core/src/transfer.rs
+++ b/crates/dbx-core/src/transfer.rs
@@ -4,6 +4,12 @@ use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
+#[cfg(test)]
+#[path = "transfer/rebuild_tests.rs"]
+mod rebuild_tests;
+
+mod ddl_plan;
+
 use crate::connection::{config_for_pool_key, AppState, PoolKind};
 use crate::db;
 use crate::db::agent_driver::AgentTableReadStartParams;
@@ -201,6 +207,14 @@ pub struct TransferRequest {
     #[serde(default)]
     pub ownership_policy: TransferOwnershipPolicy,
     pub batch_size: usize,
+    /// When true, rename the target table to a backup before creating it from the
+    /// source structure. Only after the transfer succeeds is the backup dropped.
+    /// Requires `create_table = true` and `content != DataOnly`.
+    #[serde(default)]
+    pub drop_target_before_create: bool,
+    /// Production database confirmation for drop_target_before_create.
+    #[serde(default)]
+    pub drop_target_confirmed: bool,
 }
 
 fn default_quote_target_column_names() -> bool {
@@ -212,6 +226,29 @@ fn default_quote_target_column_names() -> bool {
 pub struct TransferOwnershipPreview {
     pub missing_owners: Vec<String>,
     pub target_owner: String,
+    pub rebuild: Option<TransferRebuildPreview>,
+}
+
+/// SQL plan preview for a `drop_target_before_create` (rebuild) transfer.
+///
+/// Built without executing any DDL: it reuses the same resolution and DDL planning the
+/// actual pass runs, so the confirmation dialog shows the real rename/create/cleanup
+/// statements and the real source→target→backup mapping.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransferRebuildPreview {
+    pub sql: String,
+    pub tables: Vec<TransferRebuildPreviewTable>,
+    pub warnings: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransferRebuildPreviewTable {
+    pub source_table: String,
+    pub target_table: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub backup_table: Option<String>,
 }
 
 impl TransferRequest {
@@ -730,6 +767,13 @@ pub fn validate_transfer_request(request: &TransferRequest) -> Result<(), String
     if matches!(request.content, TransferContent::DataOnly) && !request.objects.is_empty() {
         return Err("仅数据模式不传输非表对象".to_string());
     }
+    if request.drop_target_before_create
+        && (matches!(request.content, TransferContent::DataOnly) || !request.create_table)
+    {
+        return Err("drop_target_before_create requires structure transfer (create_table and content != DataOnly). \
+             Data-only mode does not create tables, so a dropped target would not be rebuilt."
+            .to_string());
+    }
     for selection in &request.objects {
         if selection.names.is_empty() {
             return Err(format!("Object selection for {:?} is empty", selection.object_type));
@@ -6714,39 +6758,154 @@ fn build_postgres_ownership_statement(statement: &PostgresOwnershipStatement, ow
     format!("{}{}", statement.sql_prefix, quote_identifier(owner, &DatabaseType::Postgres))
 }
 
+/// Build the SQL plan preview for a `drop_target_before_create` transfer.
+///
+/// Pure planning and deliberately lightweight: it resolves target names, derives backup
+/// names, and renders the rename/drop statements — but it does *not* read per-table column
+/// metadata or prepare the full CREATE DDL, so a large selection previews quickly and the
+/// confirmation dialog stays readable. The destructive steps (rename aside, drop the backup
+/// after success) are the ones shown; the CREATE step is summarized rather than expanded.
+async fn build_rebuild_preview(
+    state: &Arc<AppState>,
+    request: &TransferRequest,
+    target_db_type: &DatabaseType,
+    target_pool_key: &str,
+) -> Result<TransferRebuildPreview, String> {
+    // Resolve target names first, exactly like the rename pre-pass, so the preview cannot
+    // disagree with execution about which table exists or what it will be renamed to.
+    let mut resolved: Vec<(String, String, bool)> = Vec::with_capacity(request.tables.len());
+    for table in &request.tables {
+        let ResolvedTransferTargetTable { name, preexisting } = resolve_transfer_target_table_name(
+            state,
+            request,
+            table,
+            target_pool_key,
+            target_db_type,
+            request.source_catalog.as_deref(),
+            request.target_catalog.as_deref(),
+        )
+        .await;
+        resolved.push((table.clone(), name, preexisting));
+    }
+
+    // Refuse the same dependencies the rename pre-pass refuses, before showing any plan.
+    let target_names = resolved.iter().map(|(_, name, _)| name.clone()).collect::<Vec<_>>();
+    crate::transfer_rebuild::ensure_no_external_table_dependencies(
+        state,
+        target_pool_key,
+        &request.target_database,
+        &request.target_schema,
+        &target_names,
+        *target_db_type,
+    )
+    .await?;
+
+    let mut tables = Vec::with_capacity(resolved.len());
+    let mut rename_statements: Vec<String> = Vec::new();
+    let mut drop_statements: Vec<String> = Vec::new();
+
+    for (table, target_table, preexisting) in &resolved {
+        let backup_table = if *preexisting {
+            let backup = crate::transfer_rebuild::backup_table_name(
+                *target_db_type,
+                &request.transfer_id,
+                &format!("{}.{}", request.source_schema, table),
+                target_table,
+            )?;
+            let rename_sql =
+                crate::db_admin_sql::build_rename_object_sql(crate::db_admin_sql::RenameObjectSqlOptions {
+                    database_type: Some(*target_db_type),
+                    object_type: crate::db_admin_sql::DatabaseObjectType::Table,
+                    schema: if request.target_schema.is_empty() { None } else { Some(request.target_schema.clone()) },
+                    old_name: target_table.clone(),
+                    new_name: backup.clone(),
+                })?;
+            rename_statements.push(rename_sql);
+            let drop_sql = crate::db_admin_sql::build_drop_table_sql(crate::db_admin_sql::TableAdminSqlOptions {
+                database_type: Some(*target_db_type),
+                schema: if request.target_schema.is_empty() { None } else { Some(request.target_schema.clone()) },
+                table_name: backup.clone(),
+                cascade: Some(true),
+                identifier_quote: None,
+            });
+            drop_statements.push(drop_sql);
+            Some(backup)
+        } else {
+            None
+        };
+
+        tables.push(TransferRebuildPreviewTable {
+            source_table: table.clone(),
+            target_table: target_table.clone(),
+            backup_table,
+        });
+    }
+
+    let mut phases: Vec<String> = Vec::new();
+    if !rename_statements.is_empty() {
+        phases.push(format!("-- 1. Backup existing target tables\n{}", rename_statements.join(";\n")));
+    }
+    phases.push(format!(
+        "-- 2. Recreate the {} selected table(s) from the source structure and transfer the selected data",
+        resolved.len()
+    ));
+    if !drop_statements.is_empty() {
+        phases.push(format!("-- 3. Drop backups after success\n{}", drop_statements.join(";\n")));
+    }
+
+    let warnings = if resolved.iter().any(|(_, _, preexisting)| !preexisting) {
+        vec!["Some target tables do not exist yet and will be created without a backup.".to_string()]
+    } else {
+        Vec::new()
+    };
+
+    Ok(TransferRebuildPreview { sql: phases.join("\n\n"), tables, warnings })
+}
+
 pub async fn preview_transfer_ownership(
-    state: &AppState,
+    state: &Arc<AppState>,
     request: &TransferRequest,
     source_db_type: &DatabaseType,
     target_db_type: &DatabaseType,
     source_pool_key: &str,
     target_pool_key: &str,
 ) -> Result<TransferOwnershipPreview, String> {
-    if !request.create_table || !is_postgres_compat_transfer(source_db_type, target_db_type) {
-        return Ok(TransferOwnershipPreview { missing_owners: Vec::new(), target_owner: String::new() });
-    }
+    // PostgreSQL-compatible transfers report role ownership gaps for the confirmation flow.
+    let (missing_owners, target_owner) =
+        if request.create_table && is_postgres_compat_transfer(source_db_type, target_db_type) {
+            let has_prokind = postgres_transfer_catalog_capabilities(state, source_pool_key).await?.has_prokind;
+            let relation_names = postgres_transfer_relation_names(request);
+            let statements = get_postgres_ownership_statements_for_transfer(
+                state,
+                source_pool_key,
+                &request.source_schema,
+                &request.target_schema,
+                &relation_names,
+                has_prokind,
+            )
+            .await?;
+            let roles = distinct_postgres_ownership_roles(&statements);
+            let existing_roles = get_existing_postgres_roles(state, target_pool_key, &roles).await?;
+            let missing_owners = roles.into_iter().filter(|role| !existing_roles.contains(role)).collect::<Vec<_>>();
+            let target_owner = if missing_owners.is_empty() {
+                String::new()
+            } else {
+                get_postgres_current_user(state, target_pool_key).await?
+            };
+            (missing_owners, target_owner)
+        } else {
+            (Vec::new(), String::new())
+        };
 
-    let has_prokind = postgres_transfer_catalog_capabilities(state, source_pool_key).await?.has_prokind;
-    let relation_names = postgres_transfer_relation_names(request);
-    let statements = get_postgres_ownership_statements_for_transfer(
-        state,
-        source_pool_key,
-        &request.source_schema,
-        &request.target_schema,
-        &relation_names,
-        has_prokind,
-    )
-    .await?;
-    let roles = distinct_postgres_ownership_roles(&statements);
-    let existing_roles = get_existing_postgres_roles(state, target_pool_key, &roles).await?;
-    let missing_owners = roles.into_iter().filter(|role| !existing_roles.contains(role)).collect::<Vec<_>>();
-    let target_owner = if missing_owners.is_empty() {
-        String::new()
+    // Rebuild transfers additionally expose the rename/create/cleanup SQL plan so the
+    // confirmation dialog shows the real statements it is about to run.
+    let rebuild = if request.drop_target_before_create {
+        Some(build_rebuild_preview(state, request, target_db_type, target_pool_key).await?)
     } else {
-        get_postgres_current_user(state, target_pool_key).await?
+        None
     };
 
-    Ok(TransferOwnershipPreview { missing_owners, target_owner })
+    Ok(TransferOwnershipPreview { missing_owners, target_owner, rebuild })
 }
 
 fn postgres_transfer_grant_statements_sql(
@@ -7388,8 +7547,515 @@ async fn close_hive_server_transfer_cursor(state: &AppState, pool_key: &str, cur
     }
 }
 
+/// Rename every existing target table to its backup name before the main
+/// create/insert pass.
+///
+/// Called only when `drop_target_before_create` is true. `tables` must already be in
+/// `parents_first = false` order (children first): MySQL `RENAME TABLE` and PostgreSQL
+/// `ALTER TABLE ... RENAME` keep incoming foreign keys attached to the renamed table,
+/// so renaming children first leaves each backup pair consistent with the other.
+///
+/// Two passes over `tables`, both before any DDL runs: resolve the target name and
+/// existence of each table (through the same `resolve_transfer_target_table_name` the
+/// main pass uses, so the two cannot disagree on which table is rebuilt), then refuse
+/// the whole transfer if a table outside the collection references one of them.
+///
+/// Returns a map from source table name to backup table name for the tables that were
+/// renamed. Tables absent from the target are skipped and absent from the map, which
+/// is what tells the main pass to create them without a backup to clean up.
+///
+/// SQL Server: the `sp_rename` object kind for a schema-unique backup object name that
+/// survived the table rename, so the pre-pass can rename it aside.
+#[derive(Clone, Copy)]
+enum SqlServerBackupObjectKind {
+    /// Primary-key / unique constraint: backed by a same-named index, so it is renamed as
+    /// `sp_rename 'schema.table.name', ..., 'INDEX'`.
+    KeyIndex,
+    /// Foreign-key / default / check constraint: renamed as `sp_rename 'schema.name', ..., 'OBJECT'`
+    /// (the object name is schema-qualified, NOT table-qualified — a table-qualified name
+    /// raises 15248 "ambiguous @objname").
+    Constraint,
+    /// Plain (non-constraint) index: `sp_rename 'schema.table.name', ..., 'INDEX'`.
+    Index,
+}
+
+/// SQL Server: list the schema-unique constraint and index names that survive a table
+/// rename, so the rebuild pre-pass can rename them aside and free the names.
+async fn get_sqlserver_backup_object_names(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<(String, SqlServerBackupObjectKind)>, String> {
+    let object = if schema.is_empty() {
+        table.replace('\'', "''")
+    } else {
+        format!("{}.{}", schema.replace('\'', "''"), table.replace('\'', "''"))
+    };
+    let sql = format!(
+        "SELECT name, CAST(0 AS int) AS kind FROM sys.objects \
+         WHERE parent_object_id = OBJECT_ID('{object}') AND type IN ('PK','UQ') \
+         UNION ALL \
+         SELECT name, CAST(1 AS int) AS kind FROM sys.objects \
+         WHERE parent_object_id = OBJECT_ID('{object}') AND type IN ('F','D','C') \
+         UNION ALL \
+         SELECT i.name, CAST(2 AS int) AS kind FROM sys.indexes i \
+         WHERE i.object_id = OBJECT_ID('{object}') \
+           AND i.is_primary_key = 0 AND i.is_unique_constraint = 0 AND i.name IS NOT NULL",
+    );
+    let result = execute_read_on_pool(state, pool_key, &sql).await?;
+    let mut objects = Vec::new();
+    for row in &result.rows {
+        let Some(name) = row.first().and_then(serde_json::Value::as_str) else {
+            continue;
+        };
+        let kind = match row.get(1).and_then(serde_json::Value::as_i64) {
+            Some(1) => SqlServerBackupObjectKind::Constraint,
+            Some(2) => SqlServerBackupObjectKind::Index,
+            _ => SqlServerBackupObjectKind::KeyIndex,
+        };
+        if !name.is_empty() {
+            objects.push((name.to_string(), kind));
+        }
+    }
+    Ok(objects)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub async fn rename_tables_to_backup<F>(
+    state: &Arc<AppState>,
+    request: &TransferRequest,
+    tables: &[String],
+    target_db_type: DatabaseType,
+    target_pool_key: &str,
+    mut progress_callback: F,
+) -> Result<HashMap<String, String>, String>
+where
+    F: FnMut(TransferProgress),
+{
+    let total_tables = tables.len();
+
+    // Resolve target names first so the fail-fast check below sees the names that will
+    // actually be renamed (target name casing and existing-table matching included).
+    let mut resolved: Vec<(String, String, bool)> = Vec::with_capacity(total_tables);
+    for table in tables {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        let ResolvedTransferTargetTable { name, preexisting } = resolve_transfer_target_table_name(
+            state,
+            request,
+            table,
+            target_pool_key,
+            &target_db_type,
+            request.source_catalog.as_deref(),
+            request.target_catalog.as_deref(),
+        )
+        .await;
+        resolved.push((table.clone(), name, preexisting));
+    }
+
+    // Refuse before the first rename: a foreign key from outside the collection would
+    // follow the rename onto the backup table, and a dependent view would be rewritten
+    // against the backup by the server itself — neither can be repaired later in the
+    // transfer.
+    let target_names = resolved.iter().map(|(_, name, _)| name.clone()).collect::<Vec<_>>();
+    crate::transfer_rebuild::ensure_no_external_table_dependencies(
+        state,
+        target_pool_key,
+        &request.target_database,
+        &request.target_schema,
+        &target_names,
+        target_db_type,
+    )
+    .await?;
+
+    // Preflight every backup name before renaming anything. Renames are not transactional
+    // across tables, so a collision discovered halfway through would leave the earlier
+    // tables already renamed aside — the failure the all-or-nothing check exists to prevent.
+    let mut plan: Vec<(String, String, String)> = Vec::new();
+    for (table, target_table, preexisting) in &resolved {
+        if !preexisting {
+            log::info!("[transfer] rename pre-pass: target table {target_table} does not exist, nothing to back up");
+            continue;
+        }
+        let backup_name = crate::transfer_rebuild::backup_table_name(
+            target_db_type,
+            &request.transfer_id,
+            &format!("{}.{}", request.source_schema, table),
+            target_table,
+        )?;
+
+        // The backup name is derived, not user-supplied, so a hit means an earlier run of
+        // this same transfer left one behind. Never overwrite it: it may be the only copy
+        // of the original table (mirrors sqlite_rebuild.rs:498-511).
+        let backup_exists = {
+            let lookup = list_transfer_tables_isolated(
+                state.clone(),
+                request.target_connection_id.clone(),
+                request.target_database.clone(),
+                request.target_schema.clone(),
+                request.target_catalog.clone(),
+                target_db_type,
+                backup_name.clone(),
+                1,
+            )
+            .await?;
+            !lookup.is_empty()
+        };
+        if backup_exists {
+            return Err(format!(
+                "Backup table name '{}' already exists in the target database. Cannot proceed with \
+                 drop_target_before_create; remove the existing backup manually or retry the transfer.",
+                backup_name
+            ));
+        }
+        plan.push((table.clone(), target_table.clone(), backup_name));
+    }
+
+    // Persist the recovery plan before the first mutation so a crash mid-rename still
+    // leaves enough information on disk to find every backup table.
+    crate::transfer_rebuild::persist_rebuild_plan(state, request, target_db_type, &plan).await?;
+
+    // Execute the renames. Any failure after the first successful rename leaves retained
+    // backups behind; the annotate pass below appends every one of them to the error.
+    let mut backup_names: HashMap<String, String> = HashMap::new();
+    let rename_pass = async {
+        for (i, (table, target_table, backup_name)) in plan.iter().enumerate() {
+            if is_cancelled(&request.transfer_id).await {
+                return Err("Cancelled".to_string());
+            }
+
+            progress_callback(TransferProgress {
+                transfer_id: request.transfer_id.clone(),
+                table: format!("rename: {table}"),
+                table_index: i,
+                total_tables,
+                rows_transferred: i as u64,
+                total_rows: Some(total_tables as u64),
+                status: TransferStatus::Running,
+                error: None,
+                terminal: false,
+            });
+
+            log::info!("[transfer] rename pre-pass: renaming {target_table} to backup {backup_name}");
+
+            let rename_sql =
+                crate::db_admin_sql::build_rename_object_sql(crate::db_admin_sql::RenameObjectSqlOptions {
+                    database_type: Some(target_db_type),
+                    object_type: crate::db_admin_sql::DatabaseObjectType::Table,
+                    schema: if request.target_schema.is_empty() { None } else { Some(request.target_schema.clone()) },
+                    old_name: target_table.clone(),
+                    new_name: backup_name.clone(),
+                })?;
+
+            execute_on_pool(state, target_pool_key, &rename_sql).await.map_err(|e| {
+                format!("Failed to rename target table '{target_table}' to backup '{backup_name}' in pre-pass: {e}")
+            })?;
+
+            backup_names.insert(table.clone(), backup_name.clone());
+
+            // PostgreSQL family: `ALTER TABLE ... RENAME TO` does NOT rename the table's
+            // indexes, constraints, or owned sequences. They keep their original
+            // schema-scoped identifiers, so the main pass's `CREATE INDEX IF NOT EXISTS`
+            // would silently no-op and a rebuilt serial column would share the backup's
+            // sequence. Rename them aside now; the hash covers each object's own identity,
+            // so indexes of the same name on different tables never collide.
+            if is_postgres_family_target(&target_db_type) {
+                let schema_prefix = if request.target_schema.is_empty() {
+                    String::new()
+                } else {
+                    format!("{}.", quote_identifier(&request.target_schema, &DatabaseType::Postgres))
+                };
+                let mut renamed_objects = Vec::new();
+
+                let indexes = get_postgres_indexes_for_transfer(
+                    state,
+                    target_pool_key,
+                    &request.target_database,
+                    &request.target_schema,
+                    backup_name,
+                )
+                .await
+                .map_err(|e| {
+                    format!(
+                        "Failed to list indexes on backup table '{backup_name}': {e}. Renaming them is what frees \
+                         the original index names for the rebuilt table."
+                    )
+                })?;
+                for index in &indexes {
+                    if is_cancelled(&request.transfer_id).await {
+                        return Err("Cancelled".to_string());
+                    }
+                    let backup_index_name = crate::transfer_rebuild::backup_table_name(
+                        target_db_type,
+                        &request.transfer_id,
+                        &format!("{}.{}#index:{}", request.source_schema, table, index.name),
+                        &index.name,
+                    )?;
+                    let rename_index_sql = format!(
+                        "ALTER INDEX {}{} RENAME TO {}",
+                        schema_prefix,
+                        quote_identifier(&index.name, &DatabaseType::Postgres),
+                        quote_identifier(&backup_index_name, &DatabaseType::Postgres)
+                    );
+                    execute_on_pool(state, target_pool_key, &rename_index_sql).await.map_err(|e| {
+                        format!(
+                            "Failed to rename index '{index_name}' on backup table '{backup_name}' to '{backup_index_name}': {e}",
+                            index_name = index.name
+                        )
+                    })?;
+                    renamed_objects.push(format!("index {} -> {}", index.name, backup_index_name));
+                }
+
+                // Owned sequences (serial/identity) keep serving the backup table's column
+                // defaults after the rename. Renaming them aside makes the main pass create
+                // fresh sequences for the rebuilt table instead of silently reusing the
+                // backup's.
+                let owned_sequences = get_postgres_owned_sequences_for_transfer(
+                    state,
+                    target_pool_key,
+                    &request.target_schema,
+                    std::slice::from_ref(backup_name),
+                )
+                .await
+                .map_err(|e| format!("Failed to list owned sequences on backup table '{backup_name}': {e}"))?;
+                for sequence in &owned_sequences {
+                    if is_cancelled(&request.transfer_id).await {
+                        return Err("Cancelled".to_string());
+                    }
+                    let backup_sequence_name = crate::transfer_rebuild::backup_table_name(
+                        target_db_type,
+                        &request.transfer_id,
+                        &format!("{}.{}#sequence:{}", request.source_schema, table, sequence.name),
+                        &sequence.name,
+                    )?;
+                    let rename_sequence_sql = format!(
+                        "ALTER SEQUENCE {}{} RENAME TO {}",
+                        schema_prefix,
+                        quote_identifier(&sequence.name, &DatabaseType::Postgres),
+                        quote_identifier(&backup_sequence_name, &DatabaseType::Postgres)
+                    );
+                    execute_on_pool(state, target_pool_key, &rename_sequence_sql).await.map_err(|e| {
+                        format!(
+                            "Failed to rename sequence '{sequence_name}' on backup table '{backup_name}' to \
+                             '{backup_sequence_name}': {e}",
+                            sequence_name = sequence.name
+                        )
+                    })?;
+                    renamed_objects.push(format!("sequence {} -> {}", sequence.name, backup_sequence_name));
+                }
+
+                crate::transfer_rebuild::record_rebuild_step(state, &request.transfer_id, table, renamed_objects)
+                    .await?;
+            } else if target_db_type == DatabaseType::SqlServer {
+                // SQL Server: `sp_rename` on the table does NOT rename its schema-unique
+                // constraints or indexes. They keep their original names, so a rebuilt table
+                // reusing the source DDL would collide ("There is already an object named").
+                // Rename them aside now to free the names.
+                let objects =
+                    get_sqlserver_backup_object_names(state, target_pool_key, &request.target_schema, backup_name)
+                        .await
+                        .map_err(|e| {
+                            format!("Failed to list constraints and indexes on backup table '{backup_name}': {e}")
+                        })?;
+                let mut renamed_objects = Vec::new();
+                for (object_name, kind) in objects {
+                    if is_cancelled(&request.transfer_id).await {
+                        return Err("Cancelled".to_string());
+                    }
+                    let backup_object_name = crate::transfer_rebuild::backup_table_name(
+                        target_db_type,
+                        &request.transfer_id,
+                        &format!("{}.{}#object:{}", request.source_schema, table, object_name),
+                        &object_name,
+                    )?;
+                    // Key/plain indexes are table-qualified and renamed as INDEX; constraints
+                    // are schema-qualified (NOT table-qualified) and renamed as OBJECT.
+                    let (qualified_object, object_type, object_label) = match kind {
+                        SqlServerBackupObjectKind::KeyIndex | SqlServerBackupObjectKind::Index => {
+                            let qualified = if request.target_schema.is_empty() {
+                                format!("{backup_name}.{object_name}")
+                            } else {
+                                format!("{}.{backup_name}.{object_name}", request.target_schema)
+                            };
+                            (qualified, "INDEX", "index")
+                        }
+                        SqlServerBackupObjectKind::Constraint => {
+                            let qualified = if request.target_schema.is_empty() {
+                                object_name.clone()
+                            } else {
+                                format!("{}.{object_name}", request.target_schema)
+                            };
+                            (qualified, "OBJECT", "constraint")
+                        }
+                    };
+                    let rename_sql =
+                        format!("EXEC sp_rename N'{qualified_object}', N'{backup_object_name}', N'{object_type}';");
+                    execute_on_pool(state, target_pool_key, &rename_sql).await.map_err(|e| {
+                        format!(
+                            "Failed to rename {object_label} '{object_name}' on backup table '{backup_name}' to \
+                             '{backup_object_name}': {e}"
+                        )
+                    })?;
+                    renamed_objects.push(format!("{object_label} {object_name} -> {backup_object_name}"));
+                }
+                crate::transfer_rebuild::record_rebuild_step(state, &request.transfer_id, table, renamed_objects)
+                    .await?;
+            } else {
+                crate::transfer_rebuild::record_rebuild_step(state, &request.transfer_id, table, Vec::new()).await?;
+            }
+        }
+        Ok(())
+    };
+    if let Err(error) = rename_pass.await {
+        if error == "Cancelled" {
+            return Err(error);
+        }
+        // Every table already renamed stays as a backup. The message is the user's map
+        // back to their data, and the journal persisted above holds the same list on disk.
+        let mut annotated = error;
+        for backup_name in backup_names.values() {
+            let qualified = qualified_table(
+                backup_name,
+                &request.target_schema,
+                &target_db_type,
+                request.target_catalog.as_deref(),
+            );
+            annotated = crate::transfer_rebuild::annotate_error_with_retained_backup(annotated, &qualified);
+        }
+        return Err(annotated);
+    }
+
+    // MySQL family: free the constraint names the backups still hold before the caller
+    // runs the deferred foreign key ALTERs. Doing it here — inside the pre-pass, after
+    // every table is renamed — keeps the core API self-contained: both desktop and Web
+    // and any direct caller run the deferred ALTERs after this returns, and MySQL
+    // constraint names are unique per database, so an unreleased name would collide with
+    // the rebuilt table's re-created constraint.
+    free_backup_foreign_key_names(state, request, target_db_type, target_pool_key, &backup_names).await?;
+
+    Ok(backup_names)
+}
+
+/// Create (or skip) the target table for a single-table transfer.
+///
+/// Extracted from [`transfer_table_inner`] so the rebuild path can create the table from the
+/// source DDL *before* reading the source column list. When the source column read fails, a
+/// rebuild still leaves the freshly-created (empty) target table plus the retained backup
+/// behind — the recovery contract the failure path relies on (drop the empty table, rename
+/// the backup back).
+#[allow(clippy::too_many_arguments)]
+async fn create_transfer_target_table(
+    state: &Arc<AppState>,
+    request: &TransferRequest,
+    table: &str,
+    target_table: &str,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+    source_pool_key: &str,
+    target_pool_key: &str,
+    known_foreign_keys: &HashMap<String, Vec<db::ForeignKeyInfo>>,
+    pending_fk_alters: &mut Vec<(String, String)>,
+    target_table_preexisting: &mut bool,
+    target_renamed_to_backup: bool,
+    columns: &[db::ColumnInfo],
+    table_comment: Option<&str>,
+    pg_compat_transfer: bool,
+    preserves_target_table_name: bool,
+) -> Result<(), String> {
+    if transfer_table_needs_inline_postgres_schema_ensure(source_db_type, target_db_type)
+        && !request.target_schema.trim().is_empty()
+    {
+        let create_schema_sql =
+            format!("CREATE SCHEMA IF NOT EXISTS {}", quote_identifier(&request.target_schema, target_db_type));
+        execute_on_pool(state, target_pool_key, &create_schema_sql)
+            .await
+            .map_err(|e| format!("Failed to ensure schema exists: {e}"))?;
+    }
+
+    // The pre-pass renamed the target away, so the name is free again. Resetting the
+    // flag is what keeps the index / foreign key / PG schema restore paths — all
+    // gated on `!target_table_preexisting` — from silently skipping.
+    if target_renamed_to_backup {
+        *target_table_preexisting = false;
+    }
+
+    if *target_table_preexisting {
+        log::info!("[transfer] target table {target_table} already exists, skipping create-table DDL");
+        return Ok(());
+    }
+
+    let owned_sequences = prepare_postgres_owned_sequences_for_transfer(
+        state,
+        request,
+        table,
+        target_table,
+        source_pool_key,
+        target_pool_key,
+        pg_compat_transfer,
+        preserves_target_table_name,
+        *target_table_preexisting,
+    )
+    .await?;
+    // Shared DDL planning: the same helper the ownership preview uses, so the
+    // confirmation dialog and the actual creation can never disagree on the DDL
+    // or the names inside it. Rebuild mode additionally fails closed here when
+    // source metadata cannot be trusted.
+    let prepared = ddl_plan::prepare_table_ddl(
+        state,
+        request,
+        table,
+        target_table,
+        source_db_type,
+        target_db_type,
+        source_pool_key,
+        columns,
+        table_comment,
+        known_foreign_keys,
+    )
+    .await?;
+    let reused_source_ddl = prepared.reused_source_ddl;
+    let ddl = prepared.ddl;
+    let deferred_fk_alters = prepared.deferred_fk_alters;
+    log::info!("[transfer] creating target table: {}", ddl.chars().take(200).collect::<String>());
+    let target_table_created = transfer_create_table_created(
+        execute_transfer_create_table_ddl_on_pool(state, target_pool_key, &ddl, target_db_type, reused_source_ddl)
+            .await,
+        "Failed to create table",
+    )?;
+    if target_table_created {
+        pending_fk_alters.extend(deferred_fk_alters.into_iter().map(|statement| (target_table.to_string(), statement)));
+        let comment_stmts = generate_comment_ddl_with_column_quoting(
+            columns,
+            target_table,
+            &request.target_schema,
+            target_db_type,
+            table_comment,
+            request.quote_target_column_names,
+        );
+        for stmt in &comment_stmts {
+            if let Err(e) = execute_on_pool(state, target_pool_key, stmt).await {
+                log::warn!("[transfer] failed to set column comment for {target_table}: {e}");
+            }
+        }
+        bind_postgres_owned_sequences_for_transfer(state, request, target_table, target_pool_key, &owned_sequences)
+            .await?;
+    } else {
+        // DDL may report the table already exists even when metadata
+        // lookup missed it (case/schema differences or localized errors).
+        *target_table_preexisting = true;
+    }
+    Ok(())
+}
+
 /// Transfer a single table. Returns rows transferred.
 /// `progress_callback` is invoked for progress updates.
+///
+/// `preexisting_backup_names` carries the output of [`rename_tables_to_backup`] and is
+/// required whenever `drop_target_before_create` is set — this pass only checks whether the
+/// table was renamed aside, and never renames or drops anything itself. Removing the backups
+/// is [`drop_backup_tables`], after every table has succeeded.
 #[allow(clippy::too_many_arguments)]
 async fn transfer_table_inner<F>(
     state: &Arc<AppState>,
@@ -7402,6 +8068,7 @@ async fn transfer_table_inner<F>(
     target_pool_key: &str,
     known_foreign_keys: &HashMap<String, Vec<db::ForeignKeyInfo>>,
     pending_fk_alters: &mut Vec<(String, String)>,
+    preexisting_backup_names: Option<&HashMap<String, String>>,
     mut progress_callback: F,
 ) -> Result<u64, String>
 where
@@ -7437,37 +8104,21 @@ where
         .await;
     let preserves_target_table_name = target_table == table;
 
-    // Get source columns (deduplicate by name)
-    let columns = {
-        let raw = get_columns_for_transfer(
-            state,
-            source_pool_key,
-            &request.source_connection_id,
-            &request.source_database,
-            &request.source_schema,
-            table,
-            request.source_catalog.as_deref(),
-        )
-        .await?;
-        let mut seen = std::collections::HashSet::new();
-        raw.into_iter().filter(|c| seen.insert(c.name.clone())).collect::<Vec<_>>()
-    };
-
-    if columns.is_empty() {
-        return Err(format!("No columns found for table {table}"));
-    }
-
-    let writable_columns = writable_transfer_columns(&columns, source_db_type, target_db_type);
-    if writable_columns.is_empty() {
-        return Err(format!("No writable columns found for table {table}"));
-    }
-
-    let col_names: Vec<String> = writable_columns.iter().map(|c| c.name.clone()).collect();
-    let col_types: Vec<Option<String>> = writable_columns.iter().map(|c| Some(c.data_type.clone())).collect();
-    let primary_key_columns = transfer_key_columns(&writable_columns, source_db_type);
-    if should_copy_data(&request.content) {
-        log::info!("[transfer] {} has {} columns, counting rows...", table, columns.len());
-    }
+    // Did the rename pre-pass move this table's target aside? False when the option is off,
+    // or when the target table did not exist, so nothing was renamed. Removing the backup is
+    // `drop_backup_tables`' job once the whole table loop has succeeded.
+    let target_renamed_to_backup =
+        match (request.drop_target_before_create, preexisting_backup_names) {
+            (false, _) => false,
+            (true, Some(backup_map)) => backup_map.contains_key(table),
+            // rename_tables_to_backup owns the rename; without it the target table would
+            // still be in place and this pass would quietly append into it.
+            (true, None) => return Err(
+                "drop_target_before_create requires the rename pre-pass: call rename_tables_to_backup and pass its \
+                 result to transfer_table."
+                    .to_string(),
+            ),
+        };
 
     // Fetch source table comment. Keep this list-tables metadata chain on its
     // own task stack, just like the target-table lookup above.
@@ -7487,6 +8138,75 @@ where
     .next()
     .and_then(|table| table.comment);
 
+    // Get source columns (deduplicate by name).
+    //
+    // A rebuild reads its CREATE DDL from the source connection (not the source pool), so a
+    // column-read failure must still create the target table first: that leaves the recovery
+    // contract intact — an empty new table plus the retained backup — so the user can drop the
+    // empty table and rename the backup back.
+    let columns: Vec<db::ColumnInfo> = match get_columns_for_transfer(
+        state,
+        source_pool_key,
+        &request.source_connection_id,
+        &request.source_database,
+        &request.source_schema,
+        table,
+        request.source_catalog.as_deref(),
+    )
+    .await
+    {
+        Ok(raw) => {
+            let mut seen = std::collections::HashSet::new();
+            raw.into_iter().filter(|c| seen.insert(c.name.clone())).collect()
+        }
+        Err(error) => {
+            if request.drop_target_before_create && target_renamed_to_backup {
+                let mut preexisting = target_table_preexisting;
+                if let Err(create_error) = create_transfer_target_table(
+                    state,
+                    request,
+                    table,
+                    &target_table,
+                    source_db_type,
+                    target_db_type,
+                    source_pool_key,
+                    target_pool_key,
+                    known_foreign_keys,
+                    pending_fk_alters,
+                    &mut preexisting,
+                    true,
+                    &[],
+                    table_comment.as_deref(),
+                    pg_compat_transfer,
+                    preserves_target_table_name,
+                )
+                .await
+                {
+                    return Err(format!(
+                        "{error} Additionally, the rebuild could not create the target table: {create_error}"
+                    ));
+                }
+            }
+            return Err(error);
+        }
+    };
+
+    if columns.is_empty() {
+        return Err(format!("No columns found for table {table}"));
+    }
+
+    let writable_columns = writable_transfer_columns(&columns, source_db_type, target_db_type);
+    if writable_columns.is_empty() {
+        return Err(format!("No writable columns found for table {table}"));
+    }
+
+    let col_names: Vec<String> = writable_columns.iter().map(|c| c.name.clone()).collect();
+    let col_types: Vec<Option<String>> = writable_columns.iter().map(|c| Some(c.data_type.clone())).collect();
+    let primary_key_columns = transfer_key_columns(&writable_columns, source_db_type);
+    if should_copy_data(&request.content) {
+        log::info!("[transfer] {} has {} columns, counting rows...", table, columns.len());
+    }
+
     let source_indexes =
         if request.create_table && pg_compat_transfer && preserves_target_table_name && !target_table_preexisting {
             get_postgres_indexes_for_transfer(
@@ -7535,233 +8255,25 @@ where
 
     // Create table on target if requested
     if request.create_table {
-        if transfer_table_needs_inline_postgres_schema_ensure(source_db_type, target_db_type)
-            && !request.target_schema.trim().is_empty()
-        {
-            let create_schema_sql =
-                format!("CREATE SCHEMA IF NOT EXISTS {}", quote_identifier(&request.target_schema, target_db_type));
-            execute_on_pool(state, target_pool_key, &create_schema_sql)
-                .await
-                .map_err(|e| format!("Failed to ensure schema exists: {e}"))?;
-        }
-        if target_table_preexisting {
-            log::info!("[transfer] target table {} already exists, skipping create-table DDL", target_table);
-        } else {
-            let owned_sequences = prepare_postgres_owned_sequences_for_transfer(
-                state,
-                request,
-                table,
-                &target_table,
-                source_pool_key,
-                target_pool_key,
-                pg_compat_transfer,
-                preserves_target_table_name,
-                target_table_preexisting,
-            )
-            .await?;
-            let (source_driver_profile, target_driver_profile) = {
-                let configs = state.configs.read().await;
-                (
-                    configs.get(&request.source_connection_id).and_then(|config| config.driver_profile.clone()),
-                    configs.get(&request.target_connection_id).and_then(|config| config.driver_profile.clone()),
-                )
-            };
-            let can_reuse_source_ddl = can_reuse_source_table_ddl(
-                source_db_type,
-                target_db_type,
-                source_driver_profile.as_deref(),
-                target_driver_profile.as_deref(),
-                preserves_target_table_name,
-            ) && (request.quote_target_column_names
-                || !matches!(target_db_type, DatabaseType::Gaussdb | DatabaseType::OpenGauss));
-            let mut reused_source_ddl = false;
-            let ddl = if can_reuse_source_ddl {
-                let (source_ddl, source_ddl_was_read) = if let Some(catalog) =
-                    resolve_external_transfer_catalog(request.source_catalog.as_deref(), source_db_type)
-                {
-                    // Doris/StarRocks external catalog: read DDL directly via
-                    // SHOW CREATE TABLE catalog.database.table using the
-                    // existing source pool (bare MySQL — addresses any catalog).
-                    let pool = {
-                        let pool = state
-                            .pool_handle(source_pool_key)
-                            .await
-                            .ok_or_else(|| "Source pool not found".to_string())?;
-                        let PoolKind::Mysql(p, _) = &pool else {
-                            return Err("Source pool must be MySQL-family for catalog DDL".to_string());
-                        };
-                        p.clone()
-                    };
-                    match db::doris::get_catalog_table_ddl(&pool, catalog, &request.source_database, table).await {
-                        Ok(ddl) => (ddl, true),
-                        Err(err) => {
-                            log::warn!("[transfer] catalog DDL read failed for {table} in catalog '{catalog}': {err}; falling back to generated DDL");
-                            (
-                                generate_create_table_ddl_with_column_quoting(
-                                    &columns,
-                                    &target_table,
-                                    &request.source_schema,
-                                    &request.target_schema,
-                                    target_db_type,
-                                    source_db_type,
-                                    table_comment.as_deref(),
-                                    request.target_catalog.as_deref(),
-                                    request.quote_target_column_names,
-                                ),
-                                false,
-                            )
-                        }
-                    }
-                } else {
-                    match crate::schema::get_table_ddl_core(
-                        state,
-                        &request.source_connection_id,
-                        &request.source_database,
-                        &request.source_schema,
-                        table,
-                        None,
-                    )
-                    .await
-                    {
-                        Ok(ddl) => (ddl, true),
-                        Err(_) => (
-                            generate_create_table_ddl_with_column_quoting(
-                                &columns,
-                                &target_table,
-                                &request.source_schema,
-                                &request.target_schema,
-                                target_db_type,
-                                source_db_type,
-                                table_comment.as_deref(),
-                                request.target_catalog.as_deref(),
-                                request.quote_target_column_names,
-                            ),
-                            false,
-                        ),
-                    }
-                };
-                if contains_oceanbase_mysql_table_options(&source_ddl)
-                    && !db::oceanbase_mysql::is_profile(target_db_type, target_driver_profile.as_deref())
-                {
-                    generate_create_table_ddl_with_column_quoting(
-                        &columns,
-                        &target_table,
-                        &request.source_schema,
-                        &request.target_schema,
-                        target_db_type,
-                        source_db_type,
-                        table_comment.as_deref(),
-                        request.target_catalog.as_deref(),
-                        request.quote_target_column_names,
-                    )
-                } else {
-                    reused_source_ddl = source_ddl_was_read;
-                    rewrite_transfer_source_table_ddl(
-                        &source_ddl,
-                        &request.source_schema,
-                        &request.target_schema,
-                        source_db_type,
-                        target_db_type,
-                    )
-                }
-            } else {
-                generate_create_table_ddl_with_column_quoting(
-                    &columns,
-                    &target_table,
-                    &request.source_schema,
-                    &request.target_schema,
-                    target_db_type,
-                    source_db_type,
-                    table_comment.as_deref(),
-                    request.target_catalog.as_deref(),
-                    request.quote_target_column_names,
-                )
-            };
-            // MySQL-family targets: create the bare table first and add any foreign
-            // keys via ALTER TABLE afterward, instead of relying on inline
-            // `CREATE TABLE ... FOREIGN KEY` constraints. Inline FKs require every
-            // referenced table to already exist, which the dependency sort can't
-            // always guarantee (foreign key cycles have no valid creation order at
-            // all) — mirrors the same defer-FK-creation approach already used for
-            // Postgres transfers.
-            let mut ddl = ddl;
-            let mut deferred_fk_alters: Vec<String> = Vec::new();
-            if supports_deferred_mysql_foreign_keys(target_db_type) {
-                // Reuse the FK metadata `sort_tables_by_fk_dependency_with_foreign_keys`
-                // already fetched for the whole batch when the caller provided it;
-                // only fall back to a live query for callers that don't pre-fetch
-                // (tests, or a native-Postgres source where the sort path takes a
-                // different, cheaper route that doesn't build per-table FK lists).
-                let foreign_keys = if let Some(fks) = known_foreign_keys.get(table) {
-                    Ok(fks.clone())
-                } else {
-                    crate::schema::list_foreign_keys_core(
-                        state,
-                        &request.source_connection_id,
-                        &request.source_database,
-                        &request.source_schema,
-                        table,
-                    )
-                    .await
-                };
-                match foreign_keys {
-                    Ok(foreign_keys) if !foreign_keys.is_empty() => {
-                        ddl = strip_inline_foreign_key_constraint_lines(&ddl);
-                        deferred_fk_alters = generate_mysql_foreign_key_alter_statements(
-                            &foreign_keys,
-                            request,
-                            &target_table,
-                            target_db_type,
-                        );
-                    }
-                    Ok(_) => {}
-                    Err(e) => {
-                        log::warn!("[transfer] failed to inspect source foreign keys for {table}: {e}");
-                    }
-                }
-            }
-            log::info!("[transfer] creating target table: {}", ddl.chars().take(200).collect::<String>());
-            let target_table_created = transfer_create_table_created(
-                execute_transfer_create_table_ddl_on_pool(
-                    state,
-                    target_pool_key,
-                    &ddl,
-                    target_db_type,
-                    reused_source_ddl,
-                )
-                .await,
-                "Failed to create table",
-            )?;
-            if target_table_created {
-                pending_fk_alters
-                    .extend(deferred_fk_alters.into_iter().map(|statement| (target_table.clone(), statement)));
-                let comment_stmts = generate_comment_ddl_with_column_quoting(
-                    &columns,
-                    &target_table,
-                    &request.target_schema,
-                    target_db_type,
-                    table_comment.as_deref(),
-                    request.quote_target_column_names,
-                );
-                for stmt in &comment_stmts {
-                    if let Err(e) = execute_on_pool(state, target_pool_key, stmt).await {
-                        log::warn!("[transfer] failed to set column comment for {}: {}", target_table, e);
-                    }
-                }
-                bind_postgres_owned_sequences_for_transfer(
-                    state,
-                    request,
-                    &target_table,
-                    target_pool_key,
-                    &owned_sequences,
-                )
-                .await?;
-            } else {
-                // DDL may report the table already exists even when metadata
-                // lookup missed it (case/schema differences or localized errors).
-                target_table_preexisting = true;
-            }
-        }
+        create_transfer_target_table(
+            state,
+            request,
+            table,
+            &target_table,
+            source_db_type,
+            target_db_type,
+            source_pool_key,
+            target_pool_key,
+            known_foreign_keys,
+            pending_fk_alters,
+            &mut target_table_preexisting,
+            target_renamed_to_backup,
+            &columns,
+            table_comment.as_deref(),
+            pg_compat_transfer,
+            preserves_target_table_name,
+        )
+        .await?;
     }
 
     let should_restore_postgres_table_schema =
@@ -7839,7 +8351,11 @@ where
     // "skipping create-table DDL" above). If the untouched target structure
     // can't accept the planned insert, fail fast here instead of truncating
     // the target's existing data and then hitting an opaque driver error.
-    if request.create_table && target_table_preexisting {
+    //
+    // Skip this validation when drop_target_before_create is true: the original
+    // target table was renamed to a backup and a fresh table matching the source
+    // structure was just created, so structural incompatibility is not possible.
+    if request.create_table && target_table_preexisting && !request.drop_target_before_create {
         validate_preexisting_target_columns(
             &target_columns,
             &col_names,
@@ -7849,8 +8365,10 @@ where
         )?;
     }
 
-    // Truncate target if overwrite mode
-    if request.mode == TransferMode::Overwrite {
+    // Truncate target if overwrite mode (only when not rebuilding the table).
+    // When drop_target_before_create is true, the target table was just created
+    // and is already empty, so TRUNCATE is unnecessary.
+    if request.mode == TransferMode::Overwrite && !request.drop_target_before_create {
         let full_table =
             qualified_table(&target_table, &request.target_schema, target_db_type, request.target_catalog.as_deref());
         let truncate_sql = match target_db_type {
@@ -8045,8 +8563,301 @@ where
     Ok(total_transferred)
 }
 
+/// Free the constraint names the backups are still holding (MySQL family).
+///
+/// MySQL constraint names are unique per database. The rebuilt tables re-create their
+/// foreign keys under the source constraint names through the deferred `ADD CONSTRAINT`
+/// statements, but every backup still holds a constraint with that exact name — the
+/// rename pre-pass moves tables, not constraint names. Each backup constraint is
+/// atomically replaced (single `ALTER` statement) with a derived backup name, keeping
+/// the referenced table — already redirected to the referenced backup by the rename —
+/// and the ON UPDATE/DELETE rules intact.
+///
+/// No-op for non-MySQL targets (constraint names are per-table there) and for pools the
+/// MySQL metadata reader cannot reach.
+pub async fn free_backup_foreign_key_names(
+    state: &Arc<AppState>,
+    request: &TransferRequest,
+    target_db_type: DatabaseType,
+    target_pool_key: &str,
+    backup_names: &HashMap<String, String>,
+) -> Result<(), String> {
+    if backup_names.is_empty() || !supports_deferred_mysql_foreign_keys(&target_db_type) {
+        return Ok(());
+    }
+    let pool = {
+        let pool_handle = state.pool_handle(target_pool_key).await;
+        match pool_handle.as_ref() {
+            Some(PoolKind::Mysql(pool, _)) => pool.clone(),
+            _ => return Ok(()),
+        }
+    };
+    for backup_table in backup_names.values() {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        let foreign_keys = db::mysql::list_foreign_keys(&pool, &request.target_database, backup_table).await?;
+        for (name, group) in group_foreign_keys_by_constraint_name(&foreign_keys) {
+            if name.contains(crate::transfer_rebuild::BACKUP_TABLE_MARKER) {
+                // Already freed by an earlier attempt; re-reading metadata after a
+                // partial success must not try to free the derived name again.
+                continue;
+            }
+            let new_name = crate::transfer_rebuild::backup_table_name(
+                target_db_type,
+                &request.transfer_id,
+                &format!("{}{}#constraint:{}", request.source_schema, backup_table, name),
+                name,
+            )?;
+            let columns = group
+                .iter()
+                .map(|foreign_key| quote_identifier(&foreign_key.column, &target_db_type))
+                .collect::<Vec<_>>()
+                .join(", ");
+            let ref_columns = group
+                .iter()
+                .map(|foreign_key| quote_identifier(&foreign_key.ref_column, &target_db_type))
+                .collect::<Vec<_>>()
+                .join(", ");
+            let referenced_table = match group[0].ref_schema.as_deref() {
+                // Same-database reference: after the rename the referenced name already
+                // points at the referenced table's backup, so keep it as-is.
+                Some(ref_schema) if ref_schema == request.target_database => {
+                    quote_identifier(&group[0].ref_table, &target_db_type)
+                }
+                // Cross-database reference: nothing in this transfer renamed it.
+                Some(ref_schema) => {
+                    format!(
+                        "{}.{}",
+                        quote_identifier(ref_schema, &target_db_type),
+                        quote_identifier(&group[0].ref_table, &target_db_type)
+                    )
+                }
+                None => quote_identifier(&group[0].ref_table, &target_db_type),
+            };
+            let mut statement = format!(
+                "ALTER TABLE {} DROP FOREIGN KEY {}, ADD CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {} ({})",
+                quote_identifier(backup_table, &target_db_type),
+                quote_identifier(name, &target_db_type),
+                quote_identifier(&new_name, &target_db_type),
+                columns,
+                referenced_table,
+                ref_columns,
+            );
+            if let Some(on_delete) = group[0].on_delete.as_deref() {
+                statement.push_str(&format!(" ON DELETE {on_delete}"));
+            }
+            if let Some(on_update) = group[0].on_update.as_deref() {
+                statement.push_str(&format!(" ON UPDATE {on_update}"));
+            }
+            execute_on_pool(state, target_pool_key, &statement).await.map_err(|e| {
+                format!("Failed to free constraint name '{name}' on backup table '{backup_table}': {e}")
+            })?;
+        }
+    }
+    Ok(())
+}
+
+/// Drop every foreign key constraint the backup tables still hold.
+///
+/// The rename pre-pass can move a foreign key cycle into the backup set, and a cycle has
+/// no valid sequential `DROP TABLE` order at all. Dropping the constraints on the backups
+/// breaks only backup-to-backup edges: the rebuilt tables' restored constraints and every
+/// external table are untouched. Individual failures are logged and skipped — the
+/// following drop loop reports the tables it could not remove.
+async fn break_backup_foreign_key_graph(
+    state: &Arc<AppState>,
+    request: &TransferRequest,
+    target_db_type: DatabaseType,
+    target_pool_key: &str,
+    backup_names: &HashMap<String, String>,
+) {
+    // MySQL family: constraint names were already freed by [`free_backup_foreign_key_names`]
+    // when it ran; this re-lists whatever constraints remain (including renamed ones) and
+    // drops them outright, because the tables themselves are about to be dropped.
+    let mysql_pool = {
+        let pool_handle = state.pool_handle(target_pool_key).await;
+        match pool_handle.as_ref() {
+            Some(PoolKind::Mysql(pool, _)) => Some(pool.clone()),
+            _ => None,
+        }
+    };
+    let postgres_family = is_postgres_family_target(&target_db_type);
+    for backup_table in backup_names.values() {
+        if is_cancelled(&request.transfer_id).await {
+            return;
+        }
+        if let Some(pool) = &mysql_pool {
+            match db::mysql::list_foreign_keys(pool, &request.target_database, backup_table).await {
+                Ok(foreign_keys) => {
+                    for name in foreign_keys.iter().map(|fk| fk.name.as_str()).collect::<Vec<_>>() {
+                        let drop_fk = format!(
+                            "ALTER TABLE {} DROP FOREIGN KEY {}",
+                            quote_identifier(backup_table, &target_db_type),
+                            quote_identifier(name, &target_db_type)
+                        );
+                        if let Err(error) = execute_on_pool(state, target_pool_key, &drop_fk).await {
+                            log::warn!(
+                                "[transfer] failed to drop foreign key {name} on backup {backup_table}: {error}"
+                            );
+                        }
+                    }
+                }
+                Err(error) => log::warn!("[transfer] failed to list foreign keys on backup {backup_table}: {error}"),
+            }
+        } else if postgres_family {
+            let foreign_keys = match get_postgres_foreign_keys_for_transfer(
+                state,
+                target_pool_key,
+                &request.target_database,
+                &request.target_schema,
+                backup_table,
+            )
+            .await
+            {
+                Ok(foreign_keys) => foreign_keys,
+                Err(error) => {
+                    log::warn!("[transfer] failed to list foreign keys on backup {backup_table}: {error}");
+                    continue;
+                }
+            };
+            for name in foreign_keys.iter().map(|fk| fk.name.as_str()).collect::<Vec<_>>() {
+                let drop_fk = format!(
+                    "ALTER TABLE {} DROP CONSTRAINT {}",
+                    qualified_table(
+                        backup_table,
+                        &request.target_schema,
+                        &target_db_type,
+                        request.target_catalog.as_deref()
+                    ),
+                    quote_identifier(name, &target_db_type)
+                );
+                if let Err(error) = execute_on_pool(state, target_pool_key, &drop_fk).await {
+                    log::warn!(
+                        "[transfer] failed to drop foreign key constraint {name} on backup {backup_table}: {error}"
+                    );
+                }
+            }
+        } else if target_db_type == DatabaseType::SqlServer {
+            let sqlserver_client = {
+                let pool_handle = state.pool_handle(target_pool_key).await;
+                match pool_handle.as_ref() {
+                    Some(PoolKind::SqlServer(client)) => Some(client.clone()),
+                    _ => None,
+                }
+            };
+            if let Some(client) = &sqlserver_client {
+                // Collect the foreign-key names while holding the client lock, then drop it
+                // before executing the ALTERs through `execute_on_pool` (which re-acquires it).
+                let foreign_keys = {
+                    let mut client = client.lock().await;
+                    match db::sqlserver::list_foreign_keys(&mut client, &request.target_schema, backup_table).await {
+                        Ok(foreign_keys) => foreign_keys,
+                        Err(error) => {
+                            log::warn!("[transfer] failed to list foreign keys on backup {backup_table}: {error}");
+                            continue;
+                        }
+                    }
+                };
+                for name in foreign_keys.iter().map(|fk| fk.name.as_str()).collect::<Vec<_>>() {
+                    let drop_fk = format!(
+                        "ALTER TABLE {} DROP CONSTRAINT {}",
+                        qualified_table(
+                            backup_table,
+                            &request.target_schema,
+                            &target_db_type,
+                            request.target_catalog.as_deref()
+                        ),
+                        quote_identifier(name, &target_db_type)
+                    );
+                    if let Err(error) = execute_on_pool(state, target_pool_key, &drop_fk).await {
+                        log::warn!(
+                            "[transfer] failed to drop foreign key constraint {name} on backup {backup_table}: {error}"
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Drop the backups left behind by [`rename_tables_to_backup`].
+///
+/// Two ordering rules make this a post-loop step rather than per-table cleanup, and neither
+/// shows up until a foreign key connects two selected tables:
+///
+/// - A backup can still be referenced by another backup. Renaming children first keeps each
+///   pair consistent, which also means `DROP TABLE parent_bak` fails while `child_bak` exists.
+///   So the drops run children first — and the backup-to-backup foreign key graph is broken
+///   first, because a foreign key cycle among the backups has no valid drop order at all.
+/// - The backups must be gone before the transfer reports success, but only after the
+///   deferred foreign key ALTERs and the selected schema objects have been restored: on
+///   MySQL the rebuilt tables cannot take over the source constraint names until
+///   [`free_backup_foreign_key_names`] has freed them from the backups.
+///
+/// `drop_order` is the children-first list handed to the rename pre-pass. A backup whose table
+/// is missing from it is still dropped, in name order, so none can leak.
+pub async fn drop_backup_tables(
+    state: &Arc<AppState>,
+    request: &TransferRequest,
+    target_db_type: DatabaseType,
+    target_pool_key: &str,
+    backup_names: &HashMap<String, String>,
+    drop_order: &[String],
+) -> Result<(), String> {
+    let mut ordered: Vec<&String> = drop_order.iter().filter(|table| backup_names.contains_key(*table)).collect();
+    let mut leftovers: Vec<&String> = backup_names.keys().filter(|table| !drop_order.contains(*table)).collect();
+    leftovers.sort();
+    ordered.extend(leftovers);
+
+    break_backup_foreign_key_graph(state, request, target_db_type, target_pool_key, backup_names).await;
+
+    let mut retained: Vec<String> = Vec::new();
+    for table in ordered {
+        let Some(backup_name) = backup_names.get(table) else {
+            continue;
+        };
+        let drop_sql = crate::db_admin_sql::build_drop_table_sql(crate::db_admin_sql::TableAdminSqlOptions {
+            database_type: Some(target_db_type),
+            schema: if request.target_schema.is_empty() { None } else { Some(request.target_schema.clone()) },
+            table_name: backup_name.clone(),
+            // Rendered for the PostgreSQL family only — `build_drop_table_sql` drops the
+            // keyword everywhere else. The backup-to-backup foreign key graph has already
+            // been broken explicitly, so CASCADE is a narrow safety net for objects that
+            // metadata could not see, not the mechanism the cleanup relies on.
+            cascade: Some(true),
+            identifier_quote: None,
+        });
+        match execute_on_pool(state, target_pool_key, &drop_sql).await {
+            Ok(_) => log::info!("[transfer] dropped backup table {backup_name}"),
+            Err(error) => {
+                log::error!("[transfer] failed to drop backup table {backup_name}: {error}");
+                retained.push(format!("{backup_name} ({error})"));
+            }
+        }
+    }
+
+    if retained.is_empty() {
+        // The whole rebuild — backups, renamed objects, cleanup — succeeded. The recovery
+        // journal has nothing left to describe.
+        if let Err(error) = crate::transfer_rebuild::complete_rebuild_journal(state, &request.transfer_id).await {
+            log::warn!("[transfer] failed to remove the rebuild recovery journal: {error}");
+        }
+        return Ok(());
+    }
+    Err(format!(
+        "Transfer completed, but {} backup table(s) could not be dropped and still occupy space: {}. \
+         Remove them manually to finish cleanup.",
+        retained.len(),
+        retained.join(", ")
+    ))
+}
+
 /// Transfer one table on its own Tokio task so the large transfer future and
 /// nested driver metadata futures do not share a single worker stack.
+///
+/// Pass the [`rename_tables_to_backup`] result as `preexisting_backup_names` whenever
+/// `drop_target_before_create` is set; the transfer errors out without it.
 #[allow(clippy::too_many_arguments)]
 pub async fn transfer_table<F>(
     state: &Arc<AppState>,
@@ -8059,6 +8870,7 @@ pub async fn transfer_table<F>(
     target_pool_key: &str,
     known_foreign_keys: &HashMap<String, Vec<db::ForeignKeyInfo>>,
     pending_fk_alters: &mut Vec<(String, String)>,
+    preexisting_backup_names: Option<&HashMap<String, String>>,
     mut progress_callback: F,
 ) -> Result<u64, String>
 where
@@ -8075,6 +8887,15 @@ where
         .get(&table)
         .map(|foreign_keys| HashMap::from([(table.clone(), foreign_keys.clone())]))
         .unwrap_or_default();
+    let preexisting_backup_names = preexisting_backup_names.map(|m| m.clone());
+    // Kept outside the spawned task: `request` moves into it, and the error path below
+    // still needs the backup's qualified name to point the user at their data.
+    let backup_for_this_table = request
+        .drop_target_before_create
+        .then(|| preexisting_backup_names.as_ref().and_then(|names| names.get(&table).cloned()))
+        .flatten();
+    let request_target_schema = request.target_schema.clone();
+    let request_target_catalog = request.target_catalog.clone();
     let (progress_tx, mut progress_rx) = tokio::sync::mpsc::channel(TRANSFER_PROGRESS_CHANNEL_CAPACITY);
 
     let mut task = tokio::spawn(async move {
@@ -8090,6 +8911,7 @@ where
             &target_pool_key,
             &known_foreign_keys,
             &mut task_pending_fk_alters,
+            preexisting_backup_names.as_ref(),
             move |progress| {
                 try_send_transfer_progress(&progress_tx, progress);
             },
@@ -8107,7 +8929,20 @@ where
                 let (result, task_pending_fk_alters) =
                     result.map_err(|error| format!("Transfer table task failed: {error}"))?;
                 pending_fk_alters.extend(task_pending_fk_alters);
-                return result;
+                // Every failure past the rename pre-pass leaves the original table under its
+                // backup name. This is the last place that still holds the name, so the note
+                // is attached here rather than at each of the inner `?` sites. Cancellation
+                // keeps its exact discriminator: the callers match on the bare "Cancelled"
+                // string to render a cancelled (not failed) terminal progress event.
+                return match (result, backup_for_this_table.as_deref()) {
+                    (Err(error), Some(backup_name)) if error != "Cancelled" => {
+                        Err(crate::transfer_rebuild::annotate_error_with_retained_backup(
+                            error,
+                            &qualified_table(backup_name, &request_target_schema, &target_db_type, request_target_catalog.as_deref()),
+                        ))
+                    }
+                    (result, _) => result,
+                };
             }
         }
     }
@@ -8765,6 +9600,30 @@ mod tests {
         );
     }
 
+    /// The rename pre-pass of `drop_target_before_create` consumes the `parents_first =
+    /// false` order, and a foreign key cycle has no such order. Cycle members must still
+    /// come out — appended in their original order — because dropping them would silently
+    /// leave those tables un-renamed and the main pass would append into the old table.
+    #[test]
+    fn table_dependency_sort_keeps_cycle_members_instead_of_dropping_them() {
+        let tables = vec!["employees".to_string(), "departments".to_string(), "regions".to_string()];
+        // employees <-> departments is a cycle; regions is free of foreign keys.
+        let dependencies = vec![
+            ("employees".to_string(), "departments".to_string()),
+            ("departments".to_string(), "employees".to_string()),
+        ];
+
+        for parents_first in [true, false] {
+            let sorted = sort_table_names_by_dependencies(&tables, &dependencies, parents_first);
+            assert_eq!(sorted.len(), tables.len(), "cycle members were dropped (parents_first={parents_first})");
+            assert_eq!(
+                sorted,
+                vec!["regions".to_string(), "employees".to_string(), "departments".to_string()],
+                "the acyclic table sorts first, then the cycle in input order (parents_first={parents_first})"
+            );
+        }
+    }
+
     #[test]
     fn table_dependency_sort_ignores_duplicates_and_out_of_scope_tables() {
         let tables = vec!["orders".to_string(), "users".to_string(), "logs".to_string()];
@@ -8963,6 +9822,8 @@ mod tests {
             quote_target_column_names: true,
             ownership_policy: TransferOwnershipPolicy::Preserve,
             batch_size: 1000,
+            drop_target_before_create: false,
+            drop_target_confirmed: false,
         };
         let json = serde_json::to_value(&request).unwrap();
         assert_eq!(json["content"], "structureOnly");
@@ -9038,6 +9899,8 @@ mod tests {
                 batch_size: 1000,
                 content: TransferContent::DataOnly,
                 objects: Vec::new(),
+                drop_target_before_create: false,
+                drop_target_confirmed: false,
             };
             assert!(validate_transfer_request(&base).is_ok());
 
@@ -9054,6 +9917,56 @@ mod tests {
             let structure_only = TransferRequest { content: TransferContent::StructureOnly, ..base.clone() };
             assert!(validate_transfer_request(&structure_only).is_ok());
         }
+
+        #[test]
+        fn rejects_drop_target_before_create_with_data_only() {
+            let base = TransferRequest {
+                transfer_id: "t".into(),
+                source_connection_id: "s".into(),
+                source_database: "db".into(),
+                source_schema: "public".into(),
+                source_catalog: None,
+                target_connection_id: "t".into(),
+                target_database: "db".into(),
+                target_schema: "public".into(),
+                target_catalog: None,
+                tables: vec!["orders".into()],
+                create_table: true,
+                mode: TransferMode::Append,
+                target_table_name_case: TransferTableNameCase::Preserve,
+                quote_target_column_names: true,
+                ownership_policy: TransferOwnershipPolicy::Preserve,
+                batch_size: 1000,
+                content: TransferContent::StructureAndData,
+                objects: Vec::new(),
+                drop_target_before_create: false,
+                drop_target_confirmed: false,
+            };
+
+            // drop_target_before_create=false → valid
+            assert!(validate_transfer_request(&base).is_ok());
+
+            // drop_target_before_create=true + StructureAndData → valid
+            let with_drop = TransferRequest { drop_target_before_create: true, ..base.clone() };
+            assert!(validate_transfer_request(&with_drop).is_ok());
+
+            // drop_target_before_create=true + StructureOnly → valid
+            let structure_only = TransferRequest {
+                content: TransferContent::StructureOnly,
+                drop_target_before_create: true,
+                ..base.clone()
+            };
+            assert!(validate_transfer_request(&structure_only).is_ok());
+
+            // drop_target_before_create=true + DataOnly → error
+            let data_only =
+                TransferRequest { content: TransferContent::DataOnly, drop_target_before_create: true, ..base.clone() };
+            let err = validate_transfer_request(&data_only).unwrap_err();
+            assert!(
+                err.contains("drop_target_before_create") && err.contains("DataOnly"),
+                "expected error to mention drop_target_before_create and DataOnly, got: {err}"
+            );
+        }
     }
 
     mod transfer_existence_tests {
@@ -10064,6 +10977,8 @@ mod tests {
             quote_target_column_names: true,
             ownership_policy: TransferOwnershipPolicy::Preserve,
             batch_size: 1000,
+            drop_target_before_create: false,
+            drop_target_confirmed: false,
         }
     }
 
diff --git a/crates/dbx-core/src/transfer/ddl_plan.rs b/crates/dbx-core/src/transfer/ddl_plan.rs
new file mode 100644
index 0000000000..e6584069f4
--- /dev/null
+++ b/crates/dbx-core/src/transfer/ddl_plan.rs
@@ -0,0 +1,420 @@
+//! Prepare target CREATE TABLE and deferred foreign keys without executing DDL.
+//!
+//! The transfer pass and the ownership preview share this planning helper so both always
+//! agree on the DDL that will run and the names it will use. Nothing here executes DDL:
+//! execution stays with `execute_transfer_create_table_ddl_on_pool` and the caller.
+
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub(super) struct PreparedTableDdl {
+    pub ddl: String,
+    pub reused_source_ddl: bool,
+    pub deferred_fk_alters: Vec<String>,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) async fn prepare_table_ddl(
+    state: &AppState,
+    request: &TransferRequest,
+    table: &str,
+    target_table: &str,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+    source_pool_key: &str,
+    columns: &[db::ColumnInfo],
+    table_comment: Option<&str>,
+    known_foreign_keys: &HashMap<String, Vec<db::ForeignKeyInfo>>,
+) -> Result<PreparedTableDdl, String> {
+    let rebuild = request.drop_target_before_create;
+
+    let foreign_keys = if let Some(foreign_keys) = known_foreign_keys.get(table) {
+        foreign_keys.clone()
+    } else if rebuild {
+        // Strict for rebuilds: silently dropping foreign keys the inspection failed on
+        // would produce a rebuilt table that enforces fewer constraints than the source.
+        crate::schema::list_foreign_keys_core(
+            state,
+            &request.source_connection_id,
+            &request.source_database,
+            &request.source_schema,
+            table,
+        )
+        .await
+        .map_err(|e| format!("Failed to inspect source foreign keys for table '{table}' before rebuilding: {e}"))?
+    } else if supports_deferred_mysql_foreign_keys(target_db_type) {
+        // Ordinary MySQL-family targets keep the legacy best-effort behavior: fall back
+        // to the generated DDL without foreign keys when the inspection fails. Other
+        // targets never use the foreign keys, so no query is issued at all.
+        match crate::schema::list_foreign_keys_core(
+            state,
+            &request.source_connection_id,
+            &request.source_database,
+            &request.source_schema,
+            table,
+        )
+        .await
+        {
+            Ok(foreign_keys) => foreign_keys,
+            Err(e) => {
+                log::warn!("[transfer] failed to inspect source foreign keys for {table}: {e}");
+                Vec::new()
+            }
+        }
+    } else {
+        Vec::new()
+    };
+
+    let (source_driver_profile, target_driver_profile) = {
+        let configs = state.configs.read().await;
+        (
+            configs.get(&request.source_connection_id).and_then(|config| config.driver_profile.clone()),
+            configs.get(&request.target_connection_id).and_then(|config| config.driver_profile.clone()),
+        )
+    };
+    let can_reuse = can_reuse_source_table_ddl(
+        source_db_type,
+        target_db_type,
+        source_driver_profile.as_deref(),
+        target_driver_profile.as_deref(),
+        target_table == table,
+    ) && (request.quote_target_column_names
+        || !matches!(target_db_type, DatabaseType::Gaussdb | DatabaseType::OpenGauss));
+
+    // A rebuild recreates the source structure exactly. When the structure comes from
+    // the source DDL (the `can_reuse` path) the column list is only used for data
+    // mapping, so an empty list is fine — the DDL is read directly from the source. Only
+    // when the DDL must be *generated* from the column list does incomplete metadata
+    // become fatal, because there would be nothing to build the CREATE TABLE from.
+    if rebuild && !can_reuse {
+        let incomplete = columns.is_empty()
+            || columns.iter().any(|column| column.name.trim().is_empty() || column.data_type.trim().is_empty());
+        if incomplete {
+            return Err(format!(
+                "Cannot rebuild table '{target_table}': the source returned incomplete column metadata, and the \
+                 target cannot reuse the source DDL."
+            ));
+        }
+    }
+
+    let mut reused_source_ddl = false;
+    let ddl = if can_reuse {
+        let (source_ddl, source_ddl_was_read) = if let Some(catalog) =
+            resolve_external_transfer_catalog(request.source_catalog.as_deref(), source_db_type)
+        {
+            // Doris/StarRocks external catalog: read DDL directly via
+            // SHOW CREATE TABLE catalog.database.table using the existing source
+            // pool (bare MySQL — addresses any catalog).
+            let pool = {
+                let pool =
+                    state.pool_handle(source_pool_key).await.ok_or_else(|| "Source pool not found".to_string())?;
+                let PoolKind::Mysql(p, _) = &pool else {
+                    return Err("Source pool must be MySQL-family for catalog DDL".to_string());
+                };
+                p.clone()
+            };
+            match db::doris::get_catalog_table_ddl(&pool, catalog, &request.source_database, table).await {
+                Ok(ddl) => (ddl, true),
+                Err(err) => {
+                    log::warn!("[transfer] catalog DDL read failed for {table} in catalog '{catalog}': {err}; falling back to generated DDL");
+                    (
+                        generate_create_table_ddl_with_column_quoting(
+                            columns,
+                            target_table,
+                            &request.source_schema,
+                            &request.target_schema,
+                            target_db_type,
+                            source_db_type,
+                            table_comment,
+                            request.target_catalog.as_deref(),
+                            request.quote_target_column_names,
+                        ),
+                        false,
+                    )
+                }
+            }
+        } else {
+            match crate::schema::get_table_ddl_core(
+                state,
+                &request.source_connection_id,
+                &request.source_database,
+                &request.source_schema,
+                table,
+                None,
+            )
+            .await
+            {
+                Ok(ddl) => (ddl, true),
+                Err(e) if rebuild => {
+                    // A rebuild cannot fall back to generated DDL when the source DDL
+                    // it promised to reproduce cannot be read.
+                    return Err(format!("Failed to read source DDL for table '{table}' before rebuilding: {e}"));
+                }
+                Err(_) => (
+                    generate_create_table_ddl_with_column_quoting(
+                        columns,
+                        target_table,
+                        &request.source_schema,
+                        &request.target_schema,
+                        target_db_type,
+                        source_db_type,
+                        table_comment,
+                        request.target_catalog.as_deref(),
+                        request.quote_target_column_names,
+                    ),
+                    false,
+                ),
+            }
+        };
+        if contains_oceanbase_mysql_table_options(&source_ddl)
+            && !db::oceanbase_mysql::is_profile(target_db_type, target_driver_profile.as_deref())
+        {
+            generate_create_table_ddl_with_column_quoting(
+                columns,
+                target_table,
+                &request.source_schema,
+                &request.target_schema,
+                target_db_type,
+                source_db_type,
+                table_comment,
+                request.target_catalog.as_deref(),
+                request.quote_target_column_names,
+            )
+        } else {
+            reused_source_ddl = source_ddl_was_read;
+            rewrite_transfer_source_table_ddl(
+                &source_ddl,
+                &request.source_schema,
+                &request.target_schema,
+                source_db_type,
+                target_db_type,
+            )
+        }
+    } else {
+        generate_create_table_ddl_with_column_quoting(
+            columns,
+            target_table,
+            &request.source_schema,
+            &request.target_schema,
+            target_db_type,
+            source_db_type,
+            table_comment,
+            request.target_catalog.as_deref(),
+            request.quote_target_column_names,
+        )
+    };
+
+    // MySQL-family targets: defer the foreign keys to ALTER statements so the table
+    // creation order never has to satisfy foreign key dependencies (a foreign key cycle
+    // has no valid CREATE TABLE order at all). The rebuild path above guarantees the
+    // metadata behind `foreign_keys` is trustworthy before anything is stripped.
+    let mut ddl = ddl;
+    let mut deferred_fk_alters = Vec::new();
+    if supports_deferred_mysql_foreign_keys(target_db_type) && !foreign_keys.is_empty() {
+        ddl = strip_inline_foreign_key_constraint_lines(&ddl);
+        deferred_fk_alters =
+            generate_mysql_foreign_key_alter_statements(&foreign_keys, request, target_table, target_db_type);
+    }
+
+    Ok(PreparedTableDdl { ddl, reused_source_ddl, deferred_fk_alters })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    async fn state_fixture() -> (Arc<AppState>, tempfile::TempDir) {
+        let directory = tempfile::tempdir().unwrap();
+        let storage = crate::storage::Storage::open(&directory.path().join("storage.db")).await.unwrap();
+        let state = Arc::new(AppState::new_with_plugin_dir(storage, directory.path().join("plugins")));
+        (state, directory)
+    }
+
+    fn request(rebuild: bool) -> TransferRequest {
+        serde_json::from_value(json!({
+            "transferId": "ddl-plan-test",
+            "sourceConnectionId": "source", "sourceDatabase": "main", "sourceSchema": "main",
+            "targetConnectionId": "target", "targetDatabase": "main", "targetSchema": "main",
+            "tables": ["child", "Parent"], "createTable": true, "content": "structureAndData",
+            "mode": "append", "batchSize": 10, "dropTargetBeforeCreate": rebuild,
+            "dropTargetConfirmed": true
+        }))
+        .unwrap()
+    }
+
+    fn columns() -> Vec<db::ColumnInfo> {
+        vec![
+            db::ColumnInfo {
+                name: "id".into(),
+                data_type: "INTEGER".into(),
+                is_primary_key: true,
+                ..Default::default()
+            },
+            db::ColumnInfo { name: "parent_id".into(), data_type: "INTEGER".into(), ..Default::default() },
+        ]
+    }
+
+    #[tokio::test]
+    async fn prepared_sqlite_ddl_preserves_source_foreign_keys_without_mutating_source() {
+        let (state, directory) = state_fixture().await;
+        let path = directory.path().join("source.db");
+        let pool = crate::db::sqlite::connect_path_create_if_missing(path.to_str().unwrap()).await.unwrap();
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "PRAGMA foreign_keys = ON;
+                     CREATE TABLE Parent (id INTEGER PRIMARY KEY);
+                     CREATE TABLE child (id INTEGER PRIMARY KEY, parent_id INTEGER REFERENCES Parent(id) ON DELETE CASCADE);
+                     INSERT INTO Parent VALUES (7);
+                     INSERT INTO child VALUES (11, 7);",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let config: ConnectionConfig = serde_json::from_value(json!({
+            "id": "source", "name": "source", "db_type": "sqlite", "host": path.to_str().unwrap(),
+            "port": 0, "username": "", "password": "", "database": null,
+            "one_time": false, "save_password": false, "read_only": false
+        }))
+        .unwrap();
+        state.configs.write().await.insert("source".into(), config);
+        let source_pool_key = ensure_transfer_pool(&state, "source", "main", None).await.unwrap();
+        let columns = crate::db::sqlite::get_columns(&pool, "main", "child").await.unwrap();
+        let prepared = prepare_table_ddl(
+            &state,
+            &request(true),
+            "child",
+            "child",
+            &DatabaseType::Sqlite,
+            &DatabaseType::Sqlite,
+            &source_pool_key,
+            &columns,
+            None,
+            &HashMap::new(),
+        )
+        .await
+        .unwrap();
+        let source_rows = crate::db::sqlite::execute_query(&pool, "SELECT id, parent_id FROM child").await.unwrap();
+        assert_eq!(source_rows.rows, vec![vec![json!(11), json!(7)]]);
+
+        let target =
+            crate::db::sqlite::connect_path_create_if_missing(directory.path().join("target.db").to_str().unwrap())
+                .await
+                .unwrap();
+        target
+            .with_connection(|connection| {
+                connection
+                    .execute_batch("PRAGMA foreign_keys = ON; CREATE TABLE Parent (id INTEGER PRIMARY KEY);")
+                    .map_err(|error| error.to_string())?;
+                connection.execute_batch(&prepared.ddl).map_err(|error| error.to_string())
+            })
+            .unwrap();
+        let foreign_keys = crate::db::sqlite::list_foreign_keys(&target, "main", "child").await.unwrap();
+        assert_eq!(foreign_keys.len(), 1, "source FK must survive the prepared CREATE TABLE: {}", prepared.ddl);
+        assert_eq!(foreign_keys[0].ref_table, "Parent");
+        assert!(crate::db::sqlite::execute_query(&target, "INSERT INTO child VALUES (1, 999)").await.is_err());
+        assert!(prepared.reused_source_ddl);
+    }
+
+    #[tokio::test]
+    async fn rebuild_rejects_failed_foreign_key_inspection() {
+        let (state, _directory) = state_fixture().await;
+        let error = prepare_table_ddl(
+            &state,
+            &request(true),
+            "child",
+            "child",
+            &DatabaseType::Sqlite,
+            &DatabaseType::Mysql,
+            "missing-source-pool",
+            &columns(),
+            None,
+            &HashMap::new(),
+        )
+        .await
+        .expect_err("a rebuild cannot discard foreign keys when source metadata is unavailable");
+        assert!(error.contains("child"), "{error}");
+        assert!(error.to_ascii_lowercase().contains("foreign key"), "{error}");
+    }
+
+    #[tokio::test]
+    async fn ordinary_foreign_key_metadata_failure_preserves_generated_fallback() {
+        let (state, _directory) = state_fixture().await;
+        let prepared = prepare_table_ddl(
+            &state,
+            &request(false),
+            "child",
+            "child",
+            &DatabaseType::Sqlite,
+            &DatabaseType::Mysql,
+            "missing-source-pool",
+            &columns(),
+            None,
+            &HashMap::new(),
+        )
+        .await
+        .unwrap();
+        assert!(!prepared.reused_source_ddl);
+        assert!(prepared.ddl.contains("CREATE TABLE"));
+    }
+
+    #[tokio::test]
+    async fn deferred_foreign_key_uses_actual_target_and_case_converted_parent() {
+        let (state, _directory) = state_fixture().await;
+        let mut request = request(true);
+        request.target_table_name_case = TransferTableNameCase::Lower;
+        let known = HashMap::from([(
+            "child".into(),
+            vec![db::ForeignKeyInfo {
+                name: "fk_child_parent".into(),
+                column: "parent_id".into(),
+                ref_schema: Some("main".into()),
+                ref_table: "Parent".into(),
+                ref_column: "id".into(),
+                on_delete: Some("CASCADE".into()),
+                on_update: Some("RESTRICT".into()),
+            }],
+        )]);
+        let prepared = prepare_table_ddl(
+            &state,
+            &request,
+            "child",
+            "resolved_child",
+            &DatabaseType::Sqlite,
+            &DatabaseType::Mysql,
+            "missing-source-pool",
+            &columns(),
+            None,
+            &known,
+        )
+        .await
+        .unwrap();
+        assert_eq!(prepared.deferred_fk_alters, vec![
+            "ALTER TABLE `resolved_child` ADD CONSTRAINT `fk_child_parent` FOREIGN KEY (`parent_id`) REFERENCES `parent` (`id`) ON DELETE CASCADE ON UPDATE RESTRICT"
+        ]);
+        assert!(prepared.ddl.contains("`resolved_child`"), "{}", prepared.ddl);
+    }
+
+    #[tokio::test]
+    async fn rebuild_requires_complete_column_metadata() {
+        let (state, _directory) = state_fixture().await;
+        let incomplete = vec![db::ColumnInfo { name: "id".into(), ..Default::default() }];
+        for columns in [&[][..], incomplete.as_slice()] {
+            let result = prepare_table_ddl(
+                &state,
+                &request(true),
+                "child",
+                "child",
+                &DatabaseType::Sqlite,
+                &DatabaseType::Mysql,
+                "missing-source-pool",
+                columns,
+                None,
+                &HashMap::from([("child".into(), Vec::new())]),
+            )
+            .await;
+            assert!(result.is_err(), "incomplete source metadata must fail before any target DDL: {result:?}");
+        }
+    }
+}
diff --git a/crates/dbx-core/src/transfer/rebuild_tests.rs b/crates/dbx-core/src/transfer/rebuild_tests.rs
new file mode 100644
index 0000000000..e278941d2e
--- /dev/null
+++ b/crates/dbx-core/src/transfer/rebuild_tests.rs
@@ -0,0 +1,116 @@
+use super::*;
+use serde_json::json;
+
+async fn sqlite_fixture() -> (tempfile::TempDir, Arc<AppState>, TransferRequest, String, String) {
+    let directory = tempfile::tempdir().unwrap();
+    let storage = crate::storage::Storage::open(&directory.path().join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new_with_plugin_dir(storage, directory.path().join("plugins")));
+    for id in ["source", "target"] {
+        let path = directory.path().join(format!("{id}.db"));
+        crate::db::sqlite::connect_path_create_if_missing(path.to_str().unwrap()).await.unwrap();
+        let config: ConnectionConfig = serde_json::from_value(json!({
+            "id": id, "name": id, "db_type": "sqlite", "host": path.to_str().unwrap(),
+            "port": 0, "username": "", "password": "", "database": null,
+            "one_time": false, "save_password": false, "read_only": false
+        }))
+        .unwrap();
+        state.configs.write().await.insert(id.to_string(), config);
+    }
+    let source_pool = ensure_transfer_pool(&state, "source", "main", None).await.unwrap();
+    let target_pool = ensure_transfer_pool(&state, "target", "main", None).await.unwrap();
+    for table in ["orders", "users"] {
+        execute_on_pool(&state, &source_pool, &format!("CREATE TABLE {table}(id INTEGER PRIMARY KEY, name TEXT)"))
+            .await
+            .unwrap();
+        execute_on_pool(&state, &source_pool, &format!("INSERT INTO {table} VALUES(1, 'source')")).await.unwrap();
+        execute_on_pool(&state, &target_pool, &format!("CREATE TABLE {table}(id INTEGER PRIMARY KEY, old_value TEXT)"))
+            .await
+            .unwrap();
+        execute_on_pool(&state, &target_pool, &format!("INSERT INTO {table} VALUES(99, 'original')")).await.unwrap();
+    }
+    let request: TransferRequest = serde_json::from_value(json!({
+        "transferId": uuid::Uuid::new_v4().to_string(),
+        "sourceConnectionId": "source", "sourceDatabase": "main", "sourceSchema": "main",
+        "targetConnectionId": "target", "targetDatabase": "main", "targetSchema": "main",
+        "tables": ["orders", "users"], "createTable": true, "content": "structureAndData",
+        "mode": "append", "batchSize": 1, "dropTargetBeforeCreate": true,
+        "dropTargetConfirmed": true
+    }))
+    .unwrap();
+    (directory, state, request, source_pool, target_pool)
+}
+
+#[tokio::test]
+async fn transfer_rebuild_preflights_every_backup_collision_before_renaming_any_table() {
+    let (_directory, state, request, _, target_pool) = sqlite_fixture().await;
+    let backup =
+        crate::transfer_rebuild::backup_table_name(DatabaseType::Sqlite, &request.transfer_id, "main.users", "users")
+            .unwrap();
+    execute_on_pool(&state, &target_pool, &format!("CREATE TABLE \"{backup}\"(id INTEGER)")).await.unwrap();
+    let result =
+        rename_tables_to_backup(&state, &request, &request.tables, DatabaseType::Sqlite, &target_pool, |_| {}).await;
+    assert!(result.is_err(), "a preexisting backup must block the operation");
+    let original = execute_read_on_pool(&state, &target_pool, "SELECT old_value FROM orders WHERE id=99").await;
+    assert!(original.is_ok(), "a collision on users must not rename orders: {original:?}");
+    assert_eq!(original.unwrap().rows[0][0], json!("original"));
+}
+
+#[tokio::test]
+async fn transfer_rebuild_cancellation_remains_a_cancellation_after_backup() {
+    let (_directory, state, mut request, source_pool, target_pool) = sqlite_fixture().await;
+    request.tables = vec!["orders".into()];
+    let backups =
+        rename_tables_to_backup(&state, &request, &request.tables, DatabaseType::Sqlite, &target_pool, |_| {})
+            .await
+            .unwrap();
+    set_cancelled(&request.transfer_id).await;
+    let result = transfer_table(
+        &state,
+        &request,
+        "orders",
+        0,
+        &DatabaseType::Sqlite,
+        &DatabaseType::Sqlite,
+        &source_pool,
+        &target_pool,
+        &HashMap::new(),
+        &mut Vec::new(),
+        Some(&backups),
+        |_| {},
+    )
+    .await;
+    clear_cancelled(&request.transfer_id).await;
+    assert_eq!(result.unwrap_err(), "Cancelled", "recovery details must not change the cancellation discriminator");
+}
+
+#[tokio::test]
+async fn transfer_rebuild_preview_plans_without_executing_ddl() {
+    let (_directory, state, request, source_pool, target_pool) = sqlite_fixture().await;
+    let preview = preview_transfer_ownership(
+        &state,
+        &request,
+        &DatabaseType::Sqlite,
+        &DatabaseType::Sqlite,
+        &source_pool,
+        &target_pool,
+    )
+    .await
+    .unwrap();
+    let rebuild = preview.rebuild.expect("a rebuild transfer must expose its SQL plan");
+
+    assert_eq!(rebuild.tables.len(), 2, "every source table must be mapped: {:?}", rebuild.tables);
+    for table in &rebuild.tables {
+        assert!(table.backup_table.is_some(), "preexisting targets must carry a backup name: {table:?}");
+    }
+    assert!(rebuild.sql.contains("-- 1. Backup existing target tables"), "{}", rebuild.sql);
+    assert!(rebuild.sql.contains("-- 2. Recreate the"), "{}", rebuild.sql);
+    assert!(rebuild.sql.contains("-- 3. Drop backups after success"), "{}", rebuild.sql);
+
+    // The preview must be pure planning: neither table may have been renamed aside.
+    for table in ["orders", "users"] {
+        let rows =
+            execute_read_on_pool(&state, &target_pool, &format!("SELECT old_value FROM {table} WHERE id=99")).await;
+        assert!(rows.is_ok(), "preview must not rename {table}: {rows:?}");
+        assert_eq!(rows.unwrap().rows[0][0], json!("original"));
+    }
+}
diff --git a/crates/dbx-core/src/transfer_rebuild.rs b/crates/dbx-core/src/transfer_rebuild.rs
new file mode 100644
index 0000000000..b1bde7db8e
--- /dev/null
+++ b/crates/dbx-core/src/transfer_rebuild.rs
@@ -0,0 +1,1476 @@
+//! Support for the transfer option `drop_target_before_create`.
+//!
+//! The transfer path has no usable transaction (see `transfer::execute_on_pool`: every
+//! statement checks out a fresh connection), so the target table is renamed to a backup
+//! instead of dropped. The backup is dropped only after the whole transfer succeeds; any
+//! failure leaves it in place for manual recovery.
+//!
+//! This module owns the backup identifier: deriving it, and keeping it inside the target
+//! dialect's identifier budget.
+
+use sha2::{Digest, Sha256};
+use sqlparser::ast::{visit_relations, ObjectNamePart, Statement, TableFactor, Visit, Visitor};
+use sqlparser::dialect::{DuckDbDialect, SQLiteDialect};
+use sqlparser::parser::Parser;
+use std::collections::BTreeSet;
+use std::ops::ControlFlow;
+
+use crate::connection::AppState;
+use crate::db_admin_sql::{supports_object_rename, DatabaseObjectType};
+use crate::models::connection::DatabaseType;
+use crate::production_safety::is_production_database;
+use crate::sql_dialect::DialectCapabilityDescriptor;
+
+/// Marker that identifies a table as a DBX transfer backup.
+pub const BACKUP_TABLE_MARKER: &str = "__dbx_bak_";
+
+/// Error prefix returned when a production target needs the destructive confirmation.
+/// The frontend matches on this to raise its confirmation dialog instead of a plain error.
+pub const DROP_TARGET_CONFIRMATION_REQUIRED: &str = "TRANSFER_DROP_TARGET_CONFIRMATION_REQUIRED";
+
+/// Error prefix returned when the target dialect is outside the supported set.
+pub const DROP_TARGET_UNSUPPORTED_DATABASE: &str = "TRANSFER_DROP_TARGET_UNSUPPORTED_DATABASE";
+
+/// Error prefix returned when tables outside the transfer reference a target table.
+/// Not recoverable by confirming: the user has to widen the selection or drop the
+/// foreign keys, so the frontend surfaces it as a plain error with the table list.
+pub const DROP_TARGET_EXTERNAL_FOREIGN_KEYS: &str = "TRANSFER_DROP_TARGET_EXTERNAL_FOREIGN_KEYS";
+
+/// Error prefix for dependent objects that cannot be redirected during a rebuild.
+pub const DROP_TARGET_EXTERNAL_DEPENDENCIES: &str = "TRANSFER_DROP_TARGET_EXTERNAL_DEPENDENCIES";
+
+/// Dialects cleared for `drop_target_before_create`.
+///
+/// The excluded engines fall into three groups: no table object (MongoDB), a rebuild that
+/// silently loses engine metadata (ClickHouse ENGINE/ORDER BY/TTL, QuestDB designated
+/// timestamp), and managed-table DROP that also deletes the warehouse data files
+/// (Hive/Spark/Kyuubi/Impala/Argo).
+///
+/// Oracle, Dameng and OceanBase-Oracle are additionally excluded even though they support
+/// table rename: their constraint and index names are schema-unique, and the rename
+/// pre-pass has not yet learned to release those names on the backup tables, so a rebuilt
+/// table reusing the source DDL would collide (ORA-00955 / "already an object named").
+const DROP_TARGET_SUPPORTED: &[DatabaseType] = &[
+    DatabaseType::Mysql,
+    DatabaseType::Postgres,
+    DatabaseType::SqlServer,
+    DatabaseType::Kingbase,
+    DatabaseType::Gaussdb,
+    DatabaseType::OpenGauss,
+    DatabaseType::Kwdb,
+    DatabaseType::Goldendb,
+    DatabaseType::Sqlite,
+    DatabaseType::DuckDb,
+    DatabaseType::CloudflareD1,
+];
+
+/// Hex characters of the derived hash appended after [`BACKUP_TABLE_MARKER`].
+const BACKUP_HASH_LEN: usize = 8;
+
+/// Identifier budget used when the dialect descriptor reports no limit. Deliberately the
+/// tightest real limit in the descriptor table (Oracle) so an unknown target cannot
+/// produce an over-long name.
+const FALLBACK_MAX_IDENTIFIER_BYTES: usize = 30;
+
+/// Identifier byte budget for `database_type`.
+///
+/// Measured in bytes even for dialects that count characters (MySQL): bytes are the
+/// stricter reading, and over-truncating only makes the backup name shorter.
+pub fn max_identifier_bytes(database_type: DatabaseType) -> usize {
+    let reported = DialectCapabilityDescriptor::capabilities_for_database_type(database_type).max_identifier_length;
+    if reported == 0 {
+        FALLBACK_MAX_IDENTIFIER_BYTES
+    } else {
+        reported as usize
+    }
+}
+
+/// Derive the backup table name for one source table inside one transfer.
+///
+/// Stable for a given `(transfer_id, qualified_source)` pair, so a retried step inside the
+/// same transfer targets the same backup. Distinct source tables never collide even when
+/// their names truncate to the same stem, because the hash covers the full qualified name.
+pub fn backup_table_name(
+    database_type: DatabaseType,
+    transfer_id: &str,
+    qualified_source: &str,
+    target_table_name: &str,
+) -> Result<String, String> {
+    let mut hasher = Sha256::new();
+    hasher.update(transfer_id.as_bytes());
+    hasher.update([0x1f]);
+    hasher.update(qualified_source.as_bytes());
+    let digest = format!("{:x}", hasher.finalize());
+    let suffix = format!("{BACKUP_TABLE_MARKER}{}", &digest[..BACKUP_HASH_LEN]);
+
+    let budget = max_identifier_bytes(database_type);
+    if budget <= suffix.len() {
+        return Err(format!(
+            "Cannot derive a backup table name for {target_table_name}: {} allows only {budget} identifier bytes, \
+             and the backup suffix needs {}.",
+            database_type.as_str(),
+            suffix.len() + 1
+        ));
+    }
+    let stem = truncate_on_char_boundary(target_table_name, budget - suffix.len());
+    Ok(format!("{stem}{suffix}"))
+}
+
+/// Truncate to at most `max_bytes` bytes without splitting a UTF-8 character.
+fn truncate_on_char_boundary(value: &str, max_bytes: usize) -> &str {
+    if value.len() <= max_bytes {
+        return value;
+    }
+    let mut end = max_bytes;
+    while end > 0 && !value.is_char_boundary(end) {
+        end -= 1;
+    }
+    &value[..end]
+}
+
+/// Append the retained backup table to a failure message.
+///
+/// Once the rename pre-pass has run, every later failure leaves the original table behind
+/// under its backup name. The name is derived from the transfer id and is not stored
+/// anywhere, so an error that omits it leaves the user with no way to find their data.
+///
+/// Idempotent: a message that already names the backup — the drop-backup failure path does
+/// — is returned unchanged instead of naming it twice.
+pub fn annotate_error_with_retained_backup(error: String, qualified_backup: &str) -> String {
+    if error.contains(qualified_backup) {
+        return error;
+    }
+    format!("{error} The original target table was kept as backup '{qualified_backup}'; rename it back to recover.")
+}
+
+/// Whether `database_type` is cleared for `drop_target_before_create`.
+///
+/// Membership in [`DROP_TARGET_SUPPORTED`] is necessary but not sufficient: the backup step
+/// needs a table rename, so a dialect that loses rename support also loses this option.
+pub fn supports_drop_target_before_create(database_type: DatabaseType) -> bool {
+    DROP_TARGET_SUPPORTED.contains(&database_type)
+        && supports_object_rename(Some(database_type), DatabaseObjectType::Table)
+}
+
+/// Storage key prefix for the persisted rebuild recovery plan.
+///
+/// The journal lives in the existing state store (no schema change), keyed by transfer id,
+/// so a crash mid-rename still leaves every backup findable on disk.
+const REBUILD_JOURNAL_KEY_PREFIX: &str = "transfer-rebuild:";
+
+/// One renamed table inside the persisted recovery plan.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct RebuildRecoveryStep {
+    /// Name of the table in the transfer selection.
+    pub source_table: String,
+    /// Actual target-side name that was renamed away.
+    pub target_table: String,
+    /// Backup name the target table now lives under.
+    pub backup_table: String,
+    /// Whether the table rename already executed.
+    #[serde(default)]
+    pub renamed: bool,
+    /// Index/sequence renames executed on the backup table, as `kind old -> new`.
+    #[serde(default)]
+    pub renamed_objects: Vec<String>,
+}
+
+/// Persisted recovery plan for one rebuild transfer.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct RebuildRecoveryJournal {
+    pub transfer_id: String,
+    pub target_connection_id: String,
+    pub target_database: String,
+    pub target_schema: String,
+    pub database_type: String,
+    pub steps: Vec<RebuildRecoveryStep>,
+}
+
+fn rebuild_journal_key(transfer_id: &str) -> String {
+    format!("{REBUILD_JOURNAL_KEY_PREFIX}{transfer_id}")
+}
+
+/// Persist the full recovery plan before the first rename executes.
+///
+/// `plan` carries `(source_table, target_table, backup_table)` for every table the
+/// pre-pass intends to rename. Writing it before any mutation guarantees the journal
+/// describes at least as much as has been renamed, never less.
+pub(crate) async fn persist_rebuild_plan(
+    state: &AppState,
+    request: &crate::transfer::TransferRequest,
+    database_type: DatabaseType,
+    plan: &[(String, String, String)],
+) -> Result<(), String> {
+    if plan.is_empty() {
+        return Ok(());
+    }
+    let journal = RebuildRecoveryJournal {
+        transfer_id: request.transfer_id.clone(),
+        target_connection_id: request.target_connection_id.clone(),
+        target_database: request.target_database.clone(),
+        target_schema: request.target_schema.clone(),
+        database_type: database_type.as_str().to_string(),
+        steps: plan
+            .iter()
+            .map(|(source_table, target_table, backup_table)| RebuildRecoveryStep {
+                source_table: source_table.clone(),
+                target_table: target_table.clone(),
+                backup_table: backup_table.clone(),
+                renamed: false,
+                renamed_objects: Vec::new(),
+            })
+            .collect(),
+    };
+    let bytes =
+        serde_json::to_vec(&journal).map_err(|e| format!("Failed to serialize the rebuild recovery plan: {e}"))?;
+    state
+        .storage
+        .save_state(&rebuild_journal_key(&request.transfer_id), &bytes, "application/json")
+        .await
+        .map_err(|e| format!("Failed to persist the rebuild recovery plan: {e}"))
+}
+
+/// Mark one table's renames as executed inside the persisted plan.
+///
+/// A missing journal is tolerated silently: the plan may not have been persisted for
+/// transfers that renamed nothing, and the journal is best-effort metadata — it must
+/// never fail the transfer it is trying to make recoverable.
+pub(crate) async fn record_rebuild_step(
+    state: &AppState,
+    transfer_id: &str,
+    source_table: &str,
+    renamed_objects: Vec<String>,
+) -> Result<(), String> {
+    let result = record_rebuild_step_inner(state, transfer_id, source_table, renamed_objects).await;
+    match result {
+        Ok(()) => Ok(()),
+        Err(error) => {
+            log::warn!("[transfer] failed to update the rebuild recovery journal: {error}");
+            Ok(())
+        }
+    }
+}
+
+async fn record_rebuild_step_inner(
+    state: &AppState,
+    transfer_id: &str,
+    source_table: &str,
+    renamed_objects: Vec<String>,
+) -> Result<(), String> {
+    let key = rebuild_journal_key(transfer_id);
+    let Some((bytes, _content_type)) = state.storage.load_state(&key).await.map_err(|e| e.to_string())? else {
+        return Ok(());
+    };
+    let mut journal: RebuildRecoveryJournal =
+        serde_json::from_slice(&bytes).map_err(|e| format!("Failed to parse the rebuild recovery journal: {e}"))?;
+    if let Some(step) = journal.steps.iter_mut().find(|step| step.source_table == source_table) {
+        step.renamed = true;
+        step.renamed_objects = renamed_objects;
+    }
+    let bytes = serde_json::to_vec(&journal).map_err(|e| e.to_string())?;
+    state.storage.save_state(&key, &bytes, "application/json").await
+}
+
+/// Delete the journal after the whole rebuild — including backup cleanup — succeeded.
+///
+/// Kept `pub`: the cleanup step lives in `transfer.rs` and both desktop and Web callers
+/// run it through the same path.
+pub(crate) async fn complete_rebuild_journal(state: &AppState, transfer_id: &str) -> Result<(), String> {
+    state.storage.delete_state(&rebuild_journal_key(transfer_id)).await
+}
+
+/// Gate `drop_target_before_create` before a transfer starts.
+///
+/// Both the Tauri command and the web route call this, so the desktop app and the HTTP API
+/// cannot drift apart on which targets are allowed or when confirmation is demanded.
+pub async fn ensure_drop_target_allowed(
+    state: &AppState,
+    target_connection_id: &str,
+    target_database: &str,
+    target_database_type: DatabaseType,
+    drop_target_before_create: bool,
+    drop_target_confirmed: bool,
+) -> Result<(), String> {
+    if !drop_target_before_create {
+        return Ok(());
+    }
+    if !supports_drop_target_before_create(target_database_type) {
+        return Err(format!(
+            "{DROP_TARGET_UNSUPPORTED_DATABASE}: dropping the target table before creating it is not supported for \
+             {}.",
+            target_database_type.as_str()
+        ));
+    }
+    let production = {
+        let configs = state.configs.read().await;
+        configs
+            .get(target_connection_id)
+            .map(|config| is_production_database(config, target_database))
+            // Fail closed: an unknown target connection is treated as production.
+            .unwrap_or(true)
+    };
+    if production && !drop_target_confirmed {
+        return Err(format!(
+            "{DROP_TARGET_CONFIRMATION_REQUIRED}: rebuilding tables in production database '{target_database}' \
+             requires explicit confirmation."
+        ));
+    }
+    Ok(())
+}
+
+/// One incoming foreign key held by a table outside the transfer collection.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ExternalIncomingForeignKey {
+    /// Schema (MySQL: database) that owns the referencing table.
+    pub referencing_schema: String,
+    /// Table holding the foreign key.
+    pub referencing_table: String,
+    /// Table inside the transfer collection that the foreign key points at.
+    pub referenced_table: String,
+    pub constraint_name: String,
+}
+
+/// Fail-fast gate: refuse the rebuild when a table outside the transfer collection
+/// points a foreign key at one of the tables about to be renamed.
+///
+/// MySQL `RENAME TABLE` and PostgreSQL `ALTER TABLE ... RENAME` both keep incoming
+/// foreign keys attached to the renamed table, so after the pre-pass the external
+/// table's foreign key would reference the backup instead of the rebuilt table —
+/// and dropping the backup at the end would then fail or, worse, silently leave the
+/// external table pointing at a table that is about to disappear. Neither outcome is
+/// recoverable from inside the transfer, so the transfer refuses to start.
+///
+/// Tables inside the collection are excluded: their foreign keys are re-created from
+/// the source structure by the main pass (`pending_fk_alters`).
+pub async fn ensure_no_external_incoming_foreign_keys(
+    state: &AppState,
+    target_pool_key: &str,
+    target_database: &str,
+    target_schema: &str,
+    target_tables: &[String],
+    target_database_type: DatabaseType,
+) -> Result<(), String> {
+    let blocking = detect_external_incoming_foreign_keys(
+        state,
+        target_pool_key,
+        target_database,
+        target_schema,
+        target_tables,
+        target_database_type,
+    )
+    .await?;
+    match describe_external_incoming_foreign_keys(&blocking) {
+        Some(message) => Err(message),
+        None => Ok(()),
+    }
+}
+
+/// Check incoming foreign keys and dependent views before the first rename.
+///
+/// This is the only dependency gate: it runs before any table is renamed aside, because a
+/// foreign key from outside the collection or a dependent view would follow the rename onto
+/// the backup. Cleanup later relies on `break_backup_foreign_key_graph` plus restrictive
+/// drops, not on a second pass of this check.
+pub async fn ensure_no_external_table_dependencies(
+    state: &AppState,
+    target_pool_key: &str,
+    target_database: &str,
+    target_schema: &str,
+    target_tables: &[String],
+    target_database_type: DatabaseType,
+) -> Result<(), String> {
+    if target_tables.is_empty() {
+        return Ok(());
+    }
+    ensure_no_external_incoming_foreign_keys(
+        state,
+        target_pool_key,
+        target_database,
+        target_schema,
+        target_tables,
+        target_database_type,
+    )
+    .await?;
+
+    let blocking = detect_dependent_views(
+        state,
+        target_pool_key,
+        target_database,
+        target_schema,
+        target_tables,
+        target_database_type,
+    )
+    .await?;
+    if blocking.is_empty() {
+        return Ok(());
+    }
+    Err(format!(
+        "{DROP_TARGET_EXTERNAL_DEPENDENCIES}: rebuilding the target tables would invalidate dependent objects or \
+         leave them attached to the backup tables. These objects must be handled explicitly before rebuilding: {}",
+        blocking.into_iter().collect::<Vec<_>>().join("; ")
+    ))
+}
+
+async fn detect_dependent_views(
+    state: &AppState,
+    pool_key: &str,
+    database: &str,
+    schema: &str,
+    target_tables: &[String],
+    database_type: DatabaseType,
+) -> Result<BTreeSet<String>, String> {
+    if matches!(database_type, DatabaseType::Sqlite | DatabaseType::CloudflareD1 | DatabaseType::DuckDb) {
+        return detect_parsed_view_dependencies(state, pool_key, database, schema, target_tables, database_type).await;
+    }
+    let sql = dependent_views_sql(database_type, database, schema, target_tables).ok_or_else(|| {
+        format!("Cannot safely inspect dependent views for {} before rebuilding target tables", database_type.as_str())
+    })?;
+    let result = read_dependency_metadata(state, pool_key, &sql, 4)
+        .await
+        .map_err(|error| format!("Failed to inspect dependent views before rebuilding target tables: {error}"))?;
+    result
+        .rows
+        .iter()
+        .map(|row| {
+            let owner = dependency_metadata_text(row, 0)?;
+            let name = dependency_metadata_text(row, 1)?;
+            let referenced = dependency_metadata_text(row, 2)?;
+            let kind = dependency_metadata_text(row, 3)?;
+            Ok(format!("{kind} {owner}.{name} -> {schema}.{referenced}"))
+        })
+        .collect()
+}
+
+/// Native dependency catalogs retain the referenced object identity across renames.
+/// Do not exclude a view because its name happens to occur in `target_tables`: the
+/// transfer's table selection does not authorize rewriting a target-only view.
+fn dependent_views_sql(
+    database_type: DatabaseType,
+    database: &str,
+    schema: &str,
+    target_tables: &[String],
+) -> Option<String> {
+    let names = target_tables.iter().map(|table| quote_sql_literal(table)).collect::<Vec<_>>().join(", ");
+    match database_type {
+        DatabaseType::Postgres
+        | DatabaseType::Kingbase
+        | DatabaseType::Gaussdb
+        | DatabaseType::OpenGauss
+        | DatabaseType::Kwdb => Some(format!(
+            "SELECT DISTINCT src_ns.nspname, src.relname, tgt.relname, \
+                    CASE WHEN src.relkind = 'm' THEN 'materialized view' ELSE 'view' END \
+             FROM pg_catalog.pg_depend dep \
+             JOIN pg_catalog.pg_rewrite rewrite ON rewrite.oid = dep.objid \
+             JOIN pg_catalog.pg_class src ON src.oid = rewrite.ev_class \
+             JOIN pg_catalog.pg_namespace src_ns ON src_ns.oid = src.relnamespace \
+             JOIN pg_catalog.pg_class tgt ON tgt.oid = dep.refobjid \
+             JOIN pg_catalog.pg_namespace tgt_ns ON tgt_ns.oid = tgt.relnamespace \
+             WHERE dep.classid = 'pg_catalog.pg_rewrite'::regclass \
+               AND dep.refclassid = 'pg_catalog.pg_class'::regclass \
+               AND src.relkind IN ('v', 'm') \
+               AND src.oid <> tgt.oid \
+               AND tgt_ns.nspname = {schema} \
+               AND tgt.relname IN ({names})",
+            schema = quote_sql_literal(schema),
+        )),
+        DatabaseType::Mysql | DatabaseType::Goldendb => Some(format!(
+            "SELECT DISTINCT VIEW_SCHEMA, VIEW_NAME, TABLE_NAME, 'view' \
+             FROM information_schema.VIEW_TABLE_USAGE \
+             WHERE {database_match} AND {table_match}",
+            database_match = mysql_metadata_name_matches("TABLE_SCHEMA", &[database]),
+            table_match = mysql_metadata_name_matches(
+                "TABLE_NAME",
+                &target_tables.iter().map(String::as_str).collect::<Vec<_>>()
+            ),
+        )),
+        DatabaseType::Oracle | DatabaseType::Dameng | DatabaseType::OceanbaseOracle => Some(format!(
+            "SELECT DISTINCT owner, name, referenced_name, type \
+             FROM all_dependencies \
+             WHERE type IN ('VIEW', 'MATERIALIZED VIEW') \
+               AND referenced_type = 'TABLE' \
+               AND referenced_owner = {schema} \
+               AND referenced_name IN ({names})",
+            schema = quote_sql_literal(schema),
+        )),
+        DatabaseType::SqlServer => Some(format!(
+            "SELECT DISTINCT SCHEMA_NAME(src.schema_id), src.name, tgt.name, 'view' \
+             FROM sys.sql_expression_dependencies dep \
+             JOIN sys.views src ON src.object_id = dep.referencing_id \
+             JOIN sys.tables tgt ON tgt.object_id = dep.referenced_id \
+             WHERE dep.referencing_class = 1 AND dep.referenced_class = 1 \
+               AND SCHEMA_NAME(tgt.schema_id) = {schema} AND tgt.name IN ({names})",
+            schema = quote_sql_literal(schema),
+        )),
+        _ => None,
+    }
+}
+
+async fn detect_parsed_view_dependencies(
+    state: &AppState,
+    pool_key: &str,
+    database: &str,
+    schema: &str,
+    target_tables: &[String],
+    database_type: DatabaseType,
+) -> Result<BTreeSet<String>, String> {
+    let (database, schema, sql) = if database_type == DatabaseType::DuckDb {
+        let database = resolve_duckdb_dependency_database(state, pool_key, database).await?;
+        let schema = if schema.is_empty() { "main" } else { schema }.to_string();
+        // DuckDB views may reference tables in another schema or attached catalog.
+        let sql =
+            "SELECT database_name, schema_name, view_name, sql FROM duckdb_views() WHERE NOT internal".to_string();
+        (database, schema, sql)
+    } else {
+        let schema = resolve_sqlite_dependency_schema(state, pool_key, database, schema, database_type).await?;
+        let mut sql = format!(
+            "SELECT '', {schema_value}, name, sql FROM {schema_ident}.sqlite_master WHERE type = 'view'",
+            schema_value = quote_sql_literal(&schema),
+            schema_ident = crate::db::sqlite::sqlite_quote_ident(&schema),
+        );
+        // Persistent SQLite views are confined to their own database. TEMP views can
+        // refer to any attached database, so they must be inspected as well.
+        if database_type == DatabaseType::Sqlite && !schema.eq_ignore_ascii_case("temp") {
+            sql.push_str(" UNION ALL SELECT '', 'temp', name, sql FROM temp.sqlite_master WHERE type = 'view'");
+        }
+        (String::new(), schema, sql)
+    };
+    let result = read_dependency_metadata(state, pool_key, &sql, 4).await?;
+    let mut blocking = BTreeSet::new();
+    for row in &result.rows {
+        let view_database = dependency_metadata_text(row, 0)?;
+        let view_schema = dependency_metadata_text(row, 1)?;
+        let view_name = dependency_metadata_text(row, 2)?;
+        let qualified = if view_database.is_empty() {
+            format!("{view_schema}.{view_name}")
+        } else {
+            format!("{view_database}.{view_schema}.{view_name}")
+        };
+        let ddl = dependency_metadata_text(row, 3)
+            .map_err(|error| format!("Cannot safely inspect dependent view {qualified}: {error}"))?;
+        let references =
+            parsed_view_target_references(ddl, database_type, &database, &schema, view_schema, target_tables)
+                .map_err(|error| format!("Cannot safely inspect dependent view {qualified}: {error}"))?;
+        for referenced in references {
+            blocking.insert(format!("view {qualified} -> {schema}.{referenced}"));
+        }
+    }
+    Ok(blocking)
+}
+
+fn parsed_view_target_references(
+    ddl: &str,
+    database_type: DatabaseType,
+    database: &str,
+    schema: &str,
+    view_schema: &str,
+    target_tables: &[String],
+) -> Result<BTreeSet<String>, String> {
+    let dialect: &dyn sqlparser::dialect::Dialect =
+        if database_type == DatabaseType::DuckDb { &DuckDbDialect {} } else { &SQLiteDialect {} };
+    let statements = Parser::parse_sql(dialect, ddl).map_err(|error| error.to_string())?;
+    let [Statement::CreateView(view)] = statements.as_slice() else {
+        return Err("the catalog did not return a complete CREATE VIEW definition".to_string());
+    };
+    if let ControlFlow::Break(error) = view.query.visit(&mut StaticViewRelations) {
+        return Err(error.to_string());
+    }
+    let mut references = BTreeSet::new();
+    let visited = visit_relations(&view.query, |relation| {
+        let names = relation
+            .0
+            .iter()
+            .map(|part| match part {
+                ObjectNamePart::Identifier(identifier) => Ok(identifier.value.as_str()),
+                _ => Err("a view relation uses an unsupported dynamic identifier".to_string()),
+            })
+            .collect::<Result<Vec<_>, _>>();
+        let names = match names {
+            Ok(names) => names,
+            Err(error) => return ControlFlow::Break(error),
+        };
+        let (qualifiers, table) = match names.split_last() {
+            Some((table, qualifiers)) => (qualifiers, *table),
+            None => return ControlFlow::Break("a view relation has no object name".to_string()),
+        };
+        let same_namespace = if database_type == DatabaseType::DuckDb {
+            match qualifiers {
+                // DuckDB retains unqualified references in its stored view SQL. A
+                // view's own schema does not prove which search_path resolved them.
+                [] => true,
+                [namespace] => namespace.eq_ignore_ascii_case(schema) || namespace.eq_ignore_ascii_case(database),
+                [catalog, namespace] => {
+                    catalog.eq_ignore_ascii_case(database) && namespace.eq_ignore_ascii_case(schema)
+                }
+                _ => return ControlFlow::Break("a DuckDB view relation has an unsupported qualified name".to_string()),
+            }
+        } else {
+            match qualifiers {
+                [] => view_schema.eq_ignore_ascii_case(schema) || view_schema.eq_ignore_ascii_case("temp"),
+                [namespace] => namespace.eq_ignore_ascii_case(schema),
+                _ => return ControlFlow::Break("a SQLite view relation has an unsupported qualified name".to_string()),
+            }
+        };
+        if same_namespace {
+            if let Some(target) = target_tables.iter().find(|target| target.eq_ignore_ascii_case(table)) {
+                references.insert(target.clone());
+            }
+        }
+        ControlFlow::Continue(())
+    });
+    match visited {
+        ControlFlow::Break(error) => Err(error),
+        ControlFlow::Continue(()) => Ok(references),
+    }
+}
+
+/// Table functions/macros can hide relation names in strings (`query_table`) or
+/// their own definitions. The view AST alone cannot prove those references safe.
+struct StaticViewRelations;
+
+impl Visitor for StaticViewRelations {
+    type Break = &'static str;
+
+    fn pre_visit_table_factor(&mut self, table: &TableFactor) -> ControlFlow<Self::Break> {
+        match table {
+            TableFactor::Table { args: None, .. } | TableFactor::Derived { .. } | TableFactor::NestedJoin { .. } => {
+                ControlFlow::Continue(())
+            }
+            _ => ControlFlow::Break(
+                "the view contains a table function or table expression whose dependencies cannot be inspected safely",
+            ),
+        }
+    }
+}
+
+async fn resolve_duckdb_dependency_database(
+    state: &AppState,
+    pool_key: &str,
+    database: &str,
+) -> Result<String, String> {
+    let database = if database.is_empty() || database.eq_ignore_ascii_case("main") {
+        let result = read_dependency_metadata(state, pool_key, "SELECT current_database()", 1).await?;
+        let row = result.rows.first().ok_or("Cannot inspect DuckDB dependencies: current database is unknown")?;
+        dependency_metadata_text(row, 0)?.to_string()
+    } else {
+        database.to_string()
+    };
+    let result =
+        read_dependency_metadata(state, pool_key, "SELECT database_name, type FROM duckdb_databases()", 2).await?;
+    let mut resolved = None;
+    for row in &result.rows {
+        let name = dependency_metadata_text(row, 0)?;
+        let kind = dependency_metadata_text(row, 1)?;
+        if !kind.eq_ignore_ascii_case("duckdb") {
+            return Err(format!(
+                "Cannot safely inspect dependencies in DuckDB catalog '{name}' (engine '{kind}') before rebuilding tables"
+            ));
+        }
+        if name.eq_ignore_ascii_case(&database) {
+            resolved = Some(name.to_string());
+        }
+    }
+    resolved.ok_or_else(|| format!("Cannot inspect DuckDB dependencies: catalog '{database}' is not attached"))
+}
+
+/// Render the fail-fast error for a non-empty set of blocking foreign keys.
+///
+/// `None` when nothing blocks. Grouped by referencing table so a table holding several
+/// constraints reads as one entry, and ordered so the message is stable across runs
+/// (`BTreeMap` + sorted constraints) — the frontend shows this string verbatim.
+fn describe_external_incoming_foreign_keys(blocking: &[ExternalIncomingForeignKey]) -> Option<String> {
+    if blocking.is_empty() {
+        return None;
+    }
+    let mut grouped = std::collections::BTreeMap::<String, Vec<String>>::new();
+    for fk in blocking {
+        grouped
+            .entry(format!("{}.{}", fk.referencing_schema, fk.referencing_table))
+            .or_default()
+            .push(format!("{} -> {}", fk.constraint_name, fk.referenced_table));
+    }
+    let described = grouped
+        .into_iter()
+        .map(|(table, mut constraints)| {
+            constraints.sort();
+            constraints.dedup();
+            format!("{table} ({})", constraints.join(", "))
+        })
+        .collect::<Vec<_>>();
+
+    Some(format!(
+        "{DROP_TARGET_EXTERNAL_FOREIGN_KEYS}: {} table(s) outside this transfer reference the target tables, and \
+         renaming a referenced table would move those foreign keys onto the backup table. Add the listed tables to \
+         the transfer, or drop their foreign keys first: {}",
+        described.len(),
+        described.join("; ")
+    ))
+}
+
+/// List incoming foreign keys held by tables outside `target_tables`.
+///
+/// SQLite also rewrites incoming foreign keys when a table is renamed, even if
+/// enforcement is currently disabled. Never infer safety from `foreign_keys=OFF`.
+pub async fn detect_external_incoming_foreign_keys(
+    state: &AppState,
+    target_pool_key: &str,
+    target_database: &str,
+    target_schema: &str,
+    target_tables: &[String],
+    target_database_type: DatabaseType,
+) -> Result<Vec<ExternalIncomingForeignKey>, String> {
+    if target_tables.is_empty() {
+        return Ok(Vec::new());
+    }
+    let resolved_database;
+    let target_database = if target_database_type == DatabaseType::DuckDb {
+        resolved_database = resolve_duckdb_dependency_database(state, target_pool_key, target_database).await?;
+        resolved_database.as_str()
+    } else {
+        target_database
+    };
+    let resolved_schema;
+    let target_schema = if matches!(target_database_type, DatabaseType::Sqlite | DatabaseType::CloudflareD1) {
+        resolved_schema = resolve_sqlite_dependency_schema(
+            state,
+            target_pool_key,
+            target_database,
+            target_schema,
+            target_database_type,
+        )
+        .await?;
+        resolved_schema.as_str()
+    } else if target_database_type == DatabaseType::DuckDb && target_schema.is_empty() {
+        "main"
+    } else {
+        target_schema
+    };
+    let sql = external_incoming_foreign_keys_sql(target_database_type, target_database, target_schema, target_tables)
+        .ok_or_else(|| {
+        format!(
+            "Cannot safely inspect incoming foreign keys for {} before rebuilding target tables: {}",
+            target_database_type.as_str(),
+            target_tables.join(", ")
+        )
+    })?;
+
+    let result = read_dependency_metadata(state, target_pool_key, &sql, 4)
+        .await
+        .map_err(|e| format!("Failed to check incoming foreign keys on the target database: {e}"))?;
+
+    let mut rows = result
+        .rows
+        .iter()
+        .map(|row| {
+            Ok(ExternalIncomingForeignKey {
+                referencing_schema: dependency_metadata_text(row, 0)?.to_string(),
+                referencing_table: dependency_metadata_text(row, 1)?.to_string(),
+                referenced_table: dependency_metadata_text(row, 2)?.to_string(),
+                constraint_name: dependency_metadata_text(row, 3)?.to_string(),
+            })
+        })
+        .collect::<Result<Vec<_>, String>>()?;
+    rows.sort();
+    rows.dedup();
+    Ok(rows)
+}
+
+async fn read_dependency_metadata(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    expected_columns: usize,
+) -> Result<crate::db::QueryResult, String> {
+    let result = crate::transfer::execute_read_on_pool(state, pool_key, sql).await?;
+    validate_dependency_metadata(&result, expected_columns)?;
+    Ok(result)
+}
+
+fn validate_dependency_metadata(result: &crate::db::QueryResult, expected_columns: usize) -> Result<(), String> {
+    if result.truncated || result.has_more {
+        return Err("Target dependency metadata was truncated; a complete dependency check is required before rebuilding tables".to_string());
+    }
+    if result.columns.len() != expected_columns {
+        return Err(format!(
+            "Cannot safely inspect target dependencies: expected {expected_columns} metadata columns, received {}",
+            result.columns.len()
+        ));
+    }
+    if result.rows.iter().any(|row| row.len() != expected_columns) {
+        return Err("Cannot safely inspect target dependencies: metadata contains an incomplete row".to_string());
+    }
+    Ok(())
+}
+
+fn dependency_metadata_text(row: &[serde_json::Value], index: usize) -> Result<&str, String> {
+    row.get(index).and_then(serde_json::Value::as_str).ok_or_else(|| {
+        format!("Cannot safely inspect target dependencies: metadata column {} is missing or is not text", index + 1)
+    })
+}
+
+async fn resolve_sqlite_dependency_schema(
+    state: &AppState,
+    pool_key: &str,
+    database: &str,
+    schema: &str,
+    database_type: DatabaseType,
+) -> Result<String, String> {
+    let requested = if !schema.trim().is_empty() {
+        schema
+    } else if database_type == DatabaseType::CloudflareD1 || database.trim().is_empty() {
+        "main"
+    } else {
+        database
+    };
+    let result = read_dependency_metadata(state, pool_key, "PRAGMA database_list", 3).await?;
+    let names = result.rows.iter().map(|row| dependency_metadata_text(row, 1)).collect::<Result<Vec<_>, _>>()?;
+    // A real attached alias wins over the legacy file-path -> main normalization.
+    if let Some(name) = names.iter().find(|name| name.eq_ignore_ascii_case(requested)) {
+        return Ok((*name).to_string());
+    }
+    let normalized = crate::db::sqlite::sqlite_quote_schema_ident(requested);
+    if let Some(name) =
+        names.iter().find(|name| crate::db::sqlite::sqlite_quote_ident(name).eq_ignore_ascii_case(&normalized))
+    {
+        return Ok((*name).to_string());
+    }
+    Err(format!("Cannot safely inspect target dependencies: SQLite schema '{requested}' is not attached"))
+}
+
+/// Build the metadata query returning `(referencing_schema, referencing_table,
+/// referenced_table, constraint_name)` for every foreign key that points at
+/// `target_tables` from outside that set.
+///
+/// `None` for dialects without a reliable metadata query. Split out from the async caller so the
+/// generated SQL — including the same-schema exclusion that keeps the transfer's own
+/// tables out of the result — is unit-testable without a live database.
+fn external_incoming_foreign_keys_sql(
+    database_type: DatabaseType,
+    database: &str,
+    schema: &str,
+    target_tables: &[String],
+) -> Option<String> {
+    let name_list = target_tables.iter().map(|table| quote_sql_literal(table)).collect::<Vec<_>>().join(", ");
+    match database_type {
+        // MySQL family: schemas are databases, so the referenced side is keyed by
+        // REFERENCED_TABLE_SCHEMA. Reading KEY_COLUMN_USAGE alone avoids the
+        // catalog-wide scan a join with TABLE_CONSTRAINTS triggers on MySQL 5.7
+        // (same reason as db::mysql::list_foreign_keys).
+        DatabaseType::Mysql | DatabaseType::Goldendb => Some(format!(
+            "SELECT DISTINCT TABLE_SCHEMA, TABLE_NAME, REFERENCED_TABLE_NAME, CONSTRAINT_NAME \
+             FROM information_schema.KEY_COLUMN_USAGE \
+             WHERE {target_database_match} AND {target_table_match} \
+               AND NOT ({source_database_match} AND {source_table_match})",
+            target_database_match = mysql_metadata_name_matches("REFERENCED_TABLE_SCHEMA", &[database]),
+            target_table_match = mysql_metadata_name_matches(
+                "REFERENCED_TABLE_NAME",
+                &target_tables.iter().map(String::as_str).collect::<Vec<_>>()
+            ),
+            source_database_match = mysql_metadata_name_matches("TABLE_SCHEMA", &[database]),
+            source_table_match = mysql_metadata_name_matches(
+                "TABLE_NAME",
+                &target_tables.iter().map(String::as_str).collect::<Vec<_>>()
+            ),
+        )),
+        // PostgreSQL family: pg_constraint is indexed on confrelid, so this stays
+        // cheap even on large catalogs. The referencing side is deliberately not
+        // restricted to `schema` — a foreign key from another schema follows the
+        // rename just the same — so the exclusion is namespace-qualified rather
+        // than by bare name.
+        DatabaseType::Postgres
+        | DatabaseType::Kingbase
+        | DatabaseType::Gaussdb
+        | DatabaseType::OpenGauss
+        | DatabaseType::Kwdb => Some(format!(
+            "SELECT DISTINCT src_ns.nspname, src.relname, tgt.relname, con.conname \
+             FROM pg_constraint con \
+             JOIN pg_class src ON src.oid = con.conrelid \
+             JOIN pg_namespace src_ns ON src_ns.oid = src.relnamespace \
+             JOIN pg_class tgt ON tgt.oid = con.confrelid \
+             JOIN pg_namespace tgt_ns ON tgt_ns.oid = tgt.relnamespace \
+             WHERE con.contype = 'f' \
+               AND tgt_ns.nspname = {schema} \
+               AND tgt.relname IN ({name_list}) \
+               AND NOT (src_ns.nspname = {schema} AND src.relname IN ({name_list}))",
+            schema = quote_sql_literal(schema),
+        )),
+        // Oracle family: constraint metadata is owner-qualified and a rename keeps
+        // incoming constraints attached, same as the two families above.
+        DatabaseType::Oracle | DatabaseType::Dameng | DatabaseType::OceanbaseOracle => Some(format!(
+            "SELECT DISTINCT c.owner, c.table_name, r.table_name, c.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 = {schema} \
+               AND r.table_name IN ({name_list}) \
+               AND NOT (c.owner = {schema} AND c.table_name IN ({name_list}))",
+            schema = quote_sql_literal(schema),
+        )),
+        DatabaseType::SqlServer => Some(format!(
+            "SELECT DISTINCT SCHEMA_NAME(src.schema_id), src.name, tgt.name, fk.name \
+             FROM sys.foreign_keys fk \
+             JOIN sys.tables src ON src.object_id = fk.parent_object_id \
+             JOIN sys.tables tgt ON tgt.object_id = fk.referenced_object_id \
+             WHERE SCHEMA_NAME(tgt.schema_id) = {schema} \
+               AND tgt.name IN ({name_list}) \
+               AND NOT (SCHEMA_NAME(src.schema_id) = {schema} AND src.name IN ({name_list}))",
+            schema = quote_sql_literal(schema),
+        )),
+        DatabaseType::Sqlite | DatabaseType::CloudflareD1 => Some(format!(
+            "SELECT DISTINCT {schema_value}, src.name, fk.\"table\", 'fk_' || CAST(fk.id AS TEXT) \
+             FROM {schema_ident}.sqlite_master src \
+             JOIN pragma_foreign_key_list(src.name, {schema_value}) fk \
+             WHERE src.type = 'table' \
+               AND fk.\"table\" COLLATE NOCASE IN ({name_list}) \
+               AND src.name COLLATE NOCASE NOT IN ({name_list})",
+            schema_value = quote_sql_literal(schema),
+            schema_ident = crate::db::sqlite::sqlite_quote_ident(schema),
+        )),
+        DatabaseType::DuckDb => {
+            let folded_names = target_tables
+                .iter()
+                .map(|name| format!("lower({})", quote_sql_literal(name)))
+                .collect::<Vec<_>>()
+                .join(", ");
+            Some(format!(
+                "SELECT DISTINCT src.table_catalog || '.' || src.table_schema, src.table_name, tgt.table_name, fk.constraint_name \
+                 FROM information_schema.referential_constraints fk \
+                 JOIN information_schema.key_column_usage src \
+                   ON src.constraint_catalog = fk.constraint_catalog \
+                  AND src.constraint_schema = fk.constraint_schema \
+                  AND src.constraint_name = fk.constraint_name \
+                 JOIN information_schema.key_column_usage tgt \
+                   ON tgt.constraint_catalog = fk.unique_constraint_catalog \
+                  AND tgt.constraint_schema = fk.unique_constraint_schema \
+                  AND tgt.constraint_name = fk.unique_constraint_name \
+                 WHERE lower(tgt.table_catalog) = lower({database}) \
+                   AND lower(tgt.table_schema) = lower({schema}) \
+                   AND lower(tgt.table_name) IN ({folded_names}) \
+                   AND NOT (lower(src.table_catalog) = lower({database}) \
+                        AND lower(src.table_schema) = lower({schema}) \
+                        AND lower(src.table_name) IN ({folded_names}))",
+                database = quote_sql_literal(database),
+                schema = quote_sql_literal(schema),
+            ))
+        }
+        _ => None,
+    }
+}
+
+/// information_schema name columns have their own collation, which can equate
+/// `orders` and `Orders` even when lower_case_table_names=0 makes them different
+/// tables. Apply the server's table-name rules to both the selected and external
+/// sides, keeping byte-sensitive comparison after folding where it is required.
+fn mysql_metadata_name_matches(column: &str, names: &[&str]) -> String {
+    let literals = names.iter().map(|name| quote_mysql_metadata_literal(name)).collect::<Vec<_>>();
+    let exact = literals.join(", ");
+    let folded = literals.iter().map(|literal| format!("LOWER({literal})")).collect::<Vec<_>>().join(", ");
+    format!(
+        "((@@lower_case_table_names = 0 AND BINARY {column} IN ({exact})) \
+          OR (@@lower_case_table_names <> 0 AND BINARY LOWER({column}) IN ({folded})))"
+    )
+}
+
+fn quote_mysql_metadata_literal(value: &str) -> String {
+    if !value.contains('\\') {
+        return quote_sql_literal(value);
+    }
+    // A hex literal has the same value with and without NO_BACKSLASH_ESCAPES.
+    let hex = value.as_bytes().iter().map(|byte| format!("{byte:02x}")).collect::<String>();
+    format!("CONVERT(X'{hex}' USING utf8mb4)")
+}
+
+/// Quote a value as a SQL string literal. Local to this module so the metadata
+/// queries above never interpolate a raw identifier.
+fn quote_sql_literal(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    async fn sqlite_dependency_fixture() -> (AppState, crate::db::sqlite::SqliteHandle, tempfile::TempDir) {
+        let directory = tempfile::tempdir().unwrap();
+        let storage = crate::storage::Storage::open(&directory.path().join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let pool =
+            crate::db::sqlite::connect_path_create_if_missing(directory.path().join("target.db").to_str().unwrap())
+                .await
+                .unwrap();
+        state
+            .update_connection_pools(|connections| {
+                connections.insert("target".to_string(), crate::connection::PoolKind::Sqlite(pool.clone()));
+            })
+            .await;
+        (state, pool, directory)
+    }
+
+    #[tokio::test]
+    async fn sqlite_external_child_blocks_rebuild_without_changing_tables_or_rows() {
+        let (state, pool, _directory) = sqlite_dependency_fixture().await;
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "PRAGMA foreign_keys = ON;
+                     CREATE TABLE parent (id INTEGER PRIMARY KEY);
+                     CREATE TABLE external_child (
+                         id INTEGER PRIMARY KEY,
+                         parent_id INTEGER REFERENCES parent(id) ON DELETE CASCADE
+                     );
+                     INSERT INTO parent VALUES (7);
+                     INSERT INTO external_child VALUES (11, 7);",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+
+        let result = ensure_no_external_incoming_foreign_keys(
+            &state,
+            "target",
+            "main",
+            "main",
+            &["PARENT".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await;
+
+        let rows = crate::db::sqlite::execute_query(
+            &pool,
+            "SELECT child.id, parent.id FROM external_child child JOIN parent ON parent.id = child.parent_id",
+        )
+        .await
+        .unwrap();
+        assert_eq!(rows.rows, vec![vec![serde_json::json!(11), serde_json::json!(7)]]);
+        let tables = crate::db::sqlite::execute_query(
+            &pool,
+            "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name",
+        )
+        .await
+        .unwrap();
+        assert_eq!(tables.rows, vec![vec![serde_json::json!("external_child")], vec![serde_json::json!("parent")]]);
+        let error = result.expect_err("a rename would redirect the external child's cascading FK to the backup");
+        assert!(error.starts_with(DROP_TARGET_EXTERNAL_FOREIGN_KEYS), "{error}");
+        assert!(error.contains("main.external_child"), "{error}");
+    }
+
+    #[tokio::test]
+    async fn sqlite_dependent_view_blocks_rebuild_without_changing_view_or_rows() {
+        let (state, pool, _directory) = sqlite_dependency_fixture().await;
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "CREATE TABLE \"pa'rent\" (id INTEGER PRIMARY KEY);
+                     INSERT INTO \"pa'rent\" VALUES (7);
+                     CREATE VIEW external_view AS
+                         SELECT id FROM (SELECT id FROM \"pa'rent\") nested_parent;",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let result = ensure_no_external_table_dependencies(
+            &state,
+            "target",
+            "main",
+            "main",
+            &["PA'RENT".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await;
+
+        let rows = crate::db::sqlite::execute_query(&pool, "SELECT id FROM external_view").await.unwrap();
+        assert_eq!(rows.rows, vec![vec![serde_json::json!(7)]]);
+        let error = result.expect_err("SQLite rewrites the external view to reference the renamed backup");
+        assert!(error.contains("main.external_view"), "{error}");
+    }
+
+    #[tokio::test]
+    async fn sqlite_selected_children_and_unrelated_views_do_not_block_rebuild() {
+        let (state, pool, _directory) = sqlite_dependency_fixture().await;
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "CREATE TABLE parent (id INTEGER PRIMARY KEY);
+                     CREATE TABLE selected_child (parent_id INTEGER REFERENCES parent(id));
+                     CREATE TABLE unrelated (id INTEGER);
+                     CREATE VIEW unrelated_view AS SELECT 'parent' AS label, id FROM unrelated;",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        ensure_no_external_table_dependencies(
+            &state,
+            "target",
+            "main",
+            "MAIN",
+            &["PARENT".to_string(), "SELECTED_CHILD".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await
+        .unwrap();
+    }
+
+    #[tokio::test]
+    async fn sqlite_dependency_checks_preserve_quoted_attached_schema_identity() {
+        let (state, pool, _directory) = sqlite_dependency_fixture().await;
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "ATTACH DATABASE ':memory:' AS \"tenant'.db\";
+                     CREATE TABLE main.parent (id INTEGER PRIMARY KEY);
+                     CREATE TABLE main.child (parent_id INTEGER REFERENCES parent(id));
+                     CREATE TABLE \"tenant'.db\".parent (id INTEGER PRIMARY KEY);
+                     CREATE TABLE \"tenant'.db\".child (parent_id INTEGER REFERENCES parent(id));",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let error = ensure_no_external_table_dependencies(
+            &state,
+            "target",
+            "tenant'.db",
+            "tenant'.db",
+            &["parent".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await
+        .unwrap_err();
+        assert!(error.contains("tenant'.db.child"), "{error}");
+        assert!(!error.contains("main.child"), "{error}");
+    }
+
+    #[tokio::test]
+    async fn sqlite_temp_views_are_checked_against_the_referenced_attached_schema() {
+        let (state, pool, _directory) = sqlite_dependency_fixture().await;
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "ATTACH DATABASE ':memory:' AS reporting;
+                     CREATE TABLE main.parent (id INTEGER PRIMARY KEY);
+                     CREATE TABLE reporting.parent (id INTEGER PRIMARY KEY);
+                     CREATE TEMP VIEW outside_view AS SELECT id FROM reporting.parent;",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        ensure_no_external_table_dependencies(
+            &state,
+            "target",
+            "main",
+            "main",
+            &["parent".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await
+        .unwrap();
+        let error = ensure_no_external_table_dependencies(
+            &state,
+            "target",
+            "reporting",
+            "reporting",
+            &["parent".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await
+        .unwrap_err();
+        assert!(error.contains("temp.outside_view"), "{error}");
+    }
+
+    #[tokio::test]
+    async fn sqlite_unreadable_view_definition_blocks_rebuild_with_object_name() {
+        let (state, pool, _directory) = sqlite_dependency_fixture().await;
+        pool.with_connection(|connection| {
+            connection
+                .execute_batch(
+                    "CREATE TABLE parent (id INTEGER);
+                     CREATE VIEW unreadable_view AS SELECT id FROM parent;
+                     PRAGMA writable_schema = ON;
+                     UPDATE sqlite_master SET sql = NULL WHERE name = 'unreadable_view';
+                     PRAGMA writable_schema = OFF;",
+                )
+                .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let error = ensure_no_external_table_dependencies(
+            &state,
+            "target",
+            "main",
+            "main",
+            &["parent".to_string()],
+            DatabaseType::Sqlite,
+        )
+        .await
+        .unwrap_err();
+        assert!(error.contains("main.unreadable_view"), "{error}");
+    }
+
+    #[test]
+    fn duckdb_foreign_keys_are_checked_with_catalog_and_schema_identity() {
+        let sql =
+            external_incoming_foreign_keys_sql(DatabaseType::DuckDb, "analytics", "reporting", &["parent".to_string()])
+                .expect("DuckDB foreign keys must be checked before a rename");
+        assert!(sql.contains("information_schema.referential_constraints"), "{sql}");
+        assert!(sql.contains("tgt.table_catalog"), "{sql}");
+        assert!(sql.contains("'analytics'"), "{sql}");
+        assert!(sql.contains("tgt.table_schema"), "{sql}");
+        assert!(sql.contains("'reporting'"), "{sql}");
+    }
+
+    #[test]
+    fn duckdb_dynamic_view_table_references_cannot_bypass_dependency_check() {
+        let result = parsed_view_target_references(
+            "CREATE VIEW external_view AS SELECT * FROM query_table('parent')",
+            DatabaseType::DuckDb,
+            "analytics",
+            "main",
+            "main",
+            &["parent".to_string()],
+        );
+        assert!(result.is_err(), "table functions can hide dependencies inside strings or macros: {result:?}");
+    }
+
+    #[test]
+    fn postgres_view_dependency_query_tracks_rewrite_and_relation_catalog_identity() {
+        let sql = dependent_views_sql(DatabaseType::Postgres, "shop", "tenant'one", &["orders".to_string()]).unwrap();
+        assert!(sql.contains("JOIN pg_catalog.pg_rewrite rewrite ON rewrite.oid = dep.objid"), "{sql}");
+        assert!(sql.contains("dep.classid = 'pg_catalog.pg_rewrite'::regclass"), "{sql}");
+        assert!(sql.contains("dep.refclassid = 'pg_catalog.pg_class'::regclass"), "{sql}");
+        assert!(sql.contains("src.relkind IN ('v', 'm')"), "{sql}");
+        assert!(sql.contains("tgt_ns.nspname = 'tenant''one'"), "{sql}");
+        assert!(!sql.contains("src_ns.nspname ="), "cross-schema dependent views must be included: {sql}");
+    }
+
+    #[tokio::test]
+    async fn incomplete_metadata_cannot_be_reported_as_no_dependencies() {
+        let (_state, pool, _directory) = sqlite_dependency_fixture().await;
+        let mut result =
+            crate::db::sqlite::execute_query(&pool, "SELECT 'schema', 'table', 'referenced', 'constraint' WHERE 0")
+                .await
+                .unwrap();
+        validate_dependency_metadata(&result, 4).unwrap();
+
+        result.truncated = true;
+        assert!(validate_dependency_metadata(&result, 4).is_err());
+        result.truncated = false;
+        result.has_more = true;
+        assert!(validate_dependency_metadata(&result, 4).is_err());
+        result.has_more = false;
+        result.rows.push(Vec::new());
+        assert!(validate_dependency_metadata(&result, 4).is_err());
+        result.rows.clear();
+        result.columns.pop();
+        assert!(validate_dependency_metadata(&result, 4).is_err());
+    }
+
+    #[test]
+    fn mysql_metadata_queries_preserve_quotes_and_backslashes_without_sql_mode_assumptions() {
+        let sql =
+            external_incoming_foreign_keys_sql(DatabaseType::Mysql, "shop", "shop", &["x\\' OR 1=1 --".to_string()])
+                .unwrap();
+        assert!(sql.contains("CONVERT(X'785c27204f5220313d31202d2d' USING utf8mb4)"), "{sql}");
+        let statements = Parser::parse_sql(&sqlparser::dialect::MySqlDialect {}, &sql).unwrap();
+        assert_eq!(statements.len(), 1);
+        assert!(matches!(statements.first(), Some(Statement::Query(_))));
+    }
+
+    const LONG_TABLE: &str = "customer_order_line_item_revision_history";
+
+    fn name(db: DatabaseType, table: &str) -> String {
+        backup_table_name(db, "transfer-1", &format!("shop.{table}"), table).unwrap()
+    }
+
+    #[test]
+    fn backup_name_fits_identifier_budget_per_dialect() {
+        for db in [DatabaseType::Oracle, DatabaseType::Postgres, DatabaseType::Mysql, DatabaseType::SqlServer] {
+            let generated = name(db, LONG_TABLE);
+            assert!(
+                generated.len() <= max_identifier_bytes(db),
+                "{db:?} produced {} bytes for budget {}: {generated}",
+                generated.len(),
+                max_identifier_bytes(db)
+            );
+            assert!(generated.contains(BACKUP_TABLE_MARKER), "{db:?} lost the backup marker: {generated}");
+        }
+    }
+
+    #[test]
+    fn backup_name_uses_the_full_budget_boundaries() {
+        // Oracle 30 / PostgreSQL 63 / MySQL 64 / SQL Server 128 are the four descriptor
+        // values the transfer path can hit; pin them so a descriptor edit is visible here.
+        assert_eq!(max_identifier_bytes(DatabaseType::Oracle), 30);
+        assert_eq!(max_identifier_bytes(DatabaseType::Postgres), 63);
+        assert_eq!(max_identifier_bytes(DatabaseType::Mysql), 64);
+        assert_eq!(max_identifier_bytes(DatabaseType::SqlServer), 128);
+
+        // 30 - len("__dbx_bak_") - 8 = 12 stem bytes on Oracle.
+        let oracle = name(DatabaseType::Oracle, LONG_TABLE);
+        assert_eq!(oracle.len(), 30);
+        assert!(oracle.starts_with("customer_ord"), "unexpected Oracle stem: {oracle}");
+
+        // Short names are left intact.
+        let short = name(DatabaseType::Postgres, "orders");
+        assert!(short.starts_with("orders__dbx_bak_"), "unexpected short name: {short}");
+    }
+
+    #[test]
+    fn distinct_sources_do_not_collide_after_truncation() {
+        let first = backup_table_name(
+            DatabaseType::Oracle,
+            "transfer-1",
+            "shop.customer_order_line_item_a",
+            "customer_order_line_item_a",
+        )
+        .unwrap();
+        let second = backup_table_name(
+            DatabaseType::Oracle,
+            "transfer-1",
+            "shop.customer_order_line_item_b",
+            "customer_order_line_item_b",
+        )
+        .unwrap();
+        assert_ne!(first, second, "truncated stems must stay distinct via the hash");
+        assert_eq!(first.len(), 30);
+        assert_eq!(second.len(), 30);
+    }
+
+    #[test]
+    fn same_source_and_transfer_is_idempotent() {
+        let first = name(DatabaseType::Mysql, "orders");
+        let second = name(DatabaseType::Mysql, "orders");
+        assert_eq!(first, second);
+
+        let other_transfer = backup_table_name(DatabaseType::Mysql, "transfer-2", "shop.orders", "orders").unwrap();
+        assert_ne!(first, other_transfer, "a different transfer must not reuse the same backup name");
+    }
+
+    #[test]
+    fn multibyte_names_truncate_on_char_boundaries() {
+        let generated = name(DatabaseType::Oracle, "客户订单明细修订历史记录表");
+        assert_eq!(generated.len(), 30, "12 stem bytes = 4 CJK characters: {generated}");
+        assert!(generated.starts_with("客户订单"), "unexpected CJK stem: {generated}");
+    }
+
+    #[test]
+    fn failure_messages_point_at_the_retained_backup() {
+        let annotated = annotate_error_with_retained_backup(
+            "Failed to insert batch: duplicate key.".to_string(),
+            "`shop`.`orders__dbx_bak_1a2b3c4d`",
+        );
+        assert!(annotated.starts_with("Failed to insert batch: duplicate key."), "original error must lead");
+        assert!(annotated.contains("`shop`.`orders__dbx_bak_1a2b3c4d`"), "backup name is missing: {annotated}");
+    }
+
+    #[test]
+    fn a_message_that_already_names_the_backup_is_left_alone() {
+        // The drop-backup failure path builds its own message; annotating it again would
+        // print the same table twice.
+        let original = "Transfer completed successfully, but failed to drop backup table \
+                        'orders__dbx_bak_1a2b3c4d': permission denied."
+            .to_string();
+        assert_eq!(annotate_error_with_retained_backup(original.clone(), "orders__dbx_bak_1a2b3c4d"), original);
+    }
+
+    #[test]
+    fn supported_targets_all_have_table_rename() {
+        for db in DROP_TARGET_SUPPORTED {
+            assert!(
+                supports_drop_target_before_create(*db),
+                "{db:?} is on the allow-list but cannot rename a table, so the backup step would fail"
+            );
+        }
+    }
+
+    #[test]
+    fn high_risk_and_non_tabular_targets_stay_excluded() {
+        for db in [
+            DatabaseType::MongoDb,
+            DatabaseType::ClickHouse,
+            DatabaseType::Questdb,
+            DatabaseType::Hive,
+            DatabaseType::Spark,
+            DatabaseType::Kyuubi,
+            DatabaseType::Impala,
+            DatabaseType::Argo,
+            DatabaseType::Turso,
+            DatabaseType::Rqlite,
+        ] {
+            assert!(!supports_drop_target_before_create(db), "{db:?} must stay excluded");
+        }
+    }
+
+    fn sql(db: DatabaseType) -> Option<String> {
+        external_incoming_foreign_keys_sql(db, "shop", "public", &["orders".to_string(), "customers".to_string()])
+    }
+
+    #[test]
+    fn external_fk_query_excludes_the_transfer_tables_themselves() {
+        // Without the exclusion every child table inside the transfer would look like a
+        // blocker and no multi-table rebuild could ever start.
+        let mysql = sql(DatabaseType::Mysql).expect("MySQL needs the check");
+        assert!(mysql.contains("BINARY REFERENCED_TABLE_SCHEMA IN ('shop')"), "{mysql}");
+        assert!(mysql.contains("AND NOT ("), "{mysql}");
+        assert!(mysql.contains("BINARY TABLE_NAME IN ('orders', 'customers')"), "{mysql}");
+        assert!(mysql.contains("BINARY LOWER(TABLE_NAME) IN (LOWER('orders'), LOWER('customers'))"), "{mysql}");
+
+        // PostgreSQL qualifies the exclusion by namespace: a same-named table in another
+        // schema is a real blocker, since its foreign key follows the rename too.
+        let postgres = sql(DatabaseType::Postgres).expect("PostgreSQL needs the check");
+        assert!(postgres.contains("con.contype = 'f'"), "{postgres}");
+        assert!(postgres.contains("tgt_ns.nspname = 'public'"), "{postgres}");
+        assert!(
+            postgres.contains("NOT (src_ns.nspname = 'public' AND src.relname IN ('orders', 'customers'))"),
+            "{postgres}"
+        );
+
+        for db in [DatabaseType::Oracle, DatabaseType::SqlServer] {
+            let generated = sql(db).unwrap_or_else(|| panic!("{db:?} needs the check"));
+            assert!(generated.contains("'orders'") && generated.contains("'customers'"), "{db:?}: {generated}");
+            assert!(generated.contains("NOT ("), "{db:?} is missing the self-exclusion: {generated}");
+        }
+    }
+
+    #[test]
+    fn sqlite_compatible_targets_inspect_foreign_keys_before_renaming() {
+        for db in [DatabaseType::Sqlite, DatabaseType::CloudflareD1] {
+            assert!(sql(db).is_some(), "{db:?} renames can redirect incoming foreign keys");
+        }
+    }
+
+    #[test]
+    fn external_fk_query_escapes_quotes_in_table_names() {
+        let generated =
+            external_incoming_foreign_keys_sql(DatabaseType::Postgres, "shop", "public", &["o'brien".to_string()])
+                .expect("PostgreSQL needs the check");
+        assert!(generated.contains("'o''brien'"), "quote was not doubled: {generated}");
+        assert!(!generated.contains("'o'brien'"), "unescaped literal leaked into the query: {generated}");
+    }
+
+    #[test]
+    fn blocking_foreign_keys_are_grouped_per_referencing_table() {
+        let fk = |table: &str, referenced: &str, constraint: &str| ExternalIncomingForeignKey {
+            referencing_schema: "public".to_string(),
+            referencing_table: table.to_string(),
+            referenced_table: referenced.to_string(),
+            constraint_name: constraint.to_string(),
+        };
+        assert_eq!(describe_external_incoming_foreign_keys(&[]), None, "no blockers must not produce an error");
+
+        let message = describe_external_incoming_foreign_keys(&[
+            fk("invoices", "orders", "fk_invoice_order"),
+            fk("audit_log", "orders", "fk_audit_order"),
+            fk("invoices", "customers", "fk_invoice_customer"),
+        ])
+        .expect("blockers must produce an error");
+
+        assert!(message.starts_with(DROP_TARGET_EXTERNAL_FOREIGN_KEYS), "{message}");
+        // Two referencing tables, not three constraints — the count drives the wording.
+        assert!(message.contains("2 table(s)"), "{message}");
+        // BTreeMap ordering keeps the message stable for snapshot-style frontend tests.
+        assert!(
+            message.contains(
+                "public.audit_log (fk_audit_order -> orders); public.invoices (fk_invoice_customer -> \
+                 customers, fk_invoice_order -> orders)"
+            ),
+            "{message}"
+        );
+    }
+}
diff --git a/crates/dbx-core/tests/live_mysql_transfer.rs b/crates/dbx-core/tests/live_mysql_transfer.rs
index 26bbfb27d5..051d914650 100644
--- a/crates/dbx-core/tests/live_mysql_transfer.rs
+++ b/crates/dbx-core/tests/live_mysql_transfer.rs
@@ -3,6 +3,7 @@ use dbx_core::db::mysql;
 use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
 use dbx_core::storage::Storage;
 use dbx_core::transfer::{
+    drop_backup_tables, execute_on_pool, rename_tables_to_backup, sort_tables_by_fk_dependency_with_foreign_keys,
     transfer_table, TransferContent, TransferMode, TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,
 };
 use serde_json::json;
@@ -85,6 +86,8 @@ fn transfer_request(
         target_catalog: None,
         tables: vec!["spatial_matrix".to_string()],
         create_table: false,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: TransferContent::default(),
         objects: Vec::new(),
         mode,
@@ -99,6 +102,13 @@ async fn query_text(pool: &mysql::MySqlPool, sql: &str) -> String {
     mysql::execute_query(pool, sql, false).await.unwrap().rows[0][0].as_str().unwrap().to_string()
 }
 
+/// `COUNT(*)` over one `information_schema` view, which is the shape every structural
+/// assertion in the `drop_target_before_create` tests below needs (does the table exist,
+/// does the column exist, was the index rebuilt, is the foreign key back).
+async fn schema_count(pool: &mysql::MySqlPool, from_and_where: &str) -> String {
+    query_text(pool, &format!("SELECT CAST(COUNT(*) AS CHAR) FROM information_schema.{from_and_where}")).await
+}
+
 #[test]
 #[ignore = "requires disposable MySQL 8.0.33 source and 8.0.45 target endpoints via DBX_LIVE_MYSQL_TRANSFER_SOURCE_*/TARGET_* variables"]
 fn live_mysql_cross_version_transfer_completes_on_small_stack() {
@@ -182,6 +192,8 @@ async fn run_live_mysql_cross_version_transfer_completes_on_small_stack() {
         target_catalog: None,
         tables: vec!["title_task".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -203,6 +215,7 @@ async fn run_live_mysql_cross_version_transfer_completes_on_small_stack() {
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await?;
@@ -334,6 +347,8 @@ async fn live_mysql_transfer_keeps_columns_whose_comment_mentions_foreign_key()
         target_catalog: None,
         tables: vec!["org".to_string(), "title_task".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -357,6 +372,7 @@ async fn live_mysql_transfer_keeps_columns_whose_comment_mentions_foreign_key()
                 &target_pool_key,
                 &std::collections::HashMap::new(),
                 &mut pending_fk_alters,
+                None,
                 |_| {},
             )
             .await?,
@@ -374,6 +390,7 @@ async fn live_mysql_transfer_keeps_columns_whose_comment_mentions_foreign_key()
                 &target_pool_key,
                 &std::collections::HashMap::new(),
                 &mut pending_fk_alters,
+                None,
                 |_| {},
             )
             .await?,
@@ -489,6 +506,8 @@ async fn live_mysql_transfer_downgrades_unsupported_source_collations() {
         target_catalog: None,
         tables: vec!["transfer_probe".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -510,6 +529,7 @@ async fn live_mysql_transfer_downgrades_unsupported_source_collations() {
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await?;
@@ -550,6 +570,8 @@ async fn live_mysql_transfer_downgrades_unsupported_source_collations() {
             target_catalog: None,
             tables: vec!["transfer_probe".to_string()],
             create_table: true,
+            drop_target_before_create: false,
+            drop_target_confirmed: false,
             content: TransferContent::default(),
             objects: Vec::new(),
             mode: TransferMode::Append,
@@ -570,6 +592,7 @@ async fn live_mysql_transfer_downgrades_unsupported_source_collations() {
                 &modern_target_pool_key,
                 &std::collections::HashMap::new(),
                 &mut Vec::new(),
+                None,
                 |_| {},
             )
             .await?,
@@ -674,6 +697,7 @@ async fn live_mysql_transfer_preserves_spatial_values_and_modes() {
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await?;
@@ -729,6 +753,7 @@ async fn live_mysql_transfer_preserves_spatial_values_and_modes() {
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await?;
@@ -765,6 +790,7 @@ async fn live_mysql_transfer_preserves_spatial_values_and_modes() {
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await?;
@@ -851,6 +877,8 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_col
         target_catalog: None,
         tables: vec!["orders".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Overwrite,
@@ -872,6 +900,7 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_col
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await;
@@ -904,6 +933,8 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_col
             target_catalog: None,
             tables: vec!["required_orders".to_string()],
             create_table: true,
+            drop_target_before_create: false,
+            drop_target_confirmed: false,
             content: TransferContent::default(),
             objects: Vec::new(),
             mode: TransferMode::Overwrite,
@@ -923,6 +954,7 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_col
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await;
@@ -998,6 +1030,8 @@ async fn live_mysql_transfer_structure_only_rejects_incompatible_target_columns(
         target_catalog: None,
         tables: vec!["orders".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: TransferContent::StructureOnly,
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -1019,6 +1053,7 @@ async fn live_mysql_transfer_structure_only_rejects_incompatible_target_columns(
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await;
@@ -1039,3 +1074,877 @@ async fn live_mysql_transfer_structure_only_rejects_incompatible_target_columns(
     cleanup.unwrap();
     test_result.unwrap();
 }
+
+/// Parent/child foreign key topology: the rename pre-pass must run children-first so that
+/// each referencing table is renamed before the table it points to, and the foreign key
+/// must be rebuilt after the main pass completes.
+#[tokio::test]
+#[ignore = "requires a disposable MySQL 5.7+ endpoint via DBX_LIVE_MYSQL_TRANSFER_* variables"]
+async fn live_mysql_transfer_drop_target_parent_child_foreign_key() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("live-mysql-parent-child-{suffix}");
+    let source_database = format!("dbx_parent_child_src_{}", &suffix[..12]);
+    let target_database = format!("dbx_parent_child_dst_{}", &suffix[..12]);
+    let config = live_mysql_config(&connection_id);
+    let setup_pool = mysql::connect(&mysql_url(&config), Duration::from_secs(10)).await.unwrap();
+
+    // Parent table `departments` referenced by child table `employees`. Both have stale target
+    // rows that the drop-recreate must replace.
+    let setup = format!(
+        "CREATE DATABASE `{source_database}`;\
+         CREATE DATABASE `{target_database}`;\
+         CREATE TABLE `{source_database}`.`departments` (id INT PRIMARY KEY, name VARCHAR(32));\
+         CREATE TABLE `{source_database}`.`employees` (\
+             id INT PRIMARY KEY, name VARCHAR(32), dept_id INT, \
+             CONSTRAINT `fk_emp_dept` FOREIGN KEY (dept_id) REFERENCES `departments`(id)\
+         );\
+         INSERT INTO `{source_database}`.`departments` VALUES (10, 'Engineering'), (20, 'Sales');\
+         INSERT INTO `{source_database}`.`employees` VALUES (1, 'Alice', 10), (2, 'Bob', 20);\
+         CREATE TABLE `{target_database}`.`departments` (id INT PRIMARY KEY, name VARCHAR(32));\
+         CREATE TABLE `{target_database}`.`employees` (\
+             id INT PRIMARY KEY, name VARCHAR(32), dept_id INT, \
+             CONSTRAINT `fk_emp_dept` FOREIGN KEY (dept_id) REFERENCES `departments`(id)\
+         );\
+         INSERT INTO `{target_database}`.`departments` VALUES (99, 'Stale');\
+         INSERT INTO `{target_database}`.`employees` VALUES (98, 'Obsolete', 99)"
+    );
+    mysql::execute_query(&setup_pool, &setup, true).await.unwrap();
+    let dir = std::env::temp_dir().join(format!("dbx-live-mysql-parent-child-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new(storage));
+    state.configs.write().await.insert(connection_id.clone(), config);
+    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_database)).await.unwrap();
+    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_database)).await.unwrap();
+
+    let request = TransferRequest {
+        transfer_id: format!("live-mysql-parent-child-{suffix}"),
+        source_connection_id: connection_id.clone(),
+        source_database: source_database.clone(),
+        source_schema: source_database.clone(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: target_database.clone(),
+        target_schema: target_database.clone(),
+        target_catalog: None,
+        tables: vec!["departments".to_string(), "employees".to_string()],
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 10,
+    };
+
+    let test_result = async {
+        // The rename pre-pass must order by foreign key dependencies, children first.
+        let known_fks = sort_tables_by_fk_dependency_with_foreign_keys(
+            &state,
+            &connection_id,
+            &request.target_database,
+            &request.target_schema,
+            &request.tables,
+            false, // parents_first = false → children-first order
+        )
+        .await?;
+        let (tables_for_rename, fk_map) = known_fks;
+        assert_eq!(
+            tables_for_rename,
+            vec!["employees", "departments"],
+            "children-first order: child must be renamed before parent"
+        );
+
+        let backup_names = rename_tables_to_backup(
+            &state,
+            &request,
+            &tables_for_rename,
+            DatabaseType::Mysql,
+            &target_pool_key,
+            |_| {},
+        )
+        .await?;
+        assert_eq!(backup_names.len(), 2, "both preexisting targets must be backed up");
+
+        // Main pass: transfer both tables in parents-first order.
+        let mut pending_fk_alters: Vec<(String, String)> = Vec::new();
+        for (i, table) in request.tables.iter().enumerate() {
+            transfer_table(
+                &state,
+                &request,
+                table,
+                i,
+                &DatabaseType::Mysql,
+                &DatabaseType::Mysql,
+                &source_pool_key,
+                &target_pool_key,
+                &fk_map,
+                &mut pending_fk_alters,
+                Some(&backup_names),
+                |_| {},
+            )
+            .await?;
+        }
+
+        // Stale rows replaced by source data.
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`departments` WHERE id=99")
+            )
+            .await,
+            "0"
+        );
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`employees` WHERE id=98")
+            )
+            .await,
+            "0"
+        );
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`departments` WHERE id IN (10,20)")
+            )
+            .await,
+            "2"
+        );
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`employees` WHERE id IN (1,2)")
+            )
+            .await,
+            "2"
+        );
+
+        // Restore the foreign key: this is where the deferred `ADD CONSTRAINT fk_emp_dept` runs.
+        for (table, alter_sql) in pending_fk_alters {
+            if let Err(e) = execute_on_pool(&state, &target_pool_key, &alter_sql).await {
+                return Err(format!("Failed to restore foreign key on table {}: {}", table, e));
+            }
+        }
+
+        // Every original table must still be recoverable after the required FK restoration.
+        for backup in backup_names.values() {
+            assert_eq!(
+                schema_count(
+                    &setup_pool,
+                    &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = '{backup}'")
+                )
+                .await,
+                "1"
+            );
+        }
+        drop_backup_tables(&state, &request, DatabaseType::Mysql, &target_pool_key, &backup_names, &tables_for_rename)
+            .await?;
+
+        // Foreign key is back and enforces referential integrity.
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!(
+                    "KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = '{target_database}' \
+                     AND TABLE_NAME = 'employees' AND CONSTRAINT_NAME = 'fk_emp_dept'"
+                )
+            )
+            .await,
+            "1",
+            "foreign key constraint must be rebuilt"
+        );
+
+        Ok::<_, String>(())
+    }
+    .await;
+
+    let cleanup = mysql::execute_query(
+        &setup_pool,
+        &format!("DROP DATABASE `{source_database}`; DROP DATABASE `{target_database}`"),
+        true,
+    )
+    .await;
+    setup_pool.disconnect().await.unwrap();
+    let _ = std::fs::remove_dir_all(dir);
+    cleanup.unwrap();
+    test_result.unwrap();
+}
+
+/// Fix A verification: when `drop_target_before_create=true` and the target has incompatible
+/// structure (extra columns not in source), the DROP-then-CREATE flow rebuilds the table to
+/// match the source, replacing the incompatible structure. This is the MySQL counterpart to
+/// `live_postgres_transfer_drop_target_rebuilds_structure_and_indexes`.
+#[tokio::test]
+#[ignore = "requires live MySQL connection via DBX_LIVE_MYSQL_TRANSFER_* env vars"]
+async fn live_mysql_transfer_drop_target_rebuilds_incompatible_structure() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("mysql-drop-rebuild-{suffix}");
+    let source_database = format!("dbx_drop_src_{}", &suffix[..12]);
+    let target_database = format!("dbx_drop_tgt_{}", &suffix[..12]);
+    let config = live_mysql_config(&connection_id);
+    let setup_pool = mysql::connect(&mysql_url(&config), Duration::from_secs(10)).await.unwrap();
+
+    // Source: products(id, name) with 1 row
+    // Target: incompatible products(id, name, extra_col, another_col) with stale row
+    let setup = format!(
+        "CREATE DATABASE `{source_database}`;\
+         CREATE DATABASE `{target_database}`;\
+         CREATE TABLE `{source_database}`.`products` (id INT PRIMARY KEY, name VARCHAR(32));\
+         INSERT INTO `{source_database}`.`products` VALUES (1, 'Widget');\
+         CREATE TABLE `{target_database}`.`products` (\
+             id INT PRIMARY KEY, name VARCHAR(32), extra_col VARCHAR(16), another_col INT\
+         );\
+         INSERT INTO `{target_database}`.`products` VALUES (99, 'Stale', 'obsolete', 42)"
+    );
+    mysql::execute_query(&setup_pool, &setup, true).await.unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-mysql-drop-rebuild-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new(storage));
+    state.configs.write().await.insert(connection_id.clone(), config);
+    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_database)).await.unwrap();
+    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_database)).await.unwrap();
+
+    let request = TransferRequest {
+        transfer_id: format!("drop-rebuild-{suffix}"),
+        source_connection_id: connection_id.clone(),
+        source_database: source_database.clone(),
+        source_schema: source_database.clone(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: target_database.clone(),
+        target_schema: target_database.clone(),
+        target_catalog: None,
+        tables: vec!["products".to_string()],
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 10,
+    };
+
+    let test_result = async {
+        // Rename pre-pass: backup the incompatible target table
+        let backup_names =
+            rename_tables_to_backup(&state, &request, &request.tables, DatabaseType::Mysql, &target_pool_key, |_| {})
+                .await?;
+        assert_eq!(backup_names.len(), 1, "preexisting target must be backed up");
+        let backup_name = backup_names.get("products").unwrap();
+
+        // Backup table exists with the old structure
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = '{backup_name}'")
+            )
+            .await,
+            "1",
+            "backup table must exist after rename"
+        );
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!(
+                    "COLUMNS WHERE TABLE_SCHEMA = '{target_database}' \
+                     AND TABLE_NAME = '{backup_name}' AND COLUMN_NAME = 'extra_col'"
+                )
+            )
+            .await,
+            "1",
+            "backup retains old structure with extra_col"
+        );
+
+        // Main transfer: rebuilds table to match source (id, name only)
+        transfer_table(
+            &state,
+            &request,
+            "products",
+            0,
+            &DatabaseType::Mysql,
+            &DatabaseType::Mysql,
+            &source_pool_key,
+            &target_pool_key,
+            &std::collections::HashMap::new(),
+            &mut Vec::new(),
+            Some(&backup_names),
+            |_| {},
+        )
+        .await?;
+
+        // Rebuilt table matches source structure: only id, name
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!(
+                    "COLUMNS WHERE TABLE_SCHEMA = '{target_database}' \
+                     AND TABLE_NAME = 'products'"
+                )
+            )
+            .await,
+            "2",
+            "rebuilt table must have exactly 2 columns from source"
+        );
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!(
+                    "COLUMNS WHERE TABLE_SCHEMA = '{target_database}' \
+                     AND TABLE_NAME = 'products' AND COLUMN_NAME = 'extra_col'"
+                )
+            )
+            .await,
+            "0",
+            "extra_col must be gone after rebuild"
+        );
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!(
+                    "COLUMNS WHERE TABLE_SCHEMA = '{target_database}' \
+                     AND TABLE_NAME = 'products' AND COLUMN_NAME = 'another_col'"
+                )
+            )
+            .await,
+            "0",
+            "another_col must be gone after rebuild"
+        );
+
+        // Stale row replaced with source data
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`products` WHERE id=99")
+            )
+            .await,
+            "0",
+            "stale row must be gone"
+        );
+        assert_eq!(
+            query_text(&setup_pool, &format!("SELECT name FROM `{target_database}`.`products` WHERE id=1")).await,
+            "Widget",
+            "source row must be present"
+        );
+
+        // Cleanup: drop backup
+        drop_backup_tables(&state, &request, DatabaseType::Mysql, &target_pool_key, &backup_names, &request.tables)
+            .await?;
+
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = '{backup_name}'")
+            )
+            .await,
+            "0",
+            "backup must be dropped after successful transfer"
+        );
+
+        Ok::<_, String>(())
+    }
+    .await;
+
+    let cleanup = mysql::execute_query(
+        &setup_pool,
+        &format!("DROP DATABASE `{source_database}`; DROP DATABASE `{target_database}`"),
+        true,
+    )
+    .await;
+    setup_pool.disconnect().await.unwrap();
+    let _ = std::fs::remove_dir_all(dir);
+    cleanup.unwrap();
+    test_result.unwrap();
+}
+
+/// Verifies external incoming foreign key rejection: when a table outside the transfer selection
+/// references a table in the transfer, `drop_target_before_create` must be blocked because
+/// dropping the referenced table would break the external constraint.
+#[tokio::test]
+#[ignore = "requires live MySQL connection via DBX_LIVE_MYSQL_TRANSFER_* env vars"]
+async fn live_mysql_transfer_drop_target_rejects_external_incoming_fk() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("mysql-external-fk-{suffix}");
+    let database = format!("dbx_ext_fk_{}", &suffix[..12]);
+    let config = live_mysql_config(&connection_id);
+    let setup_pool = mysql::connect(&mysql_url(&config), Duration::from_secs(10)).await.unwrap();
+
+    // Table `categories` will be in the transfer; table `products` is OUTSIDE the transfer
+    // and references `categories`. This external incoming FK must block drop_target.
+    let setup = format!(
+        "CREATE DATABASE `{database}`;\
+         CREATE TABLE `{database}`.`categories` (id INT PRIMARY KEY, name VARCHAR(32));\
+         CREATE TABLE `{database}`.`products` (\
+             id INT PRIMARY KEY, name VARCHAR(32), category_id INT, \
+             CONSTRAINT `fk_product_category` FOREIGN KEY (category_id) REFERENCES `categories`(id)\
+         );\
+         INSERT INTO `{database}`.`categories` VALUES (1, 'Electronics');\
+         INSERT INTO `{database}`.`products` VALUES (100, 'Laptop', 1)"
+    );
+    mysql::execute_query(&setup_pool, &setup, true).await.unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-mysql-ext-fk-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new(storage));
+    state.configs.write().await.insert(connection_id.clone(), config);
+    let pool_key = state.get_or_create_pool(&connection_id, Some(&database)).await.unwrap();
+
+    let request = TransferRequest {
+        transfer_id: format!("ext-fk-{suffix}"),
+        source_connection_id: connection_id.clone(),
+        source_database: database.clone(),
+        source_schema: database.clone(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: database.clone(),
+        target_schema: database.clone(),
+        target_catalog: None,
+        tables: vec!["categories".to_string()], // Only categories, not products
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 10,
+    };
+
+    // Attempt rename pre-pass: should detect external incoming FK and reject
+    let rename_result =
+        rename_tables_to_backup(&state, &request, &request.tables, DatabaseType::Mysql, &pool_key, |_| {}).await;
+
+    assert!(rename_result.is_err(), "rename must reject when external incoming FK exists");
+    let error = rename_result.unwrap_err();
+    assert!(
+        error.contains("fk_product_category") || error.contains("products") || error.contains("incoming"),
+        "error must mention external constraint or incoming FK, got: {error}"
+    );
+
+    // Original table unharmed
+    assert_eq!(
+        query_text(&setup_pool, &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{database}`.`categories`")).await,
+        "1",
+        "original table must survive the rejected rename"
+    );
+
+    mysql::execute_query(&setup_pool, &format!("DROP DATABASE `{database}`"), true).await.unwrap();
+    setup_pool.disconnect().await.unwrap();
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+/// A circular FK graph has no valid sequential DROP order. Rebuild must restore both new FKs
+/// while every backup still exists, then safely remove only the backup graph.
+#[tokio::test]
+#[ignore = "requires live MySQL connection via DBX_LIVE_MYSQL_TRANSFER_* env vars"]
+async fn live_mysql_transfer_drop_target_circular_foreign_keys() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("mysql-circular-fk-{suffix}");
+    let source_database = format!("dbx_circ_src_{}", &suffix[..12]);
+    let target_database = format!("dbx_circ_tgt_{}", &suffix[..12]);
+    let config = live_mysql_config(&connection_id);
+    let setup_pool = mysql::connect(&mysql_url(&config), Duration::from_secs(10)).await.unwrap();
+
+    // Circular FK: users.group_id -> groups.id, groups.owner_id -> users.id
+    let setup = format!(
+        "CREATE DATABASE `{source_database}`;\
+         CREATE DATABASE `{target_database}`;\
+         CREATE TABLE `{source_database}`.`users` (id INT PRIMARY KEY, name VARCHAR(32), group_id INT);\
+         CREATE TABLE `{source_database}`.`groups` (id INT PRIMARY KEY, name VARCHAR(32), owner_id INT);\
+         ALTER TABLE `{source_database}`.`users` ADD CONSTRAINT `fk_user_group` \
+             FOREIGN KEY (group_id) REFERENCES `groups`(id) ON UPDATE CASCADE ON DELETE RESTRICT;\
+         ALTER TABLE `{source_database}`.`groups` ADD CONSTRAINT `fk_group_owner` \
+             FOREIGN KEY (owner_id) REFERENCES `users`(id) ON UPDATE RESTRICT ON DELETE CASCADE;\
+         INSERT INTO `{source_database}`.`users` VALUES (1, 'Alice', NULL);\
+         INSERT INTO `{source_database}`.`groups` VALUES (10, 'Admins', 1);\
+         UPDATE `{source_database}`.`users` SET group_id = 10 WHERE id = 1;\
+         CREATE TABLE `{target_database}`.`users` (id INT PRIMARY KEY, name VARCHAR(32), group_id INT);\
+         CREATE TABLE `{target_database}`.`groups` (id INT PRIMARY KEY, name VARCHAR(32), owner_id INT);\
+         ALTER TABLE `{target_database}`.`users` ADD CONSTRAINT `fk_user_group` \
+             FOREIGN KEY (group_id) REFERENCES `groups`(id) ON UPDATE CASCADE ON DELETE RESTRICT;\
+         ALTER TABLE `{target_database}`.`groups` ADD CONSTRAINT `fk_group_owner` \
+             FOREIGN KEY (owner_id) REFERENCES `users`(id) ON UPDATE RESTRICT ON DELETE CASCADE;\
+         INSERT INTO `{target_database}`.`users` VALUES (99, 'Stale', NULL);\
+         INSERT INTO `{target_database}`.`groups` VALUES (98, 'Obsolete', 99);\
+         UPDATE `{target_database}`.`users` SET group_id = 98 WHERE id = 99"
+    );
+    mysql::execute_query(&setup_pool, &setup, true).await.unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-mysql-circular-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new(storage));
+    state.configs.write().await.insert(connection_id.clone(), config);
+    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_database)).await.unwrap();
+    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_database)).await.unwrap();
+
+    let request = TransferRequest {
+        transfer_id: format!("circular-{suffix}"),
+        source_connection_id: connection_id.clone(),
+        source_database: source_database.clone(),
+        source_schema: source_database.clone(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: target_database.clone(),
+        target_schema: target_database.clone(),
+        target_catalog: None,
+        tables: vec!["users".to_string(), "groups".to_string()],
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 10,
+    };
+
+    let test_result = async {
+        // Sorting alone cannot break a cycle; renaming must retain the backup relationships.
+        let (tables_for_rename, fk_map) = sort_tables_by_fk_dependency_with_foreign_keys(
+            &state,
+            &connection_id,
+            &request.target_database,
+            &request.target_schema,
+            &request.tables,
+            false,
+        )
+        .await?;
+
+        // Backup FKs must remain enforceable while their original names are freed for the new tables.
+        let backup_names = rename_tables_to_backup(
+            &state,
+            &request,
+            &tables_for_rename,
+            DatabaseType::Mysql,
+            &target_pool_key,
+            |_| {},
+        )
+        .await?;
+        assert_eq!(backup_names.len(), 2, "both tables must be backed up");
+
+        for (table, referenced_table, update_rule, delete_rule) in [
+            ("users", "groups", "CASCADE", "RESTRICT"),
+            ("groups", "users", "RESTRICT", "CASCADE"),
+        ] {
+            let backup = &backup_names[table];
+            let referenced_backup = &backup_names[referenced_table];
+            assert_eq!(
+                schema_count(
+                    &setup_pool,
+                    &format!(
+                        "REFERENTIAL_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = '{target_database}' \
+                         AND TABLE_NAME = '{backup}' AND REFERENCED_TABLE_NAME = '{referenced_backup}' \
+                         AND UPDATE_RULE = '{update_rule}' AND DELETE_RULE = '{delete_rule}'"
+                    )
+                )
+                .await,
+                "1",
+                "backup FK for {table} must preserve both its referenced backup and update/delete rules"
+            );
+        }
+
+        // Main transfer
+        let mut pending_fk_alters: Vec<(String, String)> = Vec::new();
+        for (i, table) in request.tables.iter().enumerate() {
+            transfer_table(
+                &state,
+                &request,
+                table,
+                i,
+                &DatabaseType::Mysql,
+                &DatabaseType::Mysql,
+                &source_pool_key,
+                &target_pool_key,
+                &fk_map,
+                &mut pending_fk_alters,
+                Some(&backup_names),
+                |_| {},
+            )
+            .await?;
+        }
+
+        // Data transferred correctly
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`users` WHERE id=1")
+            )
+            .await,
+            "1"
+        );
+        assert_eq!(
+            query_text(
+                &setup_pool,
+                &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`groups` WHERE id=10")
+            )
+            .await,
+            "1"
+        );
+
+        // Required FK restoration precedes cleanup, so a restoration failure retains all originals.
+        for (table, alter_sql) in pending_fk_alters {
+            execute_on_pool(&state, &target_pool_key, &alter_sql)
+                .await
+                .map_err(|e| format!("Failed to restore FK on {table} while backups are retained: {e}"))?;
+        }
+        for (table, id, name) in [("users", 99, "Stale"), ("groups", 98, "Obsolete")] {
+            let backup = &backup_names[table];
+            assert_eq!(
+                query_text(&setup_pool, &format!("SELECT name FROM `{target_database}`.`{backup}` WHERE id = {id}")).await,
+                name,
+                "original data must remain available after all new FKs are restored"
+            );
+        }
+        for (table, referenced_table, constraint, update_rule, delete_rule) in [
+            ("users", "groups", "fk_user_group", "CASCADE", "RESTRICT"),
+            ("groups", "users", "fk_group_owner", "RESTRICT", "CASCADE"),
+        ] {
+            assert_eq!(
+                schema_count(
+                    &setup_pool,
+                    &format!(
+                        "REFERENTIAL_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = '{target_database}' \
+                         AND TABLE_NAME = '{table}' AND REFERENCED_TABLE_NAME = '{referenced_table}' \
+                         AND CONSTRAINT_NAME = '{constraint}' AND UPDATE_RULE = '{update_rule}' AND DELETE_RULE = '{delete_rule}'"
+                    )
+                )
+                .await,
+                "1",
+                "new FK for {table} must point at the new table with its source rules before backups are dropped"
+            );
+        }
+
+        // Cleanup must handle the backup-only cycle without affecting restored target constraints.
+        drop_backup_tables(&state, &request, DatabaseType::Mysql, &target_pool_key, &backup_names, &tables_for_rename)
+            .await?;
+
+        // Both backups gone
+        for table in &request.tables {
+            let backup_name = backup_names.get(table).unwrap();
+            assert_eq!(
+                schema_count(
+                    &setup_pool,
+                    &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = '{backup_name}'")
+                )
+                .await,
+                "0",
+                "backup {backup_name} must be dropped"
+            );
+        }
+
+        // Circular FK constraints restored
+        assert_eq!(
+            schema_count(
+                &setup_pool,
+                &format!(
+                    "KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = '{target_database}' \
+                     AND CONSTRAINT_NAME IN ('fk_user_group', 'fk_group_owner')"
+                )
+            )
+            .await,
+            "2",
+            "both FK constraints must be restored"
+        );
+
+        let invalid_insert = mysql::execute_query(
+            &setup_pool,
+            &format!("INSERT INTO `{target_database}`.`users` VALUES (7, 'invalid', 999)"),
+            false,
+        )
+        .await
+        .expect_err("restored FK must reject missing references after backup cleanup");
+        assert!(invalid_insert.to_lowercase().contains("foreign key"), "{invalid_insert}");
+
+        Ok::<_, String>(())
+    }
+    .await;
+
+    let cleanup = mysql::execute_query(
+        &setup_pool,
+        &format!("DROP DATABASE `{source_database}`; DROP DATABASE `{target_database}`"),
+        true,
+    )
+    .await;
+    setup_pool.disconnect().await.unwrap();
+    let _ = std::fs::remove_dir_all(dir);
+    cleanup.unwrap();
+    test_result.unwrap();
+}
+
+/// Verifies backup retention on transfer failure: when the main transfer fails after the rename
+/// pre-pass, the backup tables must be retained so the user can recover. The backup is only
+/// dropped when the transfer succeeds.
+#[tokio::test]
+#[ignore = "requires live MySQL connection via DBX_LIVE_MYSQL_TRANSFER_* env vars"]
+async fn live_mysql_transfer_drop_target_retains_backup_on_failure() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("mysql-retain-backup-{suffix}");
+    let source_database = format!("dbx_retain_src_{}", &suffix[..12]);
+    let target_database = format!("dbx_retain_tgt_{}", &suffix[..12]);
+    let config = live_mysql_config(&connection_id);
+    let setup_pool = mysql::connect(&mysql_url(&config), Duration::from_secs(10)).await.unwrap();
+
+    // Source: orders(id, name)
+    // Target: orders(id, name) with a row that will survive the failed transfer
+    let setup = format!(
+        "CREATE DATABASE `{source_database}`;\
+         CREATE DATABASE `{target_database}`;\
+         CREATE TABLE `{source_database}`.`orders` (id INT PRIMARY KEY, name VARCHAR(32));\
+         INSERT INTO `{source_database}`.`orders` VALUES (1, 'Alpha');\
+         CREATE TABLE `{target_database}`.`orders` (id INT PRIMARY KEY, name VARCHAR(32));\
+         INSERT INTO `{target_database}`.`orders` VALUES (99, 'Original')"
+    );
+    mysql::execute_query(&setup_pool, &setup, true).await.unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-mysql-retain-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new(storage));
+    state.configs.write().await.insert(connection_id.clone(), config);
+    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_database)).await.unwrap();
+    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_database)).await.unwrap();
+
+    let request = TransferRequest {
+        transfer_id: format!("retain-{suffix}"),
+        source_connection_id: connection_id.clone(),
+        source_database: source_database.clone(),
+        source_schema: source_database.clone(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: target_database.clone(),
+        target_schema: target_database.clone(),
+        target_catalog: None,
+        tables: vec!["orders".to_string()],
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 10,
+    };
+
+    // Rename pre-pass: backup created
+    let backup_names =
+        rename_tables_to_backup(&state, &request, &request.tables, DatabaseType::Mysql, &target_pool_key, |_| {})
+            .await
+            .unwrap();
+    let backup_name = backup_names.get("orders").unwrap();
+
+    // Backup exists with original row
+    assert_eq!(
+        schema_count(
+            &setup_pool,
+            &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = '{backup_name}'")
+        )
+        .await,
+        "1",
+        "backup must exist after rename"
+    );
+    assert_eq!(
+        query_text(
+            &setup_pool,
+            &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`{backup_name}` WHERE id=99")
+        )
+        .await,
+        "1",
+        "backup must contain original data"
+    );
+
+    // Simulate transfer failure: corrupt the source pool key to force an error
+    let bad_pool_key = format!("{source_pool_key}_nonexistent");
+    let transfer_result = transfer_table(
+        &state,
+        &request,
+        "orders",
+        0,
+        &DatabaseType::Mysql,
+        &DatabaseType::Mysql,
+        &bad_pool_key, // Intentionally wrong to trigger failure
+        &target_pool_key,
+        &std::collections::HashMap::new(),
+        &mut Vec::new(),
+        Some(&backup_names),
+        |_| {},
+    )
+    .await;
+
+    assert!(transfer_result.is_err(), "transfer must fail with bad pool key");
+
+    // Backup still exists after transfer failure (not auto-dropped)
+    assert_eq!(
+        schema_count(
+            &setup_pool,
+            &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = '{backup_name}'")
+        )
+        .await,
+        "1",
+        "backup must survive transfer failure"
+    );
+    assert_eq!(
+        query_text(&setup_pool, &format!("SELECT name FROM `{target_database}`.`{backup_name}` WHERE id=99")).await,
+        "Original",
+        "backup data must be intact for recovery"
+    );
+
+    // Rebuilt table exists (CREATE succeeded before transfer failed) but is empty
+    assert_eq!(
+        schema_count(
+            &setup_pool,
+            &format!("TABLES WHERE TABLE_SCHEMA = '{target_database}' AND TABLE_NAME = 'orders'")
+        )
+        .await,
+        "1",
+        "rebuilt table exists (CREATE succeeded)"
+    );
+    assert_eq!(
+        query_text(&setup_pool, &format!("SELECT CAST(COUNT(*) AS CHAR) FROM `{target_database}`.`orders`")).await,
+        "0",
+        "rebuilt table is empty (transfer failed before data insert)"
+    );
+
+    // User can recover by renaming backup back: DROP orders, RENAME backup TO orders
+    mysql::execute_query(
+        &setup_pool,
+        &format!(
+            "DROP TABLE `{target_database}`.`orders`; \
+                  RENAME TABLE `{target_database}`.`{backup_name}` TO `{target_database}`.`orders`"
+        ),
+        true,
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        query_text(&setup_pool, &format!("SELECT name FROM `{target_database}`.`orders` WHERE id=99")).await,
+        "Original",
+        "user can recover original data from backup"
+    );
+
+    mysql::execute_query(
+        &setup_pool,
+        &format!("DROP DATABASE `{source_database}`; DROP DATABASE `{target_database}`"),
+        true,
+    )
+    .await
+    .unwrap();
+    setup_pool.disconnect().await.unwrap();
+    let _ = std::fs::remove_dir_all(dir);
+}
diff --git a/crates/dbx-core/tests/live_postgres_transfer.rs b/crates/dbx-core/tests/live_postgres_transfer.rs
index f6f24cb0ec..f5a98e8acb 100644
--- a/crates/dbx-core/tests/live_postgres_transfer.rs
+++ b/crates/dbx-core/tests/live_postgres_transfer.rs
@@ -3,8 +3,9 @@ use dbx_core::db::postgres;
 use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
 use dbx_core::storage::Storage;
 use dbx_core::transfer::{
-    get_db_type, transfer_postgres_schema_dependencies, transfer_postgres_schema_objects, transfer_table, TransferMode,
-    TransferObjectKind, TransferObjectSelection, TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,
+    drop_backup_tables, get_db_type, rename_tables_to_backup, transfer_postgres_schema_dependencies,
+    transfer_postgres_schema_objects, transfer_table, TransferContent, TransferMode, TransferObjectKind,
+    TransferObjectSelection, TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,
 };
 use serde_json::json;
 use std::sync::Arc;
@@ -75,6 +76,23 @@ async fn query_scalar(pool: &deadpool_postgres::Pool, sql: &str) -> serde_json::
     postgres::execute_query(pool, sql).await.unwrap().rows[0][0].clone()
 }
 
+/// Query scalar as text for structural assertions (like MySQL `schema_count`).
+async fn query_text(pool: &deadpool_postgres::Pool, sql: &str) -> String {
+    let val = query_scalar(pool, sql).await;
+    if let Some(s) = val.as_str() {
+        return s.to_string();
+    }
+    if let Some(n) = val.as_i64() {
+        return n.to_string();
+    }
+    String::new()
+}
+
+/// `COUNT(*)` over `information_schema`, the shape every drop_target structural assertion needs.
+async fn schema_count(pool: &deadpool_postgres::Pool, from_and_where: &str) -> String {
+    query_text(pool, &format!("SELECT COUNT(*)::text FROM information_schema.{from_and_where}")).await
+}
+
 async fn query_index_rows(pool: &deadpool_postgres::Pool, schema: &str) -> Vec<(String, String)> {
     postgres::execute_query(
         pool,
@@ -228,6 +246,8 @@ async fn live_postgres_transfer_upserts_generated_always_identity_values() {
         target_catalog: None,
         tables: vec!["items".to_string()],
         create_table: false,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: dbx_core::transfer::TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Upsert,
@@ -249,6 +269,7 @@ async fn live_postgres_transfer_upserts_generated_always_identity_values() {
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await
@@ -282,6 +303,7 @@ async fn live_postgres_transfer_upserts_generated_always_identity_values() {
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await
@@ -396,6 +418,8 @@ async fn live_postgres_structure_only_preserves_table_indexes() {
         target_catalog: None,
         tables: vec!["index_transfer".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: dbx_core::transfer::TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -419,6 +443,7 @@ async fn live_postgres_structure_only_preserves_table_indexes() {
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await;
@@ -442,6 +467,7 @@ async fn live_postgres_structure_only_preserves_table_indexes() {
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await;
@@ -645,6 +671,8 @@ async fn live_postgres_transfer_preserves_data_and_schema_objects() {
         target_catalog: None,
         tables: vec!["users".to_string(), "audit_logs".to_string(), "files".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: dbx_core::transfer::TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -670,6 +698,7 @@ async fn live_postgres_transfer_preserves_data_and_schema_objects() {
             &target_pool_key,
             &std::collections::HashMap::new(),
             &mut Vec::new(),
+            None,
             |_| {},
         )
         .await
@@ -846,6 +875,13 @@ async fn live_postgres_transfer_preserves_data_and_schema_objects() {
     let _ = std::fs::remove_dir_all(dir);
 }
 
+/// Scope: `drop_target_before_create: false`, the default. `create_table` is a request,
+/// not a command — an existing target table is reused as-is and the CREATE DDL is
+/// skipped, so the source rows are appended into the table the user already had.
+///
+/// `drop_target_before_create: true` inverts this on purpose: the rename pre-pass frees
+/// the name, so the CREATE DDL always runs and the target is rebuilt from the source
+/// structure. See `live_postgres_transfer_drop_target_rebuilds_structure_and_indexes`.
 #[tokio::test]
 #[ignore = "requires PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"]
 async fn live_postgres_transfer_skips_create_ddl_for_existing_target_table() {
@@ -937,6 +973,8 @@ async fn live_postgres_transfer_skips_create_ddl_for_existing_target_table() {
         target_catalog: None,
         tables: vec!["items".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: dbx_core::transfer::TransferContent::default(),
         objects: Vec::new(),
         mode: TransferMode::Append,
@@ -959,6 +997,7 @@ async fn live_postgres_transfer_skips_create_ddl_for_existing_target_table() {
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await
@@ -1058,6 +1097,8 @@ async fn live_postgres_transfer_creates_selected_sequence_before_referencing_tab
         target_catalog: None,
         tables: vec!["biz_banner".to_string()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: dbx_core::transfer::TransferContent::default(),
         objects: vec![
             TransferObjectSelection { object_type: TransferObjectKind::Table, names: vec!["biz_banner".to_string()] },
@@ -1087,6 +1128,7 @@ async fn live_postgres_transfer_creates_selected_sequence_before_referencing_tab
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await
@@ -1168,3 +1210,539 @@ async fn live_postgres_transfer_creates_selected_sequence_before_referencing_tab
     let _ = postgres::execute_batch(&target_pool, &[cleanup_sql[1].clone()]).await;
     let _ = std::fs::remove_dir_all(dir);
 }
+
+/// Counterpart to `live_postgres_transfer_skips_create_ddl_for_existing_target_table`: when
+/// `drop_target_before_create` is true, the rename pre-pass frees the name so the CREATE DDL
+/// always runs and the target is rebuilt from the source structure, including indexes.
+///
+/// This test also verifies Fix B: PG backup table indexes are renamed during the pre-pass so
+/// schema-scoped index names are freed for the rebuilt table. Without Fix B, `CREATE INDEX IF
+/// NOT EXISTS {original_name}` would silently skip because the backup still holds that name.
+#[tokio::test]
+#[ignore = "requires live PostgreSQL connection"]
+async fn live_postgres_transfer_drop_target_rebuilds_structure_and_indexes() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("pg-drop-rebuild-{suffix}");
+    let source_schema = format!("drop_src_{}", &suffix[..12]);
+    let target_schema = format!("drop_tgt_{}", &suffix[..12]);
+
+    let url = std::env::var("DBX_LIVE_PG_TRANSFER_SOURCE_URL").expect("DBX_LIVE_PG_TRANSFER_SOURCE_URL");
+    let pool = postgres::connect(&url, std::time::Duration::from_secs(5)).await.expect("live PG connection");
+    let database = query_text(&pool, "SELECT current_database()").await;
+    let config = postgres_test_config(&connection_id, &database);
+
+    // Source: orders(id, name, extra_col) + secondary index on name
+    postgres::execute_batch(
+        &pool,
+        &[
+            format!("CREATE SCHEMA {source_schema}"),
+            format!(
+                "CREATE TABLE {source_schema}.orders (\
+                 id INT PRIMARY KEY, name TEXT NOT NULL, extra_col TEXT)"
+            ),
+            format!("CREATE INDEX idx_orders_name ON {source_schema}.orders(name)"),
+            format!("COMMENT ON INDEX {source_schema}.idx_orders_name IS 'source index comment'"),
+            format!("INSERT INTO {source_schema}.orders VALUES (1, 'alpha', 'x')"),
+        ],
+    )
+    .await
+    .unwrap();
+
+    // Target: incompatible structure orders(id, name) with stale row, plus its own index
+    postgres::execute_batch(
+        &pool,
+        &[
+            format!("CREATE SCHEMA {target_schema}"),
+            format!("CREATE TABLE {target_schema}.orders (id INT PRIMARY KEY, name TEXT NOT NULL)"),
+            format!("CREATE INDEX idx_orders_name ON {target_schema}.orders(name)"),
+            format!("COMMENT ON INDEX {target_schema}.idx_orders_name IS 'stale target index comment'"),
+            format!("INSERT INTO {target_schema}.orders VALUES (99, 'stale')"),
+        ],
+    )
+    .await
+    .unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-drop-rebuild-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = Arc::new(AppState::new(storage));
+    state.configs.write().await.insert(connection_id.clone(), config);
+
+    let pool_key = format!("{}:{}", connection_id, database);
+    state
+        .update_connection_pools(|connections| {
+            connections.insert(pool_key.clone(), PoolKind::Postgres(pool.clone()));
+        })
+        .await;
+
+    let transfer_id = format!("transfer-{suffix}");
+    let request = TransferRequest {
+        transfer_id: transfer_id.clone(),
+        source_connection_id: connection_id.clone(),
+        source_database: database.to_string(),
+        source_schema: source_schema.clone(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: database.to_string(),
+        target_schema: target_schema.clone(),
+        target_catalog: None,
+        tables: vec!["orders".to_string()],
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 1000,
+    };
+
+    // Execute rename pre-pass + transfer + backup cleanup
+    let backup_names =
+        rename_tables_to_backup(&state, &request, &request.tables, DatabaseType::Postgres, &pool_key, |_| {})
+            .await
+            .unwrap();
+
+    let backup_name = backup_names.get("orders").cloned().expect("preexisting target must be backed up");
+    assert!(backup_name.starts_with("orders__dbx_bak_"), "unexpected backup name: {backup_name}");
+
+    // After pre-pass: backup table exists, original indexes were renamed (Fix B)
+    assert_eq!(
+        schema_count(&pool, &format!("tables WHERE table_schema = '{target_schema}' AND table_name = '{backup_name}'"))
+            .await,
+        "1",
+        "backup table must exist after rename pre-pass"
+    );
+
+    // Verify backup's index was renamed (Fix B): the original idx_orders_name should not exist on backup
+    let backup_indexes = postgres::execute_query(
+        &pool,
+        &format!(
+            "SELECT indexname FROM pg_indexes WHERE schemaname = '{target_schema}' \
+             AND tablename = '{backup_name}' ORDER BY indexname"
+        ),
+    )
+    .await
+    .unwrap();
+    assert!(
+        backup_indexes.rows.iter().all(|row| {
+            let idx_name = row[0].as_str().unwrap();
+            idx_name.contains("__dbx_bak_") || idx_name.ends_with("_pkey")
+        }),
+        "backup indexes should be renamed with __dbx_bak_ suffix, got: {:?}",
+        backup_indexes.rows
+    );
+
+    let transferred = transfer_table(
+        &state,
+        &request,
+        "orders",
+        0,
+        &DatabaseType::Postgres,
+        &DatabaseType::Postgres,
+        &pool_key,
+        &pool_key,
+        &std::collections::HashMap::new(),
+        &mut Vec::new(),
+        Some(&backup_names),
+        |_| {},
+    )
+    .await
+    .unwrap();
+    assert_eq!(transferred, 1, "should transfer 1 row");
+
+    drop_backup_tables(&state, &request, DatabaseType::Postgres, &pool_key, &backup_names, &request.tables)
+        .await
+        .unwrap();
+
+    // Verify structure rebuild: extra_col present (source had it, target didn't)
+    assert_eq!(
+        schema_count(
+            &pool,
+            &format!(
+                "columns WHERE table_schema = '{target_schema}' AND table_name = 'orders' \
+                 AND column_name = 'extra_col'"
+            )
+        )
+        .await,
+        "1",
+        "extra_col from source must be present after rebuild"
+    );
+
+    // Verify index rebuilt: idx_orders_name exists on the new table
+    assert_eq!(
+        query_text(
+            &pool,
+            &format!(
+                "SELECT COUNT(*)::text FROM pg_indexes WHERE schemaname = '{target_schema}' \
+                 AND tablename = 'orders' AND indexname = 'idx_orders_name'"
+            )
+        )
+        .await,
+        "1",
+        "idx_orders_name must be rebuilt on the new table"
+    );
+
+    // Verify index comment transferred to the rebuilt table's index
+    let rebuilt_comment = postgres::execute_query(
+        &pool,
+        &format!(
+            "SELECT obj_description(c.oid, 'pg_class') FROM pg_catalog.pg_class c \
+             JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+             WHERE n.nspname = '{target_schema}' AND c.relname = 'idx_orders_name'"
+        ),
+    )
+    .await
+    .unwrap();
+    assert_eq!(rebuilt_comment.rows[0][0], json!("source index comment"), "index comment must come from source");
+
+    // Verify data: stale row gone, source row present
+    assert_eq!(
+        query_text(&pool, &format!("SELECT COUNT(*)::text FROM {target_schema}.orders WHERE id = 99")).await,
+        "0",
+        "stale target row must be gone"
+    );
+    assert_eq!(
+        query_scalar(&pool, &format!("SELECT name FROM {target_schema}.orders WHERE id = 1")).await,
+        json!("alpha")
+    );
+    assert_eq!(
+        query_scalar(&pool, &format!("SELECT extra_col FROM {target_schema}.orders WHERE id = 1")).await,
+        json!("x")
+    );
+
+    // Verify backup dropped
+    assert_eq!(
+        schema_count(&pool, &format!("tables WHERE table_schema = '{target_schema}' AND table_name = '{backup_name}'"))
+            .await,
+        "0",
+        "backup must be dropped after successful transfer"
+    );
+
+    let _ = postgres::execute_batch(
+        &pool,
+        &[format!("DROP SCHEMA {source_schema} CASCADE"), format!("DROP SCHEMA {target_schema} CASCADE")],
+    )
+    .await;
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+struct PostgresRebuildFixture {
+    state: Arc<AppState>,
+    source_pool: deadpool_postgres::Pool,
+    target_pool: deadpool_postgres::Pool,
+    source_pool_key: String,
+    target_pool_key: String,
+    request: TransferRequest,
+    _storage_dir: tempfile::TempDir,
+}
+
+impl PostgresRebuildFixture {
+    async fn new(label: &str, tables: &[&str]) -> Self {
+        let source_url = std::env::var("DBX_LIVE_PG_TRANSFER_SOURCE_URL").expect("DBX_LIVE_PG_TRANSFER_SOURCE_URL");
+        let target_url = std::env::var("DBX_LIVE_PG_TRANSFER_TARGET_URL").unwrap_or_else(|_| source_url.clone());
+        let source_pool = postgres::connect(&source_url, std::time::Duration::from_secs(5)).await.unwrap();
+        let target_pool = postgres::connect(&target_url, std::time::Duration::from_secs(5)).await.unwrap();
+        let source_database = query_text(&source_pool, "SELECT current_database()").await;
+        let target_database = query_text(&target_pool, "SELECT current_database()").await;
+        let suffix = uuid::Uuid::new_v4().simple().to_string();
+        let source_schema = format!("dbx_{label}_src_{}", &suffix[..8]);
+        let target_schema = format!("dbx_{label}_dst_{}", &suffix[..8]);
+        let source_connection_id = format!("{label}-source-{suffix}");
+        let target_connection_id = format!("{label}-target-{suffix}");
+        let source_pool_key = format!("{source_connection_id}:{source_database}");
+        let target_pool_key = format!("{target_connection_id}:{target_database}");
+        let storage_dir = tempfile::tempdir().unwrap();
+        let state = Arc::new(AppState::new(Storage::open(&storage_dir.path().join("storage.db")).await.unwrap()));
+        state
+            .update_connection_pools(|connections| {
+                connections.insert(source_pool_key.clone(), PoolKind::Postgres(source_pool.clone()));
+                connections.insert(target_pool_key.clone(), PoolKind::Postgres(target_pool.clone()));
+            })
+            .await;
+        {
+            let mut configs = state.configs.write().await;
+            configs.insert(source_connection_id.clone(), postgres_test_config(&source_connection_id, &source_database));
+            configs.insert(target_connection_id.clone(), postgres_test_config(&target_connection_id, &target_database));
+        }
+        postgres::execute_query(&source_pool, &format!("CREATE SCHEMA {source_schema}")).await.unwrap();
+        postgres::execute_query(&target_pool, &format!("CREATE SCHEMA {target_schema}")).await.unwrap();
+        Self {
+            state,
+            source_pool,
+            target_pool,
+            source_pool_key,
+            target_pool_key,
+            request: TransferRequest {
+                transfer_id: format!("{label}-{suffix}"),
+                source_connection_id,
+                source_database,
+                source_schema,
+                source_catalog: None,
+                target_connection_id,
+                target_database,
+                target_schema,
+                target_catalog: None,
+                tables: tables.iter().map(|table| (*table).to_string()).collect(),
+                create_table: true,
+                drop_target_before_create: true,
+                drop_target_confirmed: true,
+                content: TransferContent::default(),
+                objects: Vec::new(),
+                mode: TransferMode::Append,
+                target_table_name_case: TransferTableNameCase::Preserve,
+                quote_target_column_names: true,
+                ownership_policy: TransferOwnershipPolicy::Preserve,
+                batch_size: 100,
+            },
+            _storage_dir: storage_dir,
+        }
+    }
+
+    async fn rename(&self) -> Result<std::collections::HashMap<String, String>, String> {
+        rename_tables_to_backup(
+            &self.state,
+            &self.request,
+            &self.request.tables,
+            DatabaseType::Postgres,
+            &self.target_pool_key,
+            |_| {},
+        )
+        .await
+    }
+
+    async fn transfer(&self, backups: &std::collections::HashMap<String, String>) -> Result<u64, String> {
+        transfer_table(
+            &self.state,
+            &self.request,
+            &self.request.tables[0],
+            0,
+            &DatabaseType::Postgres,
+            &DatabaseType::Postgres,
+            &self.source_pool_key,
+            &self.target_pool_key,
+            &std::collections::HashMap::new(),
+            &mut Vec::new(),
+            Some(backups),
+            |_| {},
+        )
+        .await
+    }
+
+    async fn drop_backups(&self, backups: &std::collections::HashMap<String, String>) -> Result<(), String> {
+        drop_backup_tables(
+            &self.state,
+            &self.request,
+            DatabaseType::Postgres,
+            &self.target_pool_key,
+            backups,
+            &self.request.tables,
+        )
+        .await
+    }
+
+    async fn cleanup(&self) {
+        postgres::execute_query(&self.source_pool, &format!("DROP SCHEMA {} CASCADE", self.request.source_schema))
+            .await
+            .unwrap();
+        postgres::execute_query(&self.target_pool, &format!("DROP SCHEMA {} CASCADE", self.request.target_schema))
+            .await
+            .unwrap();
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires disposable PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"]
+async fn live_postgres_transfer_rebuilds_same_named_serial_sequence() {
+    let fixture = PostgresRebuildFixture::new("serial_rebuild", &["orders"]).await;
+    let source_schema = &fixture.request.source_schema;
+    let target_schema = &fixture.request.target_schema;
+    postgres::execute_batch(
+        &fixture.source_pool,
+        &[
+            format!("CREATE TABLE {source_schema}.orders (id SERIAL PRIMARY KEY, name TEXT NOT NULL)"),
+            format!("INSERT INTO {source_schema}.orders (id, name) VALUES (42, 'source')"),
+        ],
+    )
+    .await
+    .unwrap();
+    postgres::execute_batch(
+        &fixture.target_pool,
+        &[
+            format!("CREATE TABLE {target_schema}.orders (id SERIAL PRIMARY KEY, name TEXT NOT NULL)"),
+            format!("INSERT INTO {target_schema}.orders (id, name) VALUES (99, 'old target')"),
+        ],
+    )
+    .await
+    .unwrap();
+
+    let result = async {
+        let backups = fixture.rename().await?;
+        let backup = backups.get("orders").expect("original target must have a backup");
+        assert_eq!(fixture.transfer(&backups).await?, 1);
+        assert_eq!(
+            query_text(&fixture.target_pool, &format!("SELECT name FROM {target_schema}.{backup} WHERE id = 99")).await,
+            "old target",
+            "original data remains recoverable until successful cleanup"
+        );
+        let new_sequence =
+            query_text(&fixture.target_pool, &format!("SELECT pg_get_serial_sequence('{target_schema}.orders', 'id')"))
+                .await;
+        let old_sequence = query_text(
+            &fixture.target_pool,
+            &format!("SELECT pg_get_serial_sequence('{target_schema}.{backup}', 'id')"),
+        )
+        .await;
+        assert!(!new_sequence.is_empty() && !old_sequence.is_empty());
+        assert_ne!(new_sequence, old_sequence, "new table and backup must own independent sequences");
+
+        fixture.drop_backups(&backups).await?;
+        assert_eq!(
+            query_scalar(
+                &fixture.target_pool,
+                &format!("INSERT INTO {target_schema}.orders (name) VALUES ('after rebuild') RETURNING id")
+            )
+            .await,
+            json!(43),
+            "dropping the backup must preserve the rebuilt sequence, synchronized to transferred data"
+        );
+        assert_eq!(
+            query_text(&fixture.target_pool, &format!("SELECT name FROM {target_schema}.orders WHERE id=42")).await,
+            "source"
+        );
+        assert_eq!(
+            query_scalar(&fixture.target_pool, &format!("SELECT to_regclass('{old_sequence}')::text")).await,
+            serde_json::Value::Null,
+            "backup cleanup must also remove the old owned sequence"
+        );
+        Ok::<_, String>(())
+    }
+    .await;
+    fixture.cleanup().await;
+    result.unwrap();
+}
+
+#[tokio::test]
+#[ignore = "requires disposable PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"]
+async fn live_postgres_transfer_rebuilds_indexes_with_shared_long_prefix() {
+    let fixture = PostgresRebuildFixture::new("long_indexes", &["orders"]).await;
+    let source_schema = &fixture.request.source_schema;
+    let target_schema = &fixture.request.target_schema;
+    // Both identifiers fit PostgreSQL's 63-byte limit but share their first 46 bytes.
+    let index_a = format!("{}first", "i".repeat(46));
+    let index_b = format!("{}second", "i".repeat(46));
+    for (pool, schema, row) in [
+        (&fixture.source_pool, source_schema, "(1, 'source', 7)"),
+        (&fixture.target_pool, target_schema, "(99, 'old target', 9)"),
+    ] {
+        postgres::execute_batch(
+            pool,
+            &[
+                format!("CREATE TABLE {schema}.orders (id INT PRIMARY KEY, name TEXT NOT NULL, amount INT)"),
+                format!("CREATE INDEX {index_a} ON {schema}.orders (name)"),
+                format!("CREATE INDEX {index_b} ON {schema}.orders (amount)"),
+                format!("INSERT INTO {schema}.orders VALUES {row}"),
+            ],
+        )
+        .await
+        .unwrap();
+    }
+
+    let result = async {
+        let backups = fixture.rename().await?;
+        let backup = backups.get("orders").expect("original target must have a backup");
+        assert_eq!(fixture.transfer(&backups).await?, 1);
+        fixture.drop_backups(&backups).await?;
+        let indexes = postgres::execute_query(
+            &fixture.target_pool,
+            &format!(
+                "SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = '{target_schema}' \
+                 AND tablename = 'orders' AND indexname IN ('{index_a}', '{index_b}') ORDER BY indexname"
+            ),
+        )
+        .await?;
+        assert_eq!(indexes.rows.len(), 2, "both secondary indexes must survive rebuild; got {:?}", indexes.rows);
+        assert_eq!(indexes.rows[0][0], json!(index_a));
+        assert!(indexes.rows[0][1].as_str().unwrap().contains("(name)"));
+        assert_eq!(indexes.rows[1][0], json!(index_b));
+        assert!(indexes.rows[1][1].as_str().unwrap().contains("(amount)"));
+        assert_eq!(
+            query_text(&fixture.target_pool, &format!("SELECT name FROM {target_schema}.orders WHERE id=1")).await,
+            "source"
+        );
+        assert_eq!(
+            query_scalar(&fixture.target_pool, &format!("SELECT to_regclass('{target_schema}.{backup}')::text")).await,
+            serde_json::Value::Null,
+            "successful rebuild must remove the backup"
+        );
+        Ok::<_, String>(())
+    }
+    .await;
+    fixture.cleanup().await;
+    result.unwrap();
+}
+
+#[tokio::test]
+#[ignore = "requires disposable PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"]
+async fn live_postgres_transfer_rebuild_rejects_target_only_view_before_any_rename() {
+    let fixture = PostgresRebuildFixture::new("external_view", &["first_table", "orders"]).await;
+    let source_schema = &fixture.request.source_schema;
+    let target_schema = &fixture.request.target_schema;
+    for (pool, schema, row) in [
+        (&fixture.source_pool, source_schema, "(1, 'source')"),
+        (&fixture.target_pool, target_schema, "(99, 'old target')"),
+    ] {
+        postgres::execute_batch(
+            pool,
+            &[
+                format!("CREATE TABLE {schema}.first_table (id INT PRIMARY KEY, name TEXT NOT NULL)"),
+                format!("CREATE TABLE {schema}.orders (id INT PRIMARY KEY, name TEXT NOT NULL)"),
+                format!("INSERT INTO {schema}.first_table VALUES {row}"),
+                format!("INSERT INTO {schema}.orders VALUES {row}"),
+            ],
+        )
+        .await
+        .unwrap();
+    }
+    postgres::execute_query(
+        &fixture.target_pool,
+        &format!("CREATE VIEW {target_schema}.target_only_orders AS SELECT id, name FROM {target_schema}.orders"),
+    )
+    .await
+    .unwrap();
+    let catalog_snapshot_sql = format!(
+        "SELECT c.relname, c.oid::text, c.relkind::text FROM pg_class c \
+         JOIN pg_namespace n ON n.oid = c.relnamespace \
+         WHERE n.nspname = '{target_schema}' ORDER BY c.relname"
+    );
+    let before = postgres::execute_query(&fixture.target_pool, &catalog_snapshot_sql).await.unwrap().rows;
+    let result = fixture.rename().await;
+    let after = postgres::execute_query(&fixture.target_pool, &catalog_snapshot_sql).await.unwrap().rows;
+
+    // Collect observations before cleanup so even a missing preflight leaves no schemas behind.
+    let rows = postgres::execute_query(
+        &fixture.target_pool,
+        &format!(
+            "SELECT 'first_table', id, name FROM {target_schema}.first_table \
+             UNION ALL SELECT 'orders', id, name FROM {target_schema}.orders \
+             UNION ALL SELECT 'target_only_orders', id, name FROM {target_schema}.target_only_orders ORDER BY 1"
+        ),
+    )
+    .await;
+    fixture.cleanup().await;
+
+    let error = result.expect_err("target-only dependent view must reject the whole plan before any table rename");
+    assert!(error.contains("target_only_orders"), "preflight must identify the dependent view: {error}");
+    assert_eq!(after, before, "all original table, index and view identities must remain unchanged");
+    assert_eq!(
+        rows.unwrap().rows,
+        vec![
+            vec![json!("first_table"), json!(99), json!("old target")],
+            vec![json!("orders"), json!(99), json!("old target")],
+            vec![json!("target_only_orders"), json!(99), json!("old target")],
+        ],
+        "preflight rejection must preserve both selected tables and the target-only view's result"
+    );
+}
diff --git a/crates/dbx-core/tests/live_sqlserver_completion.rs b/crates/dbx-core/tests/live_sqlserver_completion.rs
index 8b3e3fecfd..36629e1a55 100644
--- a/crates/dbx-core/tests/live_sqlserver_completion.rs
+++ b/crates/dbx-core/tests/live_sqlserver_completion.rs
@@ -1379,6 +1379,8 @@ async fn live_sqlserver_transfer_table_skips_rowversion_insert_column() {
         target_catalog: None,
         tables: vec![source_table.clone()],
         create_table: true,
+        drop_target_before_create: false,
+        drop_target_confirmed: false,
         content: dbx_core::transfer::TransferContent::default(),
         objects: Vec::new(),
         mode: dbx_core::transfer::TransferMode::Append,
@@ -1398,6 +1400,7 @@ async fn live_sqlserver_transfer_table_skips_rowversion_insert_column() {
         &target_pool_key,
         &std::collections::HashMap::new(),
         &mut Vec::new(),
+        None,
         |_| {},
     )
     .await;
diff --git a/crates/dbx-core/tests/live_sqlserver_transfer.rs b/crates/dbx-core/tests/live_sqlserver_transfer.rs
new file mode 100644
index 0000000000..e3c64585bf
--- /dev/null
+++ b/crates/dbx-core/tests/live_sqlserver_transfer.rs
@@ -0,0 +1,284 @@
+use dbx_core::connection::AppState;
+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+use dbx_core::storage::Storage;
+use dbx_core::transfer::{
+    drop_backup_tables, rename_tables_to_backup, transfer_table, TransferContent, TransferMode,
+    TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,
+};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+fn live_sqlserver_config(id: &str, database: &str) -> ConnectionConfig {
+    ConnectionConfig {
+        docs_notes_path: None,
+        id: id.to_string(),
+        name: id.to_string(),
+        note: String::new(),
+        db_type: DatabaseType::SqlServer,
+        driver_profile: None,
+        driver_label: None,
+        url_params: None,
+        agent_java_options: Vec::new(),
+        host: std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
+        port: std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433),
+        username: std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string()),
+        password: std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD"),
+        database: Some(database.to_string()),
+        default_schema: None,
+        visible_databases: None,
+        visible_database_patterns: None,
+        visible_schemas: None,
+        attached_databases: Vec::new(),
+        init_script: None,
+        color: None,
+        transport_layers: Vec::new(),
+        connect_timeout_secs: 15,
+        query_timeout_secs: 30,
+        idle_timeout_secs: 60,
+        keepalive_interval_secs: 0,
+        ssl: false,
+        ca_cert_path: String::new(),
+        client_cert_path: String::new(),
+        client_key_path: String::new(),
+        sysdba: false,
+        oracle_connection_type: None,
+        connection_string: None,
+        redis_connection_mode: None,
+        redis_sentinel_master: String::new(),
+        redis_sentinel_nodes: String::new(),
+        redis_sentinel_username: String::new(),
+        redis_sentinel_password: String::new(),
+        redis_sentinel_tls: false,
+        redis_cluster_nodes: String::new(),
+        redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
+        redis_scan_page_size: None,
+        redis_database_aliases: Default::default(),
+        redis_key_templates: Vec::new(),
+        etcd_endpoints: String::new(),
+        gbase_server: String::new(),
+        informix_server: String::new(),
+        external_config: None,
+        jdbc_driver_class: None,
+        jdbc_driver_paths: Vec::new(),
+        one_time: false,
+        save_password: true,
+        read_only: false,
+        is_production: false,
+        production_databases: vec![],
+        show_system_schemas: false,
+        database_info: None,
+    }
+}
+
+async fn sqlserver_env() -> (String, u16, String, String) {
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    (host, port, user, password)
+}
+
+async fn sqlserver_connect(database: &str) -> dbx_core::db::sqlserver::SqlServerClient {
+    let (host, port, user, password) = sqlserver_env().await;
+    dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(database), None, Duration::from_secs(20))
+        .await
+        .expect("connect SQL Server")
+}
+
+/// Whether a schema-scoped object with `name` still exists on `table`.
+async fn sqlserver_object_on_table_exists(
+    client: &mut dbx_core::db::sqlserver::SqlServerClient,
+    table: &str,
+    name: &str,
+) -> bool {
+    let sql = format!(
+        "SELECT CASE WHEN EXISTS ( \
+            SELECT 1 FROM sys.objects o WHERE o.name = N'{name}' AND o.parent_object_id = OBJECT_ID(N'dbo.{table}') \
+            UNION ALL \
+            SELECT 1 FROM sys.indexes i WHERE i.name = N'{name}' AND i.object_id = OBJECT_ID(N'dbo.{table}') \
+         ) THEN 1 ELSE 0 END",
+        name = name.replace('\'', "''"),
+        table = table.replace('\'', "''"),
+    );
+    let result = dbx_core::db::sqlserver::execute_query(client, &sql).await.expect("query object existence");
+    result.rows.first().and_then(|row| row.first()).and_then(|v| v.as_i64()).map(|n| n == 1).unwrap_or(false)
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
+async fn live_sqlserver_transfer_rebuild_releases_constraint_and_index_names() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let source_db = format!("dbx_rebuild_src_{}", &suffix[..12]);
+    let target_db = format!("dbx_rebuild_dst_{}", &suffix[..12]);
+    let connection_id = format!("live-sqlserver-rebuild-{suffix}");
+
+    // Create both databases and populate source + target with same-named constraints.
+    let mut master = sqlserver_connect("master").await;
+    dbx_core::db::sqlserver::execute_batch(
+        &mut master,
+        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
+    )
+    .await
+    .expect("create rebuild databases");
+
+    let mut source_client = sqlserver_connect(&source_db).await;
+    dbx_core::db::sqlserver::execute_batch(
+        &mut source_client,
+        "CREATE TABLE dbo.departments (id INT NOT NULL CONSTRAINT PK_departments PRIMARY KEY, name NVARCHAR(32)); \
+         CREATE TABLE dbo.employees (id INT NOT NULL CONSTRAINT PK_employees PRIMARY KEY, dept_id INT NULL, \
+             CONSTRAINT FK_emp_dept FOREIGN KEY (dept_id) REFERENCES dbo.departments(id)); \
+         CREATE INDEX IX_emp_dept ON dbo.employees(dept_id); \
+         INSERT INTO dbo.departments VALUES (10, N'Engineering'), (20, N'Sales'); \
+         INSERT INTO dbo.employees VALUES (1, 10), (2, 20);",
+    )
+    .await
+    .expect("create source tables");
+
+    let mut target_client = sqlserver_connect(&target_db).await;
+    dbx_core::db::sqlserver::execute_batch(
+        &mut target_client,
+        "CREATE TABLE dbo.departments (id INT NOT NULL CONSTRAINT PK_departments PRIMARY KEY, name NVARCHAR(32)); \
+         CREATE TABLE dbo.employees (id INT NOT NULL CONSTRAINT PK_employees PRIMARY KEY, dept_id INT NULL, \
+             CONSTRAINT FK_emp_dept FOREIGN KEY (dept_id) REFERENCES dbo.departments(id)); \
+         CREATE INDEX IX_emp_dept ON dbo.employees(dept_id); \
+         INSERT INTO dbo.departments VALUES (99, N'Stale'); \
+         INSERT INTO dbo.employees VALUES (98, 99);",
+    )
+    .await
+    .expect("create target tables");
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-rebuild-{suffix}"));
+    std::fs::create_dir_all(&dir).expect("create rebuild directory");
+    let storage = Storage::open(&dir.join("storage.db")).await.expect("open rebuild storage");
+    let state = Arc::new(AppState::new(storage));
+    let config = live_sqlserver_config(&connection_id, &source_db);
+    state.configs.write().await.insert(connection_id.clone(), config);
+    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_db)).await.expect("source pool");
+    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_db)).await.expect("target pool");
+
+    let request = TransferRequest {
+        transfer_id: format!("live-sqlserver-rebuild-{suffix}"),
+        source_connection_id: connection_id.clone(),
+        source_database: source_db.clone(),
+        source_schema: "dbo".to_string(),
+        source_catalog: None,
+        target_connection_id: connection_id.clone(),
+        target_database: target_db.clone(),
+        target_schema: "dbo".to_string(),
+        target_catalog: None,
+        tables: vec!["departments".to_string(), "employees".to_string()],
+        create_table: true,
+        drop_target_before_create: true,
+        drop_target_confirmed: true,
+        content: TransferContent::default(),
+        objects: Vec::new(),
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        quote_target_column_names: true,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 10,
+    };
+
+    let test_result = async {
+        let backup_names = rename_tables_to_backup(
+            &state,
+            &request,
+            &request.tables,
+            DatabaseType::SqlServer,
+            &target_pool_key,
+            |_| {},
+        )
+        .await?;
+        assert_eq!(backup_names.len(), 2, "both preexisting targets must be backed up");
+
+        // The pre-pass must have released every schema-unique constraint and index name
+        // so the rebuilt tables can reuse the source DDL's names without colliding.
+        for (table, name) in [
+            ("departments", "PK_departments"),
+            ("employees", "PK_employees"),
+            ("employees", "FK_emp_dept"),
+            ("employees", "IX_emp_dept"),
+        ] {
+            assert!(
+                !sqlserver_object_on_table_exists(&mut target_client, table, name).await,
+                "{name} on {table} must have been released before rebuild"
+            );
+        }
+
+        let mut pending_fk_alters: Vec<(String, String)> = Vec::new();
+        for (i, table) in request.tables.iter().enumerate() {
+            transfer_table(
+                &state,
+                &request,
+                table,
+                i,
+                &DatabaseType::SqlServer,
+                &DatabaseType::SqlServer,
+                &source_pool_key,
+                &target_pool_key,
+                &HashMap::new(),
+                &mut pending_fk_alters,
+                Some(&backup_names),
+                |_| {},
+            )
+            .await?;
+        }
+
+        // The rebuilt tables must have reclaimed the FK and index names — the names that
+        // would otherwise collide with the backups. Primary keys are regenerated inline by
+        // the source DDL (SQL Server auto-names them), so only their presence matters.
+        for (table, name) in [("employees", "FK_emp_dept"), ("employees", "IX_emp_dept")] {
+            assert!(
+                sqlserver_object_on_table_exists(&mut target_client, table, name).await,
+                "{name} on {table} must be rebuilt"
+            );
+        }
+        for table in ["departments", "employees"] {
+            let pk = dbx_core::db::sqlserver::execute_query(
+                &mut target_client,
+                &format!(
+                    "SELECT COUNT(*) FROM sys.key_constraints WHERE parent_object_id = OBJECT_ID('dbo.{table}') AND type = 'PK'"
+                ),
+            )
+            .await
+            .expect("count primary key");
+            assert_eq!(
+                pk.rows.first().and_then(|r| r.first()).and_then(|v| v.as_i64()),
+                Some(1),
+                "{table} must have a primary key"
+            );
+        }
+
+        // Stale target rows replaced by source data.
+        let count = dbx_core::db::sqlserver::execute_query(
+            &mut target_client,
+            "SELECT CAST(COUNT(*) AS INT) FROM dbo.departments WHERE id IN (10,20)",
+        )
+        .await
+        .expect("count rebuilt departments");
+        assert_eq!(count.rows.first().and_then(|r| r.first()).and_then(|v| v.as_i64()), Some(2));
+
+        // The rebuilt foreign key must still reject an orphan reference.
+        let orphan = dbx_core::db::sqlserver::execute_query(&mut target_client, "INSERT INTO dbo.employees VALUES (7, 999)").await;
+        assert!(orphan.is_err(), "rebuilt FK must reject a missing referenced department");
+
+        drop_backup_tables(&state, &request, DatabaseType::SqlServer, &target_pool_key, &backup_names, &request.tables).await?;
+        Ok::<_, String>(())
+    }
+    .await;
+
+    // SQL Server refuses to drop a database with active connections (code 3702); the
+    // state pools and setup clients still hold some. Force them all off first.
+    let cleanup = dbx_core::db::sqlserver::execute_batch(
+        &mut master,
+        &format!(
+            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
+             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
+        ),
+    )
+    .await;
+    let _ = std::fs::remove_dir_all(dir);
+    cleanup.expect("drop rebuild databases");
+    test_result.unwrap();
+}
diff --git a/crates/dbx-web/src/routes/transfer.rs b/crates/dbx-web/src/routes/transfer.rs
index b17486e953..ce2ea4fe4b 100644
--- a/crates/dbx-web/src/routes/transfer.rs
+++ b/crates/dbx-web/src/routes/transfer.rs
@@ -88,6 +88,23 @@ pub async fn start_transfer(
         )));
     }
 
+    // `drop_target_before_create` rebuilds target tables. Gate it before responding so the
+    // caller sees the error code rather than a progress stream that fails later.
+    if req.drop_target_before_create {
+        let target_db_type =
+            transfer::get_db_type(&state.app, &req.target_connection_id).await.map_err(AppError::from)?;
+        dbx_core::transfer_rebuild::ensure_drop_target_allowed(
+            &state.app,
+            &req.target_connection_id,
+            &req.target_database,
+            target_db_type,
+            req.drop_target_before_create,
+            req.drop_target_confirmed,
+        )
+        .await
+        .map_err(AppError::from)?;
+    }
+
     let transfer_id = req.transfer_id.clone();
 
     // Keep bounded replay state so a web EventSource opened after this POST
@@ -202,6 +219,82 @@ pub async fn start_transfer(
         let mut failed_tables: Vec<String> = Vec::new();
         let mut pending_fk_alters: Vec<(String, String)> = Vec::new();
 
+        // When drop_target_before_create is true, perform a rename pre-pass in
+        // parents_first=false order (children first) so that foreign keys on the
+        // backup tables remain intact. The main create/insert pass then runs in
+        // parents_first=true order (parents first).
+        // Children-first order used by the rename pre-pass, kept for the post-loop backup
+        // cleanup: a backup can still be referenced by another backup, so the drops must
+        // follow the same order.
+        let mut backup_drop_order: Vec<String> = Vec::new();
+        let backup_names = if req.drop_target_before_create {
+            // Re-sort tables in children-first order for the rename pre-pass
+            let (tables_for_rename, _) = transfer::sort_tables_by_fk_dependency_with_foreign_keys(
+                &app,
+                &req.target_connection_id,
+                &req.target_database,
+                &req.target_schema,
+                &tables,
+                false, // parents_first=false: children first
+            )
+            .await
+            .unwrap_or_else(|e| {
+                log::warn!("[transfer] failed to sort tables for rename pre-pass, using original order: {e}");
+                (tables.clone(), std::collections::HashMap::new())
+            });
+            backup_drop_order = tables_for_rename.clone();
+
+            let progress_channel_clone = progress_channel.clone();
+            match transfer::rename_tables_to_backup(
+                &app,
+                &req,
+                &tables_for_rename,
+                target_db_type,
+                &target_pool_key,
+                |progress| {
+                    send_transfer_progress(&progress_channel_clone, &progress);
+                },
+            )
+            .await
+            {
+                Ok(names) => Some(names),
+                Err(e) if e == "Cancelled" => {
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: "rename pre-pass".to_string(),
+                        table_index: 0,
+                        total_tables: tables.len(),
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Cancelled,
+                        error: None,
+                        terminal: true,
+                    };
+                    send_transfer_progress(&progress_channel, &progress);
+                    finish_transfer_channel(&state_clone, &req.transfer_id, &progress_channel).await;
+                    return;
+                }
+                Err(e) => {
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: "rename pre-pass".to_string(),
+                        table_index: 0,
+                        total_tables: tables.len(),
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Error,
+                        error: Some(e),
+                        terminal: true,
+                    };
+                    send_transfer_progress(&progress_channel, &progress);
+                    finish_transfer_channel(&state_clone, &req.transfer_id, &progress_channel).await;
+                    return;
+                }
+            }
+        } else {
+            None
+        };
+
         if matches!(source_db_type, dbx_core::models::connection::DatabaseType::Postgres)
             && matches!(target_db_type, dbx_core::models::connection::DatabaseType::Postgres)
         {
@@ -285,6 +378,7 @@ pub async fn start_transfer(
                 &target_pool_key,
                 &known_foreign_keys,
                 &mut pending_fk_alters,
+                backup_names.as_ref(),
                 |progress| {
                     last_rows_transferred = progress.rows_transferred;
                     last_total_rows = progress.total_rows;
@@ -345,7 +439,9 @@ pub async fn start_transfer(
         // Add any foreign keys deferred during MySQL-family table creation now that
         // every selected table exists — see transfer_table's use of
         // strip_inline_foreign_key_constraint_lines for why these can't be created
-        // inline (a foreign key cycle has no valid CREATE TABLE order at all).
+        // inline (a foreign key cycle has no valid CREATE TABLE order at all). The
+        // rename pre-pass already freed the backup constraint names, so these re-create
+        // the original names without colliding.
         let mut failed_fk_tables: Vec<String> = Vec::new();
         let mut failed_fk_count = 0usize;
         for (table, alter_sql) in &pending_fk_alters {
@@ -413,6 +509,33 @@ pub async fn start_transfer(
         if !object_outcome.failed.is_empty() {
             failed_tables.push(format!("schema objects ({})", object_outcome.failed.len()));
         }
+
+        // The rename pre-pass left one backup per rebuilt table. Drop them only now that
+        // every table, every deferred foreign key and every selected schema object has
+        // succeeded — a failure anywhere above keeps the originals recoverable under
+        // their backup names.
+        if let Some(backup_names) = backup_names.as_ref() {
+            if failed_tables.is_empty() {
+                if let Err(e) = transfer::drop_backup_tables(
+                    &app,
+                    &req,
+                    target_db_type,
+                    &target_pool_key,
+                    backup_names,
+                    &backup_drop_order,
+                )
+                .await
+                {
+                    failed_tables.push(e);
+                }
+            } else {
+                log::warn!(
+                    "[transfer] keeping {} backup table(s) because {} step(s) failed",
+                    backup_names.len(),
+                    failed_tables.len()
+                );
+            }
+        }
         let skip_suffix = if !object_outcome.skipped.is_empty() && failed_tables.is_empty() {
             format!("，跳过 {} 个已存在对象", object_outcome.skipped.len())
         } else if !object_outcome.skipped.is_empty() {
@@ -634,6 +757,8 @@ mod tests {
             target_catalog: None,
             tables: Vec::new(),
             create_table: false,
+            drop_target_before_create: false,
+            drop_target_confirmed: false,
             content: TransferContent::DataOnly,
             objects: Vec::new(),
             mode: TransferMode::Append,
diff --git a/docs/content/docs/data-transfer.cn.mdx b/docs/content/docs/data-transfer.cn.mdx
index d3e22048a2..e9427c418b 100644
--- a/docs/content/docs/data-transfer.cn.mdx
+++ b/docs/content/docs/data-transfer.cn.mdx
@@ -61,6 +61,7 @@ description: 在不同连接、数据库、Schema 或数据库引擎之间批量
 | 选项 | 说明 |
 | --- | --- |
 | 创建目标表 | 目标表不存在时，根据源元数据和目标数据库能力生成表结构 |
+| 重建结构和数据 | 将现有目标表重命名为备份表（`__dbx_bak_` 前缀），从源结构重建，插入数据后删除备份。任一步骤失败则保留备份表以供手工恢复。生产数据库需二次确认。支持 MySQL、PostgreSQL、SQL Server、KingBase、GaussDB、OpenGauss、KWDB、GoldenDB、SQLite、DuckDB 和 Cloudflare D1。 |
 | 追加 | 保留目标表已有数据并插入源数据 |
 | 覆盖 | 在传输该表前清空目标表，再写入源数据 |
 | Upsert | 目标路径支持且能确定键时，按键更新或插入 |
@@ -69,6 +70,8 @@ description: 在不同连接、数据库、Schema 或数据库引擎之间批量
 
 如果关闭“创建目标表”，目标表必须已经存在且字段可兼容。即使开启建表，跨引擎 DDL 也可能因目标数据库不支持某些类型、默认值、约束或对象而需要人工调整。
 
+<Callout type="warn">**重建结构和数据**会替换现有目标表及其索引、触发器、约束、注释和对象权限为源结构。原表会先被重命名为备份表，传输成功后删除。任一步骤失败则保留备份表，可手工恢复。</Callout>
+
 ## PostgreSQL 结构和所有者
 
 PostgreSQL 到 PostgreSQL 且启用创建表时，DBX 会在能力允许时处理序列、索引、外键以及部分 Schema 级对象和依赖。若源对象所有者在目标实例中不存在，开始前会提示选择：
diff --git a/docs/content/docs/data-transfer.mdx b/docs/content/docs/data-transfer.mdx
index 36b523f582..f953a56dd2 100644
--- a/docs/content/docs/data-transfer.mdx
+++ b/docs/content/docs/data-transfer.mdx
@@ -61,6 +61,7 @@ After copying one or more tables in the object tree, paste them at a target loca
 | Option | Details |
 | --- | --- |
 | Create target tables | Generates target structure from source metadata when the table does not exist and the path supports it |
+| Rebuild structure and data | Renames existing target tables to backup (`__dbx_bak_` prefix), rebuilds from source structure, inserts data, then drops backup on success. Any failure preserves the backup table for manual recovery. Requires confirmation on production databases. Available for MySQL, PostgreSQL, SQL Server, KingBase, GaussDB, OpenGauss, KWDB, GoldenDB, SQLite, DuckDB, and Cloudflare D1. |
 | Append | Keeps existing target rows and inserts source rows |
 | Overwrite | Clears each target table before writing its source rows |
 | Upsert | Updates or inserts by key when the target path supports it and a usable key is available |
@@ -69,6 +70,8 @@ After copying one or more tables in the object tree, paste them at a target loca
 
 If table creation is disabled, compatible target tables must already exist. Even with table creation enabled, cross-engine DDL may require manual changes when the target does not support a source type, default, constraint, or object.
 
+<Callout type="warn">**Rebuild structure and data** replaces existing target tables and their indexes, triggers, constraints, comments, and object permissions with source structure. The original table is renamed to a backup first, then dropped after a successful transfer. If any step fails, the backup table is retained and can be manually restored.</Callout>
+
 ## PostgreSQL Structure and Ownership
 
 For PostgreSQL-to-PostgreSQL transfers with table creation enabled, DBX handles supported sequences, indexes, foreign keys, and selected schema-level objects and dependencies. If source owners do not exist on the target instance, DBX prompts you to:
diff --git a/docs/content/docs/production-safety.cn.mdx b/docs/content/docs/production-safety.cn.mdx
index e0cbda4c49..4c5b7cc1d3 100644
--- a/docs/content/docs/production-safety.cn.mdx
+++ b/docs/content/docs/production-safety.cn.mdx
@@ -84,6 +84,7 @@ MCP 和 CLI 没有确认界面，仍只读取已保存的只读标记，因此
 | 数据表格 | 在确认同一解锁窗口前禁用或拒绝保存、删除等修改 | 保存行、删除行等操作进入统一生产确认 |
 | 表结构与对象操作 | 在确认解锁窗口前隐藏或禁用可识别的修改入口 | DDL、对象源码保存、数据库管理等进入统一确认 |
 | Schema 对比、SQL 文件、数据生成 | 目标只读时不允许写入 | 执行生成 SQL 或脚本前进入统一确认 |
+| 数据传输 | 不能使用只读连接作为目标；生产数据库会阻止**先删除目标表再创建**操作 | 危险的表替换操作需要明确确认并显示 DROP SQL 预览 |
 | Redis、MongoDB、etcd、消息队列等 | 按系统命令和操作重新检查只读 | 写入入口继续受生产保护和专项危险操作规则约束 |
 | AI Ask | 不执行 SQL | 不执行 SQL |
 | AI Agent | 不能绕过只读 | 生产 SQL 返回编辑器，由用户检查并手动执行 |
diff --git a/docs/content/docs/production-safety.mdx b/docs/content/docs/production-safety.mdx
index 33c619c36e..12e75b603f 100644
--- a/docs/content/docs/production-safety.mdx
+++ b/docs/content/docs/production-safety.mdx
@@ -84,6 +84,7 @@ Every production write requires a new explicit decision. Confirmation is not per
 | Data grid | Disables or rejects saves, deletes, and other mutations until the same unlock window is confirmed | Row saves and deletes enter the shared production confirmation flow |
 | Table structure and object actions | Hides or disables recognizable mutation entry points until the unlock window is confirmed | DDL, source saves, and database administration enter the shared confirmation flow |
 | Schema diff, SQL files, and data generation | Cannot write to a read-only target | Generated SQL or scripts require production confirmation before execution |
+| Data Transfer | Cannot target a read-only connection; **Drop Target Before Create** is blocked on production databases | Dangerous table-replacement operations require explicit confirmation and show DROP SQL preview |
 | Redis, MongoDB, etcd, message queues, and similar systems | Rechecks read-only state for system-specific commands and actions | Mutation entry points remain subject to production and specialized danger rules |
 | AI Ask | Does not execute SQL | Does not execute SQL |
 | AI Agent | Cannot bypass read-only state | Returns production SQL to the editor for human review and manual execution |
diff --git a/docs/pips/plans/2026-09-03-transfer-drop-before-create.md b/docs/pips/plans/2026-09-03-transfer-drop-before-create.md
new file mode 100644
index 0000000000..56002edc0a
--- /dev/null
+++ b/docs/pips/plans/2026-09-03-transfer-drop-before-create.md
@@ -0,0 +1,400 @@
+# PIP: 数据传输「创建前删除目标表」
+
+## 状态
+
+Proposed（设计已确认，待实现）
+
+## 摘要
+
+为数据传输新增「创建前删除目标表」选项：勾选后，传输前先把目标表改名为备份表，按源结构重建，写入数据，全部成功后删除备份；任一步失败则保留备份并在错误中回报备份表全名。对齐 Navicat 的「创建前删除目标对象」。
+
+采用 rename-then-drop 而非直接 DROP，因为传输路径不开事务且多数方言 DDL 不可回滚，备份表是唯一可行的恢复手段。
+
+## 背景
+
+当前目标表已存在且结构与源不一致时，传输会 fail-fast，错误原文即：
+
+> DBX does not alter an existing target table's columns during transfer — drop the target table or adjust its structure to match the source first.
+
+见 `crates/dbx-core/src/transfer.rs:1633-1662`（`validate_preexisting_target_columns`）。用户必须离开传输对话框、手工删表、再回来重跑。本功能把这句提示自动化。
+
+`TransferMode`（`transfer.rs:71-78`）目前是 `Append | Overwrite | Upsert`，`Overwrite` 生成单条 `TRUNCATE TABLE`（`:7679-7690`，SQLite/CloudflareD1/DuckDb 用 `DELETE FROM`）。`create_table: bool`（`:189`）在 UI 上没有开关，由传输内容推导（`DataTransferDialog.vue:768`）。
+
+## 已确认的设计决策
+
+| # | 决策 | 选择 |
+|---|---|---|
+| 1 | 数据模型 | **独立布尔字段** `drop_target_before_create`，不新增 `TransferMode` 变体 |
+| 2 | 方言范围 | **首版覆盖 14 个标准库**，其余在 UI 禁用并提示暂不支持 |
+| 3 | 失败恢复 | **rename-then-drop** 备份策略 |
+| 4 | 架构落点 | **方案 4′**：`DdlDialectProfile` 只加数据字段，`build_drop_table_sql` 留在 `db_admin_sql.rs` 作为唯一渲染入口 |
+| 5 | 强确认 | **不要求手打库名**，仅 `DangerConfirmDialog` + 生产库闸门 |
+
+### 决策 1 的决定性理由
+
+写入方式 Select 在 `transferContent === 'structureOnly'` 时被 `v-if` 隐藏（`DataTransferDialog.vue:1248`），而「仅结构 + 先删除重建」恰是本功能最正当的用法。做成 Select 第四项会让主场景直接不可达。独立布尔另有三点收益：不污染 `TransferMode`（避免一个字段承担 DDL 与 DML 两个维度）；危险开关有稳定版面位置可挂常驻警告；`transfer.rs:3836`/`:3838`/`:4233` 三处 match 与 `:12475`/`:12575` 两处 `for mode in [...]` 测试遍历全部无需改动。
+
+### 决策 2 的覆盖清单
+
+**启用（14 个）**：mysql、postgres、oracle、sqlserver、dameng、oceanbase-oracle、kingbase、gaussdb、opengauss、kwdb、goldendb、sqlite、duckdb、cloudflare-d1
+
+**禁用并提示暂不支持（10 个，均为 `dataTransfer: true` 但 DROP 语义高危或不适用）**：
+
+| 库 | 禁用原因 |
+|---|---|
+| mongodb | 无表概念。现有 Overwrite 走 `deleteMany({})`（`transfer.rs:4802-4811`）而非 drop collection；真 drop 会丢索引 / validator / shard key |
+| clickhouse | `can_reuse_source_table_ddl` 对其返回 false（断言 `transfer.rs:10663`），重建必丢 ENGINE / ORDER BY / 分区 / TTL |
+| hive、spark、kyuubi、impala、argo | managed（非 EXTERNAL）表 DROP 会连带删除仓库目录中的数据文件，删除范围溢出用户勾选的表清单 |
+| questdb | 丢 designated timestamp / partition by |
+| turso、rqlite | 见「顺带修复」——先修既有 TRUNCATE 分支遗漏再评估 |
+
+## 可行性依据（已有资产）
+
+drop-then-create 在 `transfer.rs` 内已是既定模式，仅未用于表对象：
+
+| 资产 | 位置 | 说明 |
+|---|---|---|
+| 物化视图 drop-then-create | `transfer.rs:2463-2469` | `generate_postgres_materialized_view_ddls` 返回 `vec![DROP, CREATE]` |
+| 触发器 drop-then-create | `transfer.rs:8323-8350` | 进度按两步计数（`:8192` `trigger_step_count = len * 2`） |
+| RLS policy drop-then-create | `transfer.rs:6421-6432` | `sort_order` 保证顺序 |
+| MySQL routine drop-then-create | `object_source_sql.rs:565-588` | `mysql_drop_routine_if_exists` |
+| **子表优先拓扑排序** | `transfer.rs:6790-6859` | Kahn 算法带 `parents_first: bool`；`false` 分支注释明确写明用于 batch drop，已作为 Tauri command 暴露（`src-tauri/src/commands/transfer.rs:418-428`） |
+| **表改名生成器** | `db_admin_sql.rs:872-928` | `build_rename_object_sql` + `supports_object_rename:840-869`，**14 库中 13 个已支持** |
+| 跨方言 DROP 生成器 | `db_admin_sql.rs:411-430` | `build_drop_table_sql`（不生成 `IF EXISTS`；CASCADE 白名单仅 9 个 PG 系，`:432-447`） |
+| SQL Server 条件删除解法 | `schema_diff.rs:3691-3702` | `IF OBJECT_ID(N'..', N'U') IS NOT NULL DROP TABLE` |
+| 带 IF EXISTS 的 DROP | `database_export.rs:3379-3381` | 复用 `crate::transfer::qualified_table` |
+| 同类选项全栈先例 | `database_export.rs:65` → `tauri.ts:4804` → `DatabaseExportDialog.vue:871-874` | `drop_table_if_exists`，命名与产品语义可对齐 |
+| 标识符长度上限常量 | `descriptor.rs:161` | MySQL 64 / PG 63 / SQL Server 128 / **Oracle 30**；目前**零校验消费者** |
+| 备份名派生 + 冲突预检范式 | `sqlite_rebuild.rs:493-511` | schema 内容 SHA256 派生（幂等）；冲突即报错，不自动清理不重试换名 |
+| 清理失败处理范式 | `table_import.rs:5675-5700` | staging 清理失败视为连接状态污染，直接作废池 |
+| 生产库谓词 | `production_safety.rs:111` / `:197` | `DDL_OBJECT_TARGET_RE` 已覆盖 `DROP TABLE [IF EXISTS]`，解析不出目标时 fail-closed |
+| 前端生产闸门 | `productionExecutionGuard.ts:15-63` | 已有 20+ 调用点，transfer 链路零接入 |
+| 危险操作 UI 骨架 | `useSidebarTableMutationRuntime.ts:100-111` / `:459-497` | 先生成 SQL 预览再弹窗 |
+| 强确认组件 | `DangerConfirmDialog.vue:29-60` | 含 `confirmDisabled` / `showSuppressToggle` / `details` |
+
+## 已排除的方案（含前期判断纠正）
+
+### 排除：PG 家族包显式事务以获得原子性
+
+`execute_on_pool`（`transfer.rs:5097-5098`）每次调用都重新 checkout 连接 —— MySQL 走 sqlx 池、PG 系走 deadpool。`BEGIN` 与后续语句会落在不同连接上，`BEGIN` 随连接归还立即回滚，**给出虚假的原子性错觉，比没有事务更危险**。
+
+旁证：MySQL 的 `lock_timeout_sql`（`ddl_profile.rs:351` `SET SESSION lock_wait_timeout = 3;`）在这条路径上本来就是失效的。
+
+Oracle / Dameng / Kingbase（`PoolKind::Agent`，单 client + Mutex + 固定 `agent_session_id`）与 SQL Server（`Arc<Mutex<SqlServerClient>>`）侥幸同会话，但这是实现巧合非契约 —— `PoolErrorAction::ReconnectAndRetry`（`transfer.rs:5060-5081`）会在错误时重建池并换 `pool_key`。
+
+### 纠正：rename-then-drop 不需要同会话
+
+前期误判「多步操作无法保证同会话」会阻塞决策 3。前提事实成立，但推论错误：rename-then-drop 的价值是**可恢复性**而非原子性，每步独立提交恰恰是它能工作的原因。逐失败点见「关键设计 · 失败点状态矩阵」。**无需新增「持连接执行多语句」入口。**
+
+### 排除：激活 `plugins/dialects/*.yaml` 的 drop_table 模板（原决策 4 方案 B）
+
+yaml 里确实已有 `ddl_capabilities.templates.drop_table`（`mysql.yaml:116`、`oracle.yaml:109`）、`online_safety.drop_table`、`destruction_level.drop_table: "FATAL"`，且全部零消费。但缺的不是接线，是整条通路，有三个结构性障碍加一个既有 bug：
+
+1. **`to_descriptor` 根本不读模板**（`dialect_yaml.rs:637-694` 只映射 33 个 bool + `max_length` + `structural_capabilities`）。`templates` / `rollback_templates` / `online_safety` / `destruction_level` 只走「解析 → 存进 `LoadedDialect.yaml` → 回写」的往返。
+2. **类型不兼容**：profile 字段是 `Option<&'static str>` 且 struct 是 `Copy`（`ddl_profile.rs:99`），yaml 给 `String`。放弃 `Copy` 会波及全部 `profile_for` 调用点（`script_generator.rs` 四处、`schema_diff.rs` 十处、`type_rewrite.rs:315`、`db_admin_sql.rs:1101`）。
+3. **键空间不匹配**：profile 按 `DatabaseType`（80+ 变体），registry 按 `DialectKind`（11 个）。`dameng.yaml` / `kingbase.yaml` / `goldendb.yaml` / `oceanbase.yaml` 的模板永远取不到。
+4. **既有 bug**：注册键 = `lowercase(yaml.dialect.name)`（`build.rs:63` + `dialect_loader.rs:117`），查找键 = `kind.label()`（`sql_dialect.rs:73`）。`"PostgreSQL"→"postgresql"` vs `"postgres"`、`"SQL Server"→"sql server"` vs `"sqlserver"` 两处 miss，**postgres 与 sqlserver 一直走硬编码回落**。目前不可见（yaml 与硬编码对 `transactional_ddl` 恰好同值），但意味着任何新增 yaml 字段对这两库都不生效。
+
+改为方案 4′（见阶段 1）。原方案值得单独一个 PIP，约 4-5 人日，回归风险集中在已上线的侧边栏删表与批量删除路径。
+
+## 实现路径
+
+### 阶段 1：方言底座（方案 4′）
+
+**任务 1.1 — `DdlDialectProfile` 新增四个数据字段**
+
+在 `crates/dbx-core/src/sql_dialect/ddl_profile.rs` 的 `DdlDialectProfile`（`:99-167`）新增：
+
+- `drop_table_template: Option<&'static str>`（占位符 `{table}` / `{cascade}`，与既有 `FN_DROP:209` / `SEQ_DROP:214` 同风格）
+- `drop_table_supports_cascade: bool`
+- `drop_table_supports_if_exists: bool`
+- `rename_table_syntax: RenameTableSyntax`（新枚举，参照既有 `RenameColumnSyntax:70-79`）
+
+全部为 `Copy` 兼容类型，不破坏 struct 的 `Copy` 派生。渲染沿用 `render_template`（`:199-205`，纯 `String::replace`，**调用方必须自己先 `quote_ident`**）。
+
+覆盖 6 个 family 构造函数 + `conservative_ansi`：`mysql_family:311`、`postgres_family:356`、`oracle_family:401`、`sqlserver_family:447`、`sqlite_family:492`、`conservative_ansi:627`（⚠️ **DuckDB 落在 `conservative_ansi`（`profile_for:710`），不在 sqlite family**，`create_table_if_not_exists=false`、`type_map` 为空）。
+
+**任务 1.2 — `build_drop_table_sql` 改为读 profile**
+
+`db_admin_sql.rs:411-430` 保持为唯一渲染入口，内部改为读 profile 字段替代硬编码。`supports_drop_table_cascade`（`:432-447`）改为读 `profile.drop_table_supports_cascade`，同时同步前端复制的白名单 `dbAdminSql.ts:322`（两处逐项一致，漏改会导致前端预览 SQL 与后端生成 SQL 分叉）。
+
+**为什么不把函数整体搬进 profile**：`qualified_name_with_quote`（`:1078-1093`，私有）存在的唯一理由是 Cloud Spanner 双方言 —— 连接上报的 `identifier_quote` 必须覆盖静态映射，而 `DdlDialectProfile::quote_ident`（`:174-196`）只认静态 `QuoteStyle`。整体搬迁会撕裂 `identifier_quote` 语义、迫使私有 helper 跨模块提升可见性、让 `supports_drop_table_cascade` 与姊妹函数 `supports_truncate_table_cascade` 分居两处、并让 IoTDB（`DELETE TIMESERIES`）/ InfluxDB（`DROP MEASUREMENT`）特判（`:418-422`）失去归属。
+
+**必须先定真源**：`oracle.yaml:109` 的模板是 `DROP TABLE {table} CASCADE CONSTRAINTS`，而 `supports_drop_table_cascade` 白名单**不含 Oracle**。三个 Oracle 系 yaml 之间也不一致（`dameng.yaml:101` 是 `IF EXISTS`），只因都被 `oracle.yaml` 覆盖才未暴露。本 PIP 以 Rust 侧现状为真源（Oracle 无 CASCADE），yaml 差异记为技术债。
+
+- 验收：单测挂 `db_admin_sql.rs:1573-1594` 现有 `builds_drop_and_clear_table_sql` 旁；覆盖 6 个 family + DuckDB；**Rust 生产调用方仅 2 个**（`src-tauri/src/commands/query.rs:632-635`、`crates/dbx-web/src/routes/query.rs:904-906`），签名不变故零改动
+- 工作量：1 人日
+
+**任务 1.3 — `TransferRequest` 新增字段与校验**
+
+`transfer.rs:176-203` 新增 `#[serde(default)] pub drop_target_before_create: bool`（紧邻 `create_table:189`）。`validate_transfer_request`（`:727-743`）拒绝 `drop_target_before_create && content == DataOnly`（措辞参照 `table_import.rs:5925-5935` 拒绝 `create_table` + `Truncate` 的先例）。
+
+Tauri 与 Web 共用 `dbx_core::transfer::TransferRequest`，一次改动双向生效。`crates/dbx-web/src/routes/transfer.rs:623-660` 的 fixture 需补字段。
+
+- 验收：`#[serde(default)]` 保证旧任务反序列化不破；校验单测挂 `transfer.rs:8745` `transfer_validation_tests`
+- 工作量：0.5 人日
+
+**任务 1.4 — 补 oceanbase-oracle 的 rename 支持**
+
+`is_oracle_like_rename`（`db_admin_sql.rs:1009-1012`）只列 `Oracle | Dameng | Oscar`，不含 `OceanbaseOracle`，导致 `supports_object_rename` 返回 false、`build_rename_object_sql` 直接返回 `Err`。补一个变体 + 单测（`:2433-2620` 已覆盖 mysql/sqlite/duckdb/postgres/sqlserver/oracle/dameng/oscar）。
+
+- 工作量：0.25 人日
+
+**任务 1.5 — 备份表名生成器（新增）**
+
+读 `descriptor.rs:161 max_identifier_length`（目前零校验消费者），实现「截断 + 短哈希」。`{table}__dbx_bak` 比原名长 13 字符，Oracle 上限 30 意味着原名超过 17 字符即溢出。派生思路参照 `sqlite_rebuild.rs:493-496`（内容哈希，幂等），冲突预检参照 `:498-511`（命中即报错，不自动清理不重试换名）。
+
+- 验收：Oracle（30）/ PG（63）/ MySQL（64）/ SQL Server（128）四个边界各一条单测；长表名不溢出且不同源表不碰撞
+- 工作量：0.75 人日
+
+**任务 1.6 — 接入生产库闸门（传输链路首次）**
+
+在 `src-tauri/src/commands/transfer.rs:26`（`ensure_connection_writable` 旁）与 `crates/dbx-web/src/routes/transfer.rs:81-89`（只读拒绝旁）新增：`drop_target_before_create && is_production_database(...)` 时要求请求携带显式确认标记，否则返回可辨识错误码供前端弹确认框。
+
+- 工作量：0.5 人日
+
+### 阶段 2：传输编排与 rename-then-drop
+
+**任务 2.1 — 单表 rename → create 路径，并重置 `target_table_preexisting`**
+
+在建表主流程 `transfer.rs:7364-7592` 的 `:7376` `else` 分支之前插入 rename 备份。本模式下跳过 `validate_preexisting_target_columns`（`:7669-7677`，表即将改名，结构不匹配不再是问题）与 TRUNCATE 判定（`:7679-7690`，新表本就为空）。
+
+⚠️ **最容易漏的一处**：`:7318`（PG 索引抓取）、`:7331`（PG 外键抓取）、`:7595`（`should_restore_postgres_table_schema`）三处均门控在 `!target_table_preexisting` 上。rename 后**必须**把该标志置回 `false`，否则 `source_indexes` / `source_foreign_keys` 会是空 `Vec`，索引与外键**静默不重建**。
+
+- 验收：必须有 live 测试锁定「DROP 模式下 PG 索引与外键被重建」
+- 工作量：1 人日
+
+**任务 2.2 — 双趟编排**
+
+rename 顺序（子表先）与 create/insert 顺序（父表先）相反，但现有编排是单趟 per-table 循环、一张表内部完成建表加写数据。改为：`drop_target_before_create` 为真时先按 `parents_first=false`（`transfer.rs:6770`）全量 rename 一趟，再走现有 `parents_first=true` 循环。进度事件需覆盖 rename 阶段（参照 `:8192` 的两步计数）。
+
+⚠️ **Tauri（`src-tauri/src/commands/transfer.rs:160-253`）与 Web（`crates/dbx-web/src/routes/transfer.rs:277-340`）两处必须同步改**，否则 Web API 行为与桌面端分歧。取消（`is_cancelled`，`transfer.rs:6673`）在 rename 预趟中同样生效；成环的表由 `:6846-6856` 追加到末尾而非报错，此行为保留。
+
+- 工作量：1.5 人日（**架构风险集中点**，建议先跑通「无外键多表」再进 2.3）
+
+**任务 2.3 — 外键处理**
+
+传输路径当前对 DROP 被 FK 阻塞**零处理**：无 `SET FOREIGN_KEY_CHECKS=0`（仅 `database_export.rs:2533`/`:3344` 写进导出文件且限 MySQL）；`session_replication_role` / `SET CONSTRAINTS` / `NOCHECK CONSTRAINT` 全仓零命中；`CASCADE` 在 `transfer.rs` 中不存在。
+
+**rename 相比直接 DROP 的关键差异（见「关键设计」）**：MySQL 的 `RENAME TABLE` 与 PG 的 `ALTER TABLE RENAME` 都会让**入向外键跟着走**，改名后其他表的 FK 指向备份表。这与直接 DROP（打断后重建）行为不同，必须显式处理。
+
+可复用的既有 FK 结构：`strip_inline_foreign_key_constraint_lines`（`:4970-4989`）、`supports_deferred_mysql_foreign_keys`（`:1831-1834`）、`generate_mysql_foreign_key_alter_statements`（`:2167-2232`）、`pending_fk_alters` 末尾统一执行（`src-tauri/src/commands/transfer.rs:259-272`）。会话开关的恢复参照 `transfer.rs:1703-1717` 的 `SET IDENTITY_INSERT ON/OFF` 双 result match 补偿模式（本文件唯一的补偿式清理先例）。
+
+⚠️ 注意会话状态不跨 `execute_on_pool` 保留（见「已排除的方案」），`SET FOREIGN_KEY_CHECKS=0` 在 MySQL 池上**不会生效**。MySQL 侧必须靠 rename 顺序（子表先）而非关闭 FK 检查。
+
+- 验收：live 测试覆盖「父子表」与「循环引用」两种拓扑在 MySQL 与 PG 上均能完成
+- 工作量：2 人日
+
+**任务 2.4 — 备份表生命周期**
+
+序列：rename 备份 → create 新表 → 写数据 → 全部成功后 `DROP TABLE {backup}`。任一步失败保留备份，错误信息回报备份表全名（文案风格参照 `sqlite_rebuild.rs:508-510`）。删备份失败的处理参照 `table_import.rs:5675-5700`：视为连接状态污染，合并错误串并作废池。
+
+- 工作量：1 人日
+
+### 阶段 3：前端选项与警示
+
+**任务 3.1 — 契约与类型**
+
+`apps/desktop/src/lib/backend/tauri.ts:4566-4585` 的 `TransferRequest` 新增 `dropTargetBeforeCreate: boolean`（紧邻 `createTable:4577`）；`types/database.ts:1438-1455` 的 `TransferTaskConfig` 同步。其余为 `import type` 自动跟随。
+
+⚠️ Rust serde camelCase 与 TS 类型**无任何编译期或 CI 校验**，需人工核对。
+
+- 工作量：0.25 人日
+
+**任务 3.2 — 复选框与联动数据流**
+
+**插入点**：`DataTransferDialog.vue` 的 `:1247`（传输内容 radio 组收尾 `</div>`）之后、`:1248`（写入方式 `<div v-if=...>`）之前。视觉顺序即依赖顺序。
+
+**形态**：原生 `<input type="checkbox">` + `accent-destructive`，包在 `<label>` 内（隐式关联），`pl-5` 缩进表示从属于「传输内容」。
+
+> 已核实：`DataTransferDialog.vue` 内**没有任何复选框**；手搓 `CheckSquare`/`Square` 是 `DatabaseExportDialog.vue` 的写法，该写法有 7 项 a11y 缺陷（完全无法键盘操作、无 role/state、无 name 关联、Space/Enter 无响应、disabled 仅视觉、未勾选态对比度低于 3:1、无焦点指示器）。本文件自身惯用原生 `<input type="radio">`（`:1233`/`:1237`/`:1242`），项目**不存在** shadcn Checkbox 组件。危险复选框范式见 `ObjectBrowser.vue:3785`、`ConnectionTree.vue:2777`。
+
+**数据流（关键，强于 watch 兜底）**：
+
+- `dropTargetBeforeCreateChecked`（ref）只喂 `v-model`，仅服务 UI
+- `canDropTargetBeforeCreate`（computed）= `transferContent !== 'dataOnly' && targetSupportsDropRecreate`
+- `dropTargetBeforeCreate`（computed）= `canDropTargetBeforeCreate && dropTargetBeforeCreateChecked` —— **这是 `TransferRequest` 与 `currentConfig()` 唯一的读取源**，不可达状态在结构上无法泄进请求体
+- 另加一个仅为视觉卫生的 watch（`[transferContent, targetConnectionId]` → 若已不可达则写 `false`）。只写 false，故**不需要** `skip*Watch` 标记
+
+> 反面教训：朴素的 reset watch 会破坏 `loadTaskIntoForm()` —— 它在 `:886` 先设 `transferContent` 再设 `transferMode`，这正是 `:442-451` 那批 `skip*Watch` 一次性标记存在的原因。
+
+**方言门控**：必须用 `effectiveDatabaseTypeForConnection`，**不能**用 `transferDatabaseTypeForConnection`（后者在 `jdbcDialect.ts:97` 会把 doris/starrocks 掩回 `mysql`）。禁用样式照 `DatabaseExportDialog.vue:871` 的 `cursor-not-allowed text-muted-foreground/50`——渲染但禁用，避免版面跳动并让用户看到原因。
+
+**顺带修两处现存缺陷**（各一行）：`:771` 改为 `structureOnly` 时不发送 `transferMode`；`:1222` 的琥珀横幅补 `dark:` 变体（现为 `bg-amber-50 text-amber-700`，暗色主题下浅底浅字；正确写法见 `TableImportDialog.vue:1521`）。
+
+⚠️ `__tests__/DataTransferDialog.spec.ts` 是**源码文本断言**测试：`:59-60` 逐字符 pin 住 `createTable: transferContent.value !== "dataOnly"`、`:12` pin 住 `DialogContent` 完整 class 串、`:23`/`:33-38` pin 住布局 class。触碰这些行必须同步改 spec。
+
+- 工作量：1 人日
+
+**任务 3.3 — 三层警示 + 确认链**
+
+**第一层**（常驻、刻意中性，`text-[11px] text-muted-foreground/70`，与 `contentStructureOnlyHint:1239` 同层级）：说明三步机制。对未勾选项挂红字只会训练用户忽略红字。
+
+**第二层**（勾选后出现，`role="alert"`，`border-destructive/30 bg-destructive/10 text-destructive` + `AlertTriangle`，来自 `@lucide/vue`）。**因采用 rename-then-drop，文案不再是「永久消失」**：
+
+> 目标表及其索引、触发器、约束、注释和对象权限会被替换为源结构。原表会先改名为备份表，传输成功后删除；任一步失败则保留备份，可手工恢复。
+
+行内最高级别且只有这一条。不加第三条横幅、不在勾选时弹 modal、不要求手打——勾选动作本身可逆，不配不可逆级别的摩擦。配色不加过渡动画（危险警示应瞬时呈现，与 `:1222`、`TableImportDialog.vue:1521` 一致）。
+
+**第三层**：`requestStartTransfer()`（`:1012-1015`）按 `dropTargetBeforeCreate` 分流——未勾选走原 `showStartConfirm`（`:1322`），已勾选走 `DangerConfirmDialog`。普通 append 传输不该看到红色弹窗，否则红色贬值。
+
+- **DROP SQL 预览**：照 `useSidebarTableMutationRuntime.ts:108-111` 的「先生成预览再弹窗」。价值最高的元素——它顺带回答「目标表名大小写」（`:1261`）改写后到底操作的是哪个名字。约束：`buildDropTableSql`（`dbAdminSql.ts:298`）是**每张表一次 IPC**，故只生成前 10 条 + 一行 `-- 其余 N 张表省略`（`DangerConfirmDialog` 自身另有 8192 字符 / 200 行截断，`:13-14`）；必须传 `detailsText`（`:149`）声明这是**示例**，实际 SQL 由 Rust 按目标方言生成
+- **生产闸门**：把 `:743-745` 的 `ensureReadOnlyWriteAccess` 升级为 `executeWithProductionContextGuard`（`productionExecutionGuard.ts:47-63`，其 `:48` 内部已含 `ensureReadOnlyWriteAccess`，unlock 在 `readOnlyUnlockStore` 中记忆化（`readOnlyWriteAccess.ts:60`），不会二次弹解锁框），`reviewText` 设为 DROP 预览
+- **不传 `showSuppressToggle`**（`DangerConfirmDialog.vue:38`）：已保存任务支持一键 Start，此弹窗是该路径唯一关卡
+
+⚠️ `DataTransferDialog.spec.ts:9-11` 断言「只有一个可 resize 的 `DialogContent`」，新弹窗**不能**带 `resize`。
+
+- 工作量：1.5 人日
+
+**任务 3.4 — 任务持久化闭环**
+
+`currentConfig()`（`:846-861`）、`loadTaskIntoForm()`（`:886-889`）、`resetState()`（`:644-648`）三处都要带上新字段；`configSnapshot` / `isConfigDirty` 因整对象 `JSON.stringify`（`:865-875`）自动生效。
+
+- 验收：旧任务（无该字段）加载后为 `false` 而非 `undefined`。照 `transferTaskStore.spec.ts:70`（「keeps target column quoting enabled for saved tasks created before the option existed」）风格补一条向后兼容测试
+- 工作量：0.5 人日
+
+### 阶段 4：测试与文档
+
+**任务 4.1 — 单元测试（最先写，无需真实库）**
+
+- DROP / rename SQL 生成的方言单测：挂 `db_admin_sql.rs:1573-1594`（DROP）与 `:2433-2620`（rename）
+- 备份名生成器的四个长度边界单测
+- `validate_transfer_request` 拒绝非法组合：挂 `transfer.rs:8745`
+- 建表流程单测：挂 `transfer.rs:9765` `transfer_content_mode_tests` 或新建 `transfer_drop_recreate_tests`
+- 工作量：1 人日
+
+**任务 4.2 — live 集成测试**
+
+`crates/dbx-core/tests/live_mysql_transfer.rs` 的 `fn transfer_request()`（`:69-96`）是新字段第一个落点。**最佳断言范式在 `:707-741`**（插脏数据 → 传输 → 断言脏数据消失）。生命周期沿用 `:651-657` 建 AppState → `:660` `let test_result = async {...}.await` → `:779` 先 cleanup 再 `cleanup.unwrap(); test_result.unwrap();` 的 cleanup-before-assert 结构。
+
+⚠️ **两处既有断言与新模式冲突，必须处理**：
+
+- `live_mysql_transfer.rs:882-895` 断言 `"target row was destroyed by TRUNCATE despite the transfer failing"` —— 锁定「校验必须在 TRUNCATE 之前」。新模式下该校验因 rename 而不必要，需显式决策并在测试中体现等价语义
+- `live_postgres_transfer.rs:849-851` `live_postgres_transfer_skips_create_ddl_for_existing_target_table` —— 语义**直接冲突**。另注意该文件**没有任何 Overwrite 测试**
+
+新增覆盖：结构不兼容目标 + 新模式 → 成功；父子外键两表 → rename 顺序正确；PG 索引与外键在重建后存在（对应任务 2.1 验收）；失败时备份表保留且错误含备份名。
+
+跑法：`make db DB=mysql@8.4` → 导出 `DBX_LIVE_MYSQL_TRANSFER_{HOST,PORT,USER,PASSWORD}` → `cargo test -p dbx-core --test live_mysql_transfer -- --ignored`。**`RUST_MIN_STACK=8388608` 必须设置**（transfer future 栈很深，`live_mysql_transfer.rs:104-118` 有 2MB 栈手工线程测试）。
+
+- 工作量：1.5 人日
+
+**任务 4.3 — 文档与 i18n**
+
+文档必改 4 个文件：`docs/content/docs/data-transfer.{mdx,cn.mdx}` 的传输选项表格（各 `:59-70`，另 `:14`/`:48` 也提到写入模式）；**容易漏的** `docs/content/docs/production-safety.{mdx,cn.mdx}:133`（现文案「跨引擎传输和批量导入需要单独检查类型映射、目标表和清空选项」）。
+
+**i18n key 清单**（扁平挂 `transfer.*`，en 插在 `en.ts:5372` 之后、zh-CN 在 `:5356` 之后，与其描述的 content radio 相邻）：
+
+| key | zh-CN | en |
+|---|---|---|
+| `dropTargetBeforeCreate` | 创建前删除目标表 | Drop the target table before creating |
+| `dropTargetBeforeCreateHint` | 先将目标表改名备份，按源结构重建后写入数据，成功后删除备份 | Rename the target table to a backup, recreate it from the source structure, write data, then drop the backup |
+| `dropTargetWarning` | 目标表及其索引、触发器、约束、注释和对象权限会被替换为源结构。原表会先改名为备份表，传输成功后删除；任一步失败则保留备份，可手工恢复。 | The target table and its indexes, triggers, constraints, comments, and object grants are replaced by the source structure. The original is renamed to a backup and dropped only after the transfer succeeds; if any step fails the backup is kept for manual recovery. |
+| `dropTargetDataOnlyDisabled` | 仅数据模式不建表，删除目标表后不会重建 | Data-only mode does not create tables, so a dropped target would not be rebuilt |
+| `dropTargetUnsupportedDatabase` | 该数据库暂不支持此选项 | This option is not yet supported for this database |
+| `dropTargetNonTableNote` | 该选项只作用于表；已选中的视图、存储过程等对象不会被删除。 | This option affects tables only; selected views, procedures, and other objects are not dropped. |
+| `dropTargetConfirmTitle` | 确认重建目标表 | Confirm rebuilding target tables |
+| `dropTargetConfirmMessage` | 将在 {target} 重建 {count} 张目标表并写入数据。原表会先改名备份，成功后删除。 | {count} target table(s) in {target} will be rebuilt and repopulated. Originals are renamed to backups and dropped only on success. |
+| `dropTargetConfirmSqlNote` | 以下为示例语句，实际由传输任务按目标方言生成。 | The statements below are illustrative; the transfer task generates the actual SQL for the target dialect. |
+| `dropTargetConfirmButton` | 重建后传输 | Rebuild and transfer |
+| `dropTargetPreviewOmitted` | -- 其余 {count} 张表省略 | -- {count} more table(s) omitted |
+| `dropTargetBackupKept` | 传输失败，已保留备份表 {backup}，可手工恢复 | Transfer failed; backup table {backup} was kept for manual recovery |
+
+⚠️ **漏加 i18n key 不会被任何现有检查捕获** —— 7 个非英语文件都是 `export default withEnglishFallback({...})`（`locales/fallback.ts:29`），缺键静默回退英文；`transfer` 命名空间**没有 parity 测试**；`i18n/index.ts:74-81` 的 `createI18n` 未传 message schema 泛型，`t()` 的 key 不做类型检查。必须人工逐文件核对 8 个语言文件（`en` / `zh-CN` / `zh-TW` / `ja` / `ko` / `es` / `it` / `pt-BR`）。
+
+不需要改：`docs/content/docs/meta.json`（已含 `data-transfer`）、CHANGELOG（`changelog.rs:90-107` 是远端 CDN 读取器，仓库无本地 `CHANGELOG.md`）、知识库（`scripts/build-knowledge-base.mjs` 产物在 `outputs/`，已 gitignore 且不在 CI）。
+
+- 工作量：0.75 人日
+
+## 关键设计
+
+### 备份表命名与冲突
+
+- 命名：`{truncated_table}__dbx_bak_{short_hash}`，总长受 `descriptor.rs:161 max_identifier_length` 约束（Oracle 30 / PG 63 / MySQL 64 / SQL Server 128）
+- 哈希从源表限定名 + 传输 id 派生，保证同一传输内幂等、不同源表不碰撞
+- 冲突预检：rename 前查询目标库是否已存在该名；命中即报错，**不自动清理、不重试换名**（沿用 `sqlite_rebuild.rs:498-511` 的判断——自动清理一个我们没创建的对象是不可接受的）
+
+### 外键与 rename 的交互
+
+MySQL 的 `RENAME TABLE` 与 PG 的 `ALTER TABLE ... RENAME TO` 都会让**入向外键跟着走**：改名后其他表的 FK 定义指向备份表，新建的同名表不会自动继承这些入向引用。这与直接 DROP（打断后由 `pending_fk_alters` 重建）行为不同。
+
+处理：rename 预趟按 `parents_first=false`（子表先）执行，使被引用表在其引用者之后才被改名；配合现有的 FK 延迟重建机制（`generate_mysql_foreign_key_alter_statements:2167-2232` + `pending_fk_alters` 末尾统一执行）。**不能依赖 `SET FOREIGN_KEY_CHECKS=0`** —— 会话状态不跨 `execute_on_pool` 保留。
+
+### 失败点状态矩阵
+
+| 失败点 | 目标端状态 | 用户可恢复 |
+|---|---|---|
+| rename 之前（预检 / 权限 / 冲突） | 完全未改动 | 无需恢复 |
+| rename 成功、create 失败 | 备份表存在，原名无表 | 是：改回名 |
+| create 成功、写数据失败 | 备份表存在，新表空或部分 | 是：删新表、改回名 |
+| 写数据成功、删备份失败 | 新表完整，备份残留 | 是：手工删备份（错误串含表名，池已作废） |
+| 用户中途取消 | 同上按取消时点 | 是，同上 |
+
+每一步独立提交，不依赖回滚。这是 rename-then-drop 相比直接 DROP 的全部价值。
+
+## 顺带修复与技术债
+
+**建议纳入本次改动**（各一行，与新功能同源）：
+
+- `script_generator.rs:437-443` 对 `DROP TABLE` **无条件**插入 `IF EXISTS`（`CREATE TABLE`/`CREATE INDEX` 分支会查 profile，DROP 分支因 profile 无字段而不查），Oracle 23c 之前生成非法 SQL。任务 1.1 的 `drop_table_supports_if_exists` 字段正好修掉
+- `DataTransferDialog.vue:771` 在 `structureOnly` 下仍无条件发送 `transferMode`
+- `DataTransferDialog.vue:1222` 琥珀横幅缺 `dark:` 变体
+
+**建议独立提交**（与本功能无依赖）：
+
+- `transfer.rs:7683-7688` 与 `db_admin_sql.rs:552-576` 的 SQLite 系名单漏了 Turso / Rqlite（两者无 `TRUNCATE`，会落到 `TRUNCATE TABLE` 分支）。修完可评估把这两库纳入决策 2 的启用清单
+
+**记为技术债，不在本次范围**：
+
+- dialect registry 注册键与查找键错位（`build.rs:63` + `dialect_loader.rs:117` vs `sql_dialect.rs:73`），导致 postgres / sqlserver 的 yaml descriptor 从未生效。目前不可见但会让任何新增 yaml 字段对这两库失效
+- `plugins/dialects/` 的 `templates` / `rollback_templates` / `online_safety` / `destruction_level` 四组数据零消费（`to_descriptor:637-694` 不读）。激活方案见「已排除的方案」，值得独立 PIP
+- 三个 Oracle 系 yaml 的 `drop_table` 模板互相不一致（`oracle.yaml:109` 带 `CASCADE CONSTRAINTS`、`dameng.yaml:101` 带 `IF EXISTS`、`oceanbase.yaml:83` 带 `CASCADE CONSTRAINTS`），且与 Rust 侧 `supports_drop_table_cascade`（不含 Oracle）冲突
+- `descriptor.rs:451` 的 Oracle `max_identifier_length = 30` 对 Oracle 12.2+ 偏保守（实际支持 128）。保守值对备份名生成器是安全侧，暂不改
+- `query.rs:3815` 的事务性 DDL 白名单不含 DuckDB，尽管 DuckDB 实际支持
+
+## 范围边界
+
+**不在本次范围**：
+
+- **备份表遗留清理入口**。仓库中没有任何机制让用户发现或清理残留备份（grep `_old_` / `__dbx` / `staging` / `orphan` 确认无此类 UI 或命令）。本次仅在失败错误串中回报备份表全名（`dropTargetBackupKept` key）。完整方案（命名前缀约定 + 列举查询 + UI 入口）约 +1 人日，建议观察实际使用后再定
+- 10 个高危 / 不适用方言的支持（见决策 2）
+- 非表对象（视图 / 存储过程 / 触发器 / 序列）的先删后建。这些对象已有各自的 `CREATE OR REPLACE` 或 drop-then-create 路径，本选项只作用于表（`dropTargetNonTableNote` key 明确告知用户）
+
+## 工作量与关键路径
+
+```
+1.1 ─┬─> 1.2 ─┐
+     └─> 1.4 ─┤
+1.3 ──────────┼─> 2.1 ─> 2.2 ─> 2.3 ─> 2.4 ─> 4.2
+1.5 ──────────┤          │
+1.6 ──────────┘          └─> 3.1 ─> 3.2 ─> 3.3 ─> 3.4
+4.1 可与阶段 1/2 并行；4.3 最后
+```
+
+关键路径：**1.3 → 2.1 → 2.2 → 2.3 → 4.2**。任务 2.2 是架构风险集中点。
+
+| 阶段 | 人日 |
+|---|---|
+| 1（方言底座） | 3.0 |
+| 2（编排与 rename） | 5.5 |
+| 3（前端） | 3.25 |
+| 4（测试文档） | 3.25 |
+| **合计** | **约 15 人日** |
+
+## 风险
+
+| 风险 | 影响 | 缓解 |
+|---|---|---|
+| `target_table_preexisting` 未重置 → PG 索引与外键静默不重建 | 高（数据可用但结构残缺，难察觉） | 任务 2.1 验收强制 live 测试；review 专查 `transfer.rs:7318`/`:7331`/`:7595` |
+| 入向外键跟随 rename 指向备份表 | 高（约束静默丢失） | 见「关键设计 · 外键与 rename 的交互」；任务 2.3 的循环引用 live 测试 |
+| Tauri 与 Web 两处编排改动不同步 | 中（Web API 与桌面端分歧） | 任务 2.2 验收显式要求；两处均有 fixture 可挂断言 |
+| 备份名在 Oracle 30 字符上限溢出 | 中（长表名直接失败） | 任务 1.5 的四个边界单测 |
+| 备份表残留无清理入口 | 中（磁盘占用累积） | 本次仅回报表名；见「范围边界」 |
+| 前后端 cascade 白名单分叉 | 低（预览 SQL 与实际不符） | 任务 1.2 明确要求同步 `dbAdminSql.ts:322` |
+| i18n 漏键静默回退英文 | 低 | 无自动化手段，人工核对 8 文件；可考虑为 `transfer` 补 parity 测试（注意 `docsNamespaceParity.spec.ts:11-17` 记录的陷阱：必须 import 原始对象而非 `withEnglishFallback` 合并后的默认导出） |
+| `DataTransferDialog.spec.ts` 源码文本断言被打断 | 低（CI 红但原因明确） | 任务 3.2/3.3 已列出被 pin 的具体行号 |
+
+
+
+
+
+
diff --git a/docs/pips/plans/2026-09-07-transfer-rebuild-hardening.md b/docs/pips/plans/2026-09-07-transfer-rebuild-hardening.md
new file mode 100644
index 0000000000..2d16d2d862
--- /dev/null
+++ b/docs/pips/plans/2026-09-07-transfer-rebuild-hardening.md
@@ -0,0 +1,102 @@
+# Transfer rebuild hardening Implementation Plan
+
+> **For agentic workers:** Use the approved design from the conversation and execute the independent frontend, dependency-check, and regression-test tasks in parallel. Keep core orchestration and integration sequential. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 将重建整合为第四种目标表处理方式，并修复本次 review 发现的依赖越界、序列和索引冲突、提前清理和取消恢复问题。
+
+**Architecture:** UI 提供四种互斥策略，API 继续使用 `TransferMode` 与 `dropTargetBeforeCreate`。后端先准备完整备份计划并保存恢复记录，再执行备份、建表、写入和结构恢复，全部必要步骤成功后才清理；Tauri 与 Web 共用编排。确认预览复用后端计划，包含实际限定目标名和 SQL。
+
+**Tech Stack:** Rust / Tokio / existing database drivers, Vue 3 / TypeScript / Pinia, Vitest, Cargo tests.
+
+**Spec:** 本会话用户已确认的 review 与改造方案；原设计背景见 `docs/pips/plans/2026-09-03-transfer-drop-before-create.md`。
+
+## Global Constraints
+
+- 使用现有依赖，离线构建；数据库验证仅在临时实例或临时 SQLite 文件中进行。
+- 兼容已有任务的重建布尔字段，不增加第四个底层 DML `TransferMode`。
+- 不把生产标记当作永久禁止：复用连接和数据库级生产确认，确认字段仅作用于一次请求。
+- 不对未选中的依赖对象执行隐式 CASCADE；预检无法确认安全时在第一条 DDL 前报错。
+- 普通追加、清空、Upsert 的行为保持兼容；重建模式以 INSERT 写入新表。
+- 所有对象名称经方言 quoting，备份名称按对象完整身份派生并预检冲突。
+- 回归测试验证数据库对象与数据结果，不添加源码文本断言。
+- 本轮交付可审查的本地修改，不 push 或发布。
+
+## Task 1: 四种 UI 策略及确认流程
+
+**Files:** `apps/desktop/src/components/transfer/DataTransferDialog.vue`, new `transferStrategy.ts` and behavior tests, `stores/transferTaskStore.ts`, `types/database.ts`, `lib/backend/tauri.ts`, transfer locale keys and user documentation.
+
+**Interfaces:** Existing `TransferRequest` stays compatible. `TransferOwnershipPreview` gains optional `rebuild: { sql: string; tables: Array<{ sourceTable: string; targetTable: string; backupTable?: string }>; warnings: string[] }`. Preview and actual execution use the same frozen request and transfer ID.
+
+- [ ] Write behavior tests for legacy task migration and mutually exclusive request mapping.
+
+```ts
+expect(resolveTransferStrategy({ mode: 'upsert', dropTargetBeforeCreate: true })).toBe('rebuild');
+expect(transferStrategyOptions('rebuild')).toEqual({ mode: 'append', dropTargetBeforeCreate: true });
+```
+
+- [ ] Run the new tests and observe failures before implementation.
+- [ ] Add four-way strategy selection. Structure-only offers keep/rebuild; data-only and unsupported targets disable rebuild with a reason.
+- [ ] Freeze the request before preview/confirmation. Display backend rebuild SQL; combine destructive and production confirmation without instructing users to disable protection.
+- [ ] Normalize saved legacy rebuild tasks, keep confirmation transient, update all eight locales and docs including malformed JSX quotes.
+- [ ] Run covering Vitest tests and frontend typecheck.
+
+## Task 2: 依赖预检
+
+**Files:** `crates/dbx-core/src/transfer_rebuild.rs` and its tests.
+
+**Interfaces:** Preserve `ensure_no_external_incoming_foreign_keys`. Add `ensure_no_external_table_dependencies(state: &AppState, target_pool_key: &str, target_database: &str, target_schema: &str, target_tables: &[String], target_database_type: DatabaseType) -> Result<(), String>` for rebuild planning and cleanup verification.
+
+- [ ] Add a real SQLite regression that creates parent/external child with `ON DELETE CASCADE`, runs preflight, and verifies rejection before mutation.
+- [ ] Add PostgreSQL dependency SQL coverage and live regression for a target-only dependent view.
+- [ ] Implement SQLite incoming-FK metadata checks and dependent-view checks with quoted values/identifiers; refuse unsafe or uninspectable dependencies.
+- [ ] Keep MySQL, PostgreSQL, Oracle and SQL Server incoming-FK checks; include schema identity and normalized table matching where required.
+- [ ] Run the targeted tests; the temporary external table and its rows must remain intact.
+
+## Task 3: 备份计划及生命周期
+
+**Files:** `crates/dbx-core/src/transfer.rs`, `transfer_rebuild.rs` integration, focused new core module if appropriate, `storage.rs`, `src-tauri/src/commands/transfer.rs`, `crates/dbx-web/src/routes/transfer.rs`.
+
+**Interfaces:** Keep `rename_tables_to_backup` and `transfer_table` public signatures compatible. Add serializable recovery records with qualified source/target/backup identities, SQL, operation state and error/cancellation outcome. Ownership preview gains the optional rebuild preview from Task 1.
+
+- [ ] Reproduce failed source-sequence ownership and colliding long PostgreSQL index names with live regression tests.
+- [ ] Resolve all actual target names, source structure, backup names and collisions before the first DDL; propagate metadata lookup errors for rebuilds.
+- [ ] Rename owned PostgreSQL sequences and indexes with hashes containing each object's identity; abort on rename errors and retain complete recovery information.
+- [ ] Free MySQL backup FK names using atomically replaced constraints on backup tables, preserving referenced backups and ON UPDATE/DELETE rules.
+- [ ] Persist the recovery plan before mutations and update execution state; terminal errors/cancellation expose retained backups and manual recovery SQL.
+- [ ] Share the orchestration between desktop and Web. Use typed internal cancellation and preserve the public cancellation event.
+- [ ] Restore all deferred constraints and selected schema objects before cleanup. Never issue broad `DROP ... CASCADE`.
+- [ ] Break only backup-to-backup FK cycles during final cleanup; a cleanup failure reports retained objects without claiming the whole rollback set remains intact.
+- [ ] Use the same prepared DDL and actual target identifiers for preview and execution.
+
+## Task 4: 集成回归及审查
+
+**Files:** `crates/dbx-core/tests/live_mysql_transfer.rs`, `live_postgres_transfer.rs`, new SQLite rebuild regression tests, existing frontend behavior tests.
+
+- [ ] Add regression cases for PostgreSQL SERIAL/identity ownership, shared long index prefixes, external views, MySQL cyclic FKs, SQLite external children, partial rename cancellation, failure before final cleanup, and successful cleanup.
+- [ ] Verify red before the relevant fixes, then run green against temporary PostgreSQL and MySQL servers and temporary SQLite databases.
+- [ ] Run `RUST_MIN_STACK=8388608 cargo test --offline --locked -p dbx-core --no-default-features --features sqlite-bundled --lib transfer`.
+- [ ] Run relevant frontend Vitest cases, `pnpm exec vue-tsc --noEmit --project apps/desktop/tsconfig.json`, and Rust checks for core/Web/Tauri with available local features.
+- [ ] Request an independent code review, fix actionable findings, inspect the final diff and working-tree state.
+
+## Progress
+
+- Baseline: commit `c3e417a9a`, clean working tree; prior review verified 45 frontend and 265 core transfer tests passing.
+- Branch: `codex/transfer-rebuild`; use the current clean workspace to keep the user's local changes directly reviewable and reuse offline build caches.
+- Task 1 (UI strategies): `transferStrategy.ts` + 26 behavior tests, legacy-task migration and store coverage (23 tests) all passing; `vue-tsc --noEmit` clean; locales and dialog updated.
+- Task 2 (dependency preflight): `ensure_no_external_table_dependencies` (incoming FKs + dependent views) implemented with SQLite/PG-family/MySQL-family/Oracle-family/SQL Server/DuckDB coverage; wired into `rename_tables_to_backup` before the first rename. 24+ module tests pass.
+- Task 3 (backup lifecycle):
+  - Backup-name collision preflight is now all-or-nothing before any rename (red test fixed).
+  - Cancellation keeps its exact `"Cancelled"` discriminator; retained-backup annotation is appended only to real failures (red test fixed).
+  - PostgreSQL-family pre-pass renames owned sequences and indexes with per-object identity hashes; listing/rename failures abort instead of being swallowed.
+  - Recovery journal (`transfer-rebuild:<id>` in the existing state store) is persisted before the first rename and updated per step; removed after successful cleanup.
+  - New `free_backup_foreign_key_names` frees MySQL backup constraint names atomically before the deferred FK ALTERs.
+  - Cleanup order: table loop → free constraint names → deferred FK ALTERs → schema objects → `drop_backup_tables` (which now breaks the backup-to-backup FK graph first, fixing "Cannot drop table ... referenced by a foreign key constraint" seen with Flowable schemas).
+- DDL planning shared: `transfer/ddl_plan.rs::prepare_table_ddl` replaces the inline block in `transfer_table_inner`; rebuild mode fails closed on incomplete columns, unreadable source DDL, and failed FK inspection.
+- Verification: 283 core transfer lib tests pass (2 prior red tests fixed); full dbx-core lib suite 5653 passed with one pre-existing environment failure (`external_driver_preview_retry_preserves_marker_truncation`, JDBC plugin timeout, reproduced on the clean baseline); `dbx-web` and Tauri `dbx` `cargo check` clean; frontend Vitest (49) and `vue-tsc` clean.
+- Live regression (temporary Docker `postgres:16-alpine` + `mysql:8.0` on loopback ports 55432/53306, cleaned up afterwards):
+  - PostgreSQL rebuild tests: 4/4 passed (`rebuilds_same_named_serial_sequence`, `rebuilds_indexes_with_shared_long_prefix`, `rebuild_rejects_target_only_view_before_any_rename`, `drop_target_rebuilds_structure_and_indexes`).
+  - MySQL `drop_target` tests: 5/5 passed, including the Flowable-style `parent_child` FK, the `circular_foreign_keys` cleanup (the `ERROR 3730` scenario), and `retains_backup_on_failure`.
+- Recovery semantics (user decision "B"): `create_transfer_target_table` was extracted, and the rebuild path now creates the target table from the source DDL *before* reading the source column list. A source column-read failure therefore still leaves the empty new table + retained backup behind (drop the empty table, rename the backup back).
+- Ownership preview gains the optional rebuild plan: `TransferOwnershipPreview.rebuild` (`TransferRebuildPreview` with `sql`/`tables`/`warnings`) is built by `build_rebuild_preview` — pure planning that reuses the same resolution, backup-name derivation, dependency preflight, and DDL planning as execution, so the confirmation dialog shows the real rename/create/cleanup statements. A SQLite regression (`transfer_rebuild_preview_plans_without_executing_ddl`) verifies it plans without renaming anything.
+- Final verification: 284 core transfer lib tests, PostgreSQL rebuild 4/4, MySQL `drop_target` 5/5, `dbx-web` + Tauri `dbx` `cargo check` clean, `vue-tsc` clean.
+- Pending: an independent review pass.
diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
index 7e38cce9ee..469396140b 100644
--- a/src-tauri/src/commands/transfer.rs
+++ b/src-tauri/src/commands/transfer.rs
@@ -30,6 +30,18 @@ pub async fn start_transfer(
     let target_db_type = get_db_type(&state, &request.target_connection_id).await?;
     dbx_core::transfer::validate_transfer_request(&request)?;
 
+    // `drop_target_before_create` rebuilds target tables; gate the dialect and require an
+    // explicit confirmation for production databases.
+    dbx_core::transfer_rebuild::ensure_drop_target_allowed(
+        &state,
+        &request.target_connection_id,
+        &request.target_database,
+        target_db_type,
+        request.drop_target_before_create,
+        request.drop_target_confirmed,
+    )
+    .await?;
+
     // Cross-family object transfers are validated inside transfer_schema_objects:
     // only mechanically rewriteable kinds (views, sequences) are allowed.
     // Structure-only data transfer is unsupported for MongoDB.
@@ -102,6 +114,87 @@ pub async fn start_transfer(
         let mut last_rows_transferred = 0_u64;
         let mut last_total_rows = None;
 
+        // When drop_target_before_create is true, perform a rename pre-pass in
+        // parents_first=false order (children first) so that foreign keys on the
+        // backup tables remain intact. The main create/insert pass then runs in
+        // parents_first=true order (parents first).
+        // Children-first order used by the rename pre-pass, kept for the post-loop backup
+        // cleanup: a backup can still be referenced by another backup, so the drops must
+        // follow the same order.
+        let mut backup_drop_order: Vec<String> = Vec::new();
+        let backup_names = if request.drop_target_before_create {
+            // Re-sort tables in children-first order for the rename pre-pass
+            let (tables_for_rename, _) = dbx_core::transfer::sort_tables_by_fk_dependency_with_foreign_keys(
+                &state,
+                &request.target_connection_id,
+                &request.target_database,
+                &request.target_schema,
+                &sorted_tables,
+                false, // parents_first=false: children first
+            )
+            .await
+            .unwrap_or_else(|e| {
+                log::warn!("[transfer] failed to sort tables for rename pre-pass, using original order: {e}");
+                (sorted_tables.clone(), std::collections::HashMap::new())
+            });
+            backup_drop_order = tables_for_rename.clone();
+
+            match dbx_core::transfer::rename_tables_to_backup(
+                &state,
+                &request,
+                &tables_for_rename,
+                target_db_type,
+                &target_pool_key,
+                |progress| {
+                    last_rows_transferred = progress.rows_transferred;
+                    last_total_rows = progress.total_rows;
+                    emit_progress(&app, progress);
+                },
+            )
+            .await
+            {
+                Ok(names) => Some(names),
+                Err(e) if e == "Cancelled" => {
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: "rename pre-pass".to_string(),
+                            table_index: 0,
+                            total_tables,
+                            rows_transferred: last_rows_transferred,
+                            total_rows: last_total_rows,
+                            status: TransferStatus::Cancelled,
+                            error: None,
+                            terminal: true,
+                        },
+                    );
+                    dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                    return;
+                }
+                Err(e) => {
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: "rename pre-pass".to_string(),
+                            table_index: 0,
+                            total_tables,
+                            rows_transferred: last_rows_transferred,
+                            total_rows: last_total_rows,
+                            status: TransferStatus::Error,
+                            error: Some(e),
+                            terminal: true,
+                        },
+                    );
+                    dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                    return;
+                }
+            }
+        } else {
+            None
+        };
+
         if matches!(source_db_type, dbx_core::models::connection::DatabaseType::Postgres)
             && matches!(target_db_type, dbx_core::models::connection::DatabaseType::Postgres)
         {
@@ -190,6 +283,7 @@ pub async fn start_transfer(
                 &target_pool_key,
                 &known_foreign_keys,
                 &mut pending_fk_alters,
+                backup_names.as_ref(),
                 |progress| {
                     last_rows_transferred = progress.rows_transferred;
                     last_total_rows = progress.total_rows;
@@ -255,7 +349,9 @@ pub async fn start_transfer(
         // Add any foreign keys deferred during MySQL-family table creation now that
         // every selected table exists — see transfer_table's use of
         // strip_inline_foreign_key_constraint_lines for why these can't be created
-        // inline (a foreign key cycle has no valid CREATE TABLE order at all).
+        // inline (a foreign key cycle has no valid CREATE TABLE order at all). The
+        // rename pre-pass already freed the backup constraint names, so these re-create
+        // the original names without colliding.
         let mut failed_fk_tables: Vec<String> = Vec::new();
         let mut failed_fk_count = 0usize;
         for (table, alter_sql) in &pending_fk_alters {
@@ -328,6 +424,33 @@ pub async fn start_transfer(
         if !object_outcome.failed.is_empty() {
             failed_tables.push(format!("schema objects ({})", object_outcome.failed.len()));
         }
+
+        // The rename pre-pass left one backup per rebuilt table. Drop them only now that
+        // every table, every deferred foreign key and every selected schema object has
+        // succeeded — a failure anywhere above keeps the originals recoverable under
+        // their backup names.
+        if let Some(backup_names) = backup_names.as_ref() {
+            if failed_tables.is_empty() {
+                if let Err(e) = dbx_core::transfer::drop_backup_tables(
+                    &state,
+                    &request,
+                    target_db_type,
+                    &target_pool_key,
+                    backup_names,
+                    &backup_drop_order,
+                )
+                .await
+                {
+                    failed_tables.push(e);
+                }
+            } else {
+                log::warn!(
+                    "[transfer] keeping {} backup table(s) because {} step(s) failed",
+                    backup_names.len(),
+                    failed_tables.len()
+                );
+            }
+        }
         let skip_suffix = if !object_outcome.skipped.is_empty() && failed_tables.is_empty() {
             format!("，跳过 {} 个已存在对象", object_outcome.skipped.len())
         } else if !object_outcome.skipped.is_empty() {