From bf68b93b05aac8b2b8bf86f4a8e8c164d5fd7448 Mon Sep 17 00:00:00 2001 From: jearhe <0verme7753@gmail.com> Date: Mon, 5 Oct 2026 02:02:53 +0800 Subject: [PATCH] feat(transfer): add SQL preview before structure-only transfer --- .../transfer/DataTransferDialog.vue | 78 ++- .../transferStructurePreview.spec.ts | 173 +++++ .../components/transfer/transferStrategy.ts | 26 + apps/desktop/src/i18n/locales/az.ts | 7 + apps/desktop/src/i18n/locales/en.ts | 7 + apps/desktop/src/i18n/locales/es.ts | 8 + apps/desktop/src/i18n/locales/id.ts | 7 + apps/desktop/src/i18n/locales/it.ts | 8 + apps/desktop/src/i18n/locales/ja.ts | 7 + apps/desktop/src/i18n/locales/ko.ts | 7 + apps/desktop/src/i18n/locales/pt-BR.ts | 7 + apps/desktop/src/i18n/locales/ru.ts | 7 + apps/desktop/src/i18n/locales/tr.ts | 7 + apps/desktop/src/i18n/locales/zh-CN.ts | 7 + apps/desktop/src/i18n/locales/zh-TW.ts | 7 + apps/desktop/src/lib/backend/tauri.ts | 19 + crates/dbx-core/src/data/transfer.rs | 176 ++++- crates/dbx-core/src/data/transfer/ddl_plan.rs | 8 +- .../src/data/transfer/structure_plan.rs | 603 ++++++++++++++++++ .../dbx-core/tests/live_postgres_transfer.rs | 179 +++++- docs/content/docs/data-transfer.cn.mdx | 19 + docs/content/docs/data-transfer.mdx | 19 + 22 files changed, 1332 insertions(+), 54 deletions(-) create mode 100644 apps/desktop/src/components/transfer/__tests__/transferStructurePreview.spec.ts create mode 100644 crates/dbx-core/src/data/transfer/structure_plan.rs diff --git a/apps/desktop/src/components/transfer/DataTransferDialog.vue b/apps/desktop/src/components/transfer/DataTransferDialog.vue index a17f26923e..0d59539cf6 100644 --- a/apps/desktop/src/components/transfer/DataTransferDialog.vue +++ b/apps/desktop/src/components/transfer/DataTransferDialog.vue @@ -6,7 +6,18 @@ import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, Di import { Button } from "@/components/ui/button"; import { buildTransferObjectSelections, countTransferObjects } from "./transferSelections"; import { createTaskLoadTracker } from "./taskLoadTracker"; -import { confirmTransferWithProductionSafety, createTransferSubmission, rebuildUnavailableReason, resolveTransferStrategy, supportsTransferUpsert, transferStrategyOptions, type TransferStrategy } from "./transferStrategy"; +import { + confirmTransferWithProductionSafety, + createTransferSubmission, + hasTransferSqlPreview, + rebuildUnavailableReason, + resolveTransferStrategy, + supportsTransferUpsert, + transferPreviewSql, + transferStrategyOptions, + TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE, + 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"; @@ -181,7 +192,7 @@ const targetTableStrategy = computed({ const targetTableNameCase = ref("preserve"); const quoteTargetColumnNames = ref(true); const batchSize = ref(1000); -const showRebuildConfirm = ref(false); +const showSqlPreviewConfirm = ref(false); const isSubmitting = ref(false); const pendingTransferId = ref(null); const showStartConfirm = ref(false); @@ -812,7 +823,7 @@ async function requestStartTransfer() { 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); + toast(transferPreviewFailureMessage(message), 5000); } finally { if (pendingTransferId.value === request.transferId) { pendingTransferId.value = null; @@ -1069,18 +1080,48 @@ const confirmationSummary = computed(() => { }); const confirmationStrategy = computed(() => (confirmationRequest.value ? transferStrategyLabel(confirmationRequest.value) : "")); -const rebuildConfirmationDetails = computed(() => { - const rebuild = confirmationPreview.value?.rebuild; - if (!rebuild) return ""; - const missingTargets = rebuild.tables.some((table) => !table.backupTable); - return [confirmationSummary.value, t("transfer.rebuildSummary", { count: rebuild.tables.length }), missingTargets ? t("transfer.rebuildMissingTargets") : ""].filter(Boolean).join("\n"); +const confirmationTitle = computed(() => { + if (!confirmationRequest.value) return ""; + // A rebuild keeps its strategy title (it covers rename + create); a plain structure transfer + // is titled by what the user is actually reviewing. + return confirmationRequest.value.dropTargetBeforeCreate ? confirmationStrategy.value : t("transfer.structurePreviewTitle"); }); +/** The read-only SQL both confirmations review, composed so no operation is shown twice. */ +const confirmationSql = computed(() => (confirmationPreview.value ? transferPreviewSql(confirmationPreview.value) : "")); +const confirmationDangerMessage = computed(() => (confirmationRequest.value?.dropTargetBeforeCreate ? t("transfer.rebuildDanger") : t("transfer.structurePreviewDanger"))); +const confirmationDetails = computed(() => { + const preview = confirmationPreview.value; + const request = confirmationRequest.value; + if (!preview || !request) return ""; + const lines = [confirmationSummary.value]; + if (preview.rebuild) { + const missingTargets = preview.rebuild.tables.some((table) => !table.backupTable); + lines.push(t("transfer.rebuildSummary", { count: preview.rebuild.tables.length })); + if (missingTargets) lines.push(t("transfer.rebuildMissingTargets")); + } + if (preview.structure) { + lines.push(t("transfer.structurePreviewSummary", { count: preview.structure.tables.length })); + if (preview.structure.tables.some((table) => table.preexisting)) lines.push(t("transfer.structurePreviewPreexistingTargets")); + const unexpandedObjects = request.objects.filter((selection) => selection.objectType !== "TABLE" && selection.names.length > 0); + if (unexpandedObjects.length > 0) { + lines.push(t("transfer.structurePreviewUnexpandedObjects", { objects: unexpandedObjects.map((selection) => selection.names.join(", ")).join("; ") })); + } + lines.push(t("transfer.structurePreviewRevalidation")); + } + return lines.filter(Boolean).join("\n"); +}); + +function transferPreviewFailureMessage(message: string): string { + if (message === "TRANSFER_REBUILD_PREVIEW_UNAVAILABLE") return t("transfer.rebuildPreviewUnavailable"); + if (message === TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE) return t("transfer.structurePreviewUnavailable"); + return t("transfer.previewFailed", { message }); +} function requestTransferConfirmation(request: api.TransferRequest, preview: api.TransferOwnershipPreview): Promise { confirmationRequest.value = request; confirmationPreview.value = preview; - const reviewText = preview.rebuild - ? [confirmationStrategy.value, rebuildConfirmationDetails.value, preview.rebuild.sql].filter(Boolean).join("\n\n") + const reviewText = hasTransferSqlPreview(preview) + ? [confirmationStrategy.value, confirmationDetails.value, transferPreviewSql(preview)].filter(Boolean).join("\n\n") : [confirmationSummary.value, `${t("transfer.targetTableHandling")}: ${confirmationStrategy.value}`, ...request.objects.map((selection) => selection.names.join(", "))].join("\n"); return confirmTransferWithProductionSafety({ request, @@ -1090,7 +1131,7 @@ function requestTransferConfirmation(request: api.TransferRequest, preview: api. confirm: () => new Promise((resolve) => { resolveTransferConfirmation = resolve; - if (request.dropTargetBeforeCreate) showRebuildConfirm.value = true; + if (hasTransferSqlPreview(preview)) showSqlPreviewConfirm.value = true; else showStartConfirm.value = true; }), }); @@ -1100,7 +1141,7 @@ function resolveStartDecision(confirmed: boolean) { const resolve = resolveTransferConfirmation; resolveTransferConfirmation = undefined; showStartConfirm.value = false; - showRebuildConfirm.value = false; + showSqlPreviewConfirm.value = false; resolve?.(confirmed); } @@ -1124,7 +1165,7 @@ watch( { flush: "sync" }, ); watch( - showRebuildConfirm, + showSqlPreviewConfirm, (isOpen) => { if (!isOpen) resolveStartDecision(false); }, @@ -1460,16 +1501,7 @@ async function saveConfigTask() { - + diff --git a/apps/desktop/src/components/transfer/__tests__/transferStructurePreview.spec.ts b/apps/desktop/src/components/transfer/__tests__/transferStructurePreview.spec.ts new file mode 100644 index 0000000000..ebb6d98cc5 --- /dev/null +++ b/apps/desktop/src/components/transfer/__tests__/transferStructurePreview.spec.ts @@ -0,0 +1,173 @@ +import { describe, expect, it, vi } from "vitest"; +import type { TransferOwnershipPreview, TransferRequest } from "@/lib/backend/api"; +import { createTransferSubmission, hasTransferSqlPreview, transferPreviewSql, TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE } from "../transferStrategy"; + +function structureRequest(overrides: Partial = {}): 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: "structureOnly", + mode: "append", + targetTableNameCase: "preserve", + quoteTargetColumnNames: true, + ownershipPolicy: "preserve", + batchSize: 1000, + dropTargetBeforeCreate: false, + dropTargetConfirmed: false, + ...overrides, + }; +} + +function structurePreview(sql = '-- orders -> reporting.orders\nCREATE TABLE "reporting"."orders" ("id" integer);'): TransferOwnershipPreview["structure"] { + return { sql, tables: [{ sourceTable: "orders", targetTable: "reporting.orders", preexisting: false, sql }] }; +} + +function preview(overrides: Partial = {}): TransferOwnershipPreview { + return { missingOwners: [], targetOwner: "", structure: structurePreview(), ...overrides }; +} + +/** Collects what the submission asked for, so a refused transfer is visible as "no execute". */ +function submissionHarness(backendPreview: (request: TransferRequest) => Promise, confirmed = true) { + const previews: TransferRequest[] = []; + const reviewed: Array<{ request: TransferRequest; preview: TransferOwnershipPreview }> = []; + const executions: TransferRequest[] = []; + const submission = createTransferSubmission({ + preview: async (request) => { + previews.push(request); + return backendPreview(request); + }, + confirmOwnership: async () => "preserve", + confirm: async (request, plan) => { + reviewed.push({ request, preview: plan }); + return confirmed; + }, + execute: (request) => { + executions.push(request); + }, + }); + return { submission, previews, reviewed, executions }; +} + +describe("structure-only SQL preview", () => { + it("reviews the planned structure SQL and executes only after confirmation", async () => { + const harness = submissionHarness(async () => preview()); + + await expect(harness.submission.start(structureRequest())).resolves.toBe(true); + + expect(harness.previews).toHaveLength(1); + expect(harness.reviewed[0]?.preview.structure?.sql).toContain("CREATE TABLE"); + expect(transferPreviewSql(harness.reviewed[0]!.preview)).toContain('CREATE TABLE "reporting"."orders"'); + expect(hasTransferSqlPreview(harness.reviewed[0]!.preview)).toBe(true); + expect(harness.executions).toHaveLength(1); + expect(harness.executions[0]?.content).toBe("structureOnly"); + }); + + it("does not execute when the SQL confirmation is cancelled", async () => { + const harness = submissionHarness(async () => preview(), false); + + await expect(harness.submission.start(structureRequest())).resolves.toBe(false); + + expect(harness.reviewed).toHaveLength(1); + expect(harness.executions).toEqual([]); + }); + + it("fails closed when the backend returns no structure preview", async () => { + const harness = submissionHarness(async () => ({ missingOwners: [], targetOwner: "" })); + + await expect(harness.submission.start(structureRequest())).rejects.toThrow(TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE); + + expect(harness.reviewed).toEqual([]); + expect(harness.executions).toEqual([]); + }); + + it("places the structure plan between the rebuild rename and cleanup phases without repeating either", () => { + const composed = transferPreviewSql({ + missingOwners: [], + targetOwner: "", + structure: structurePreview("CREATE TABLE users (id integer);"), + rebuild: { + sql: "COMBINED PLAN", + tables: [{ sourceTable: "users", targetTable: "users", backupTable: "users__dbx_bak_1" }], + backupSql: "ALTER TABLE users RENAME TO users__dbx_bak_1;", + cleanupSql: "DROP TABLE users__dbx_bak_1;", + }, + }); + + expect(composed.split("\n\n")).toEqual(["ALTER TABLE users RENAME TO users__dbx_bak_1;", "CREATE TABLE users (id integer);", "DROP TABLE users__dbx_bak_1;"]); + expect(composed).not.toContain("COMBINED PLAN"); + }); + + it("keeps the combined rebuild plan for rebuilds without a structure preview", () => { + const composed = transferPreviewSql({ + missingOwners: [], + targetOwner: "", + rebuild: { + sql: "COMBINED PLAN", + tables: [{ sourceTable: "users", targetTable: "users", backupTable: "users__dbx_bak_1" }], + }, + }); + + expect(composed).toBe("COMBINED PLAN"); + expect(hasTransferSqlPreview({ missingOwners: [], targetOwner: "", rebuild: { sql: "PLAN", tables: [] } })).toBe(true); + }); + + it("does not request a structure preview for data-only transfers", async () => { + const harness = submissionHarness(async () => { + throw new Error("Data-only must not load the structure preview"); + }); + + await expect(harness.submission.start(structureRequest({ content: "dataOnly", createTable: false }))).resolves.toBe(true); + + expect(harness.previews).toEqual([]); + expect(harness.executions).toHaveLength(1); + }); + + it("keeps structure-and-data transfers on the existing confirmation path", async () => { + const harness = submissionHarness(async () => ({ missingOwners: [], targetOwner: "" })); + + await expect(harness.submission.start(structureRequest({ content: "structureAndData", tables: ["orders"] }))).resolves.toBe(true); + + expect(harness.previews).toHaveLength(1); + expect(harness.reviewed[0]?.preview.structure).toBeUndefined(); + expect(hasTransferSqlPreview(harness.reviewed[0]!.preview)).toBe(false); + expect(harness.executions).toHaveLength(1); + }); + + it("still refuses a rebuild that has no rebuild plan", async () => { + const harness = submissionHarness(async () => ({ missingOwners: [], targetOwner: "", structure: structurePreview() })); + + await expect(harness.submission.start(structureRequest({ dropTargetBeforeCreate: true }))).rejects.toThrow("TRANSFER_REBUILD_PREVIEW_UNAVAILABLE"); + + expect(harness.executions).toEqual([]); + }); + + it("refuses a structure-only transfer whose preview is missing even when ownership was re-confirmed", async () => { + const executions: TransferRequest[] = []; + let previewCalls = 0; + const confirmations = vi.fn(async () => true); + const submission = createTransferSubmission({ + preview: async () => { + previewCalls += 1; + return previewCalls === 1 ? { missingOwners: ["old_owner"], targetOwner: "target_user", structure: structurePreview() } : { missingOwners: [], targetOwner: "" }; + }, + confirmOwnership: async () => "reassignMissing", + confirm: confirmations, + execute: (request) => { + executions.push(request); + }, + }); + + await expect(submission.start(structureRequest())).rejects.toThrow(TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE); + + expect(confirmations).not.toHaveBeenCalled(); + expect(executions).toEqual([]); + }); +}); diff --git a/apps/desktop/src/components/transfer/transferStrategy.ts b/apps/desktop/src/components/transfer/transferStrategy.ts index 55c4b28ed1..8420c8d32a 100644 --- a/apps/desktop/src/components/transfer/transferStrategy.ts +++ b/apps/desktop/src/components/transfer/transferStrategy.ts @@ -5,6 +5,9 @@ import { useProductionSafetyStore } from "@/stores/productionSafetyStore"; export type TransferStrategy = TransferMode | "rebuild"; +/** Fail-closed discriminator: a structure-only transfer may not run without its SQL preview. */ +export const TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE = "TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE"; + export function resolveTransferStrategy(options: { mode?: TransferMode; dropTargetBeforeCreate?: boolean }): TransferStrategy { return options.dropTargetBeforeCreate ? "rebuild" : (options.mode ?? "append"); } @@ -42,6 +45,26 @@ function freezeTransferRequest(request: TransferRequest): TransferRequest { return Object.freeze(snapshot); } +/** + * The SQL document a SQL-preview confirmation shows and reviews. + * + * A rebuild is composed around the structure plan so each operation appears exactly once and + * in execution order — rename the old target aside, create the new structure, drop the + * backups after success. Without a rebuild (or without a structure plan) it is just the + * structure SQL, and a backend that only reports the combined rebuild plan keeps its + * existing `rebuild.sql`. + */ +export function transferPreviewSql(preview: TransferOwnershipPreview): string { + const sections = [preview.rebuild?.backupSql, preview.structure?.sql, preview.rebuild?.cleanupSql].filter((section): section is string => Boolean(section)); + if (sections.length > 0) return sections.join("\n\n"); + return preview.rebuild?.sql ?? ""; +} + +/** Whether this preview has SQL the user must review in a read-only confirmation. */ +export function hasTransferSqlPreview(preview: TransferOwnershipPreview): boolean { + return Boolean(preview.rebuild || preview.structure); +} + interface TransferSubmissionOptions { ensureWritable?: (request: TransferRequest) => Promise; preview: (request: TransferRequest) => Promise; @@ -75,6 +98,9 @@ export function createTransferSubmission(options: TransferSubmissionOptions) { } } if (request.dropTargetBeforeCreate && !preview.rebuild) throw new Error("TRANSFER_REBUILD_PREVIEW_UNAVAILABLE"); + // A structure-only transfer changes the target schema; never fall back to the plain + // start confirmation when the backend did not say what it is going to run. + if (request.content === "structureOnly" && !preview.structure) throw new Error(TRANSFER_STRUCTURE_PREVIEW_UNAVAILABLE); if (!(await options.confirm(request, preview)) || !isCurrent()) return false; options.execute(Object.freeze({ ...request, dropTargetConfirmed: request.dropTargetBeforeCreate })); return true; diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.ts index 25c78ac801..1104bf15b2 100644 --- a/apps/desktop/src/i18n/locales/az.ts +++ b/apps/desktop/src/i18n/locales/az.ts @@ -5995,6 +5995,13 @@ export default withEnglishFallback({ rebuildDataOnlyDisabled: "Yalnız məlumat köçürmələri üçün yenidən qurma əlçatan deyil. Struktur və məlumatları və ya yalnız strukturu seçin.", rebuildUnsupportedDisabled: "Seçilmiş hədəf mühərriki hədəf cədvəllərin yenidən qurulmasını dəstəkləmir.", rebuildPreviewUnavailable: "Server tərəfi yenidən qurma planını təqdim etmədi. Köçürmə başlamayıb; yenidən qurmanı dəstəkləyən server tərəfi ilə önbaxışı yeniləyin.", + structurePreviewTitle: "Struktur SQL önbaxışı", + structurePreviewDanger: "Bunlar köçürmənin hədəfdə icra edəcəyi struktur ifadələridir və yalnız oxumaq üçün göstərilir. Köçürmə başlayarkən DBX cari hədəf strukturunu yenidən yoxlayır, ona görə bu arada dəyişən hədəf son icra olunan ifadələri dəyişə bilər.", + structurePreviewSummary: "{count} cədvəlin strukturu yaradılacaq və ya yenilənəcək.", + structurePreviewPreexistingTargets: "Bəzi hədəf cədvəlləri artıq mövcuddur: cari icra davranışı ilə eyni şəkildə DBX onlar üçün struktur DDL icra etmir.", + structurePreviewUnexpandedObjects: "Seçilmiş cədvəldən başqa obyektlər ({objects}) icra zamanı köçürülür; onların yaradılan DDL-i bu önbaxışda göstərilmir.", + structurePreviewRevalidation: "Yalnız önbaxış: icradan əvvəl DBX cari hədəf strukturunu yenidən yoxlayır.", + structurePreviewUnavailable: "Server tərəfi struktur SQL önbaxışını təqdim etmədi. Köçürmə başlamayıb; struktur önbaxışını dəstəkləyən server tərəfi ilə yenidən cəhd edin.", previewFailed: "Köçürməni hazırlamaq mümkün olmadı: {message}", start: "Köçürməni başlat", startConfirmTitle: "Köçürməni təsdiqlə", diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts index dd5f25c53f..b542b2bc9e 100644 --- a/apps/desktop/src/i18n/locales/en.ts +++ b/apps/desktop/src/i18n/locales/en.ts @@ -6764,6 +6764,13 @@ export default { 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.", rebuildMissingTargets: "Some target tables do not exist yet and will be created without a backup.", + structurePreviewTitle: "Structure SQL preview", + structurePreviewDanger: "These are the structure statements this transfer is about to run on the target, shown read-only. DBX re-checks the current target structure when the transfer starts, so a target that changed in the meantime can change what finally runs.", + structurePreviewSummary: "Structure will be created or updated for {count} table(s).", + structurePreviewPreexistingTargets: "Some target tables already exist: DBX runs no structure DDL for them, matching how the transfer executes today.", + structurePreviewUnexpandedObjects: "Selected non-table objects ({objects}) are transferred during execution; their generated DDL is not expanded in this preview.", + structurePreviewRevalidation: "Preview only: DBX re-validates the current target structure before executing.", + structurePreviewUnavailable: "The backend did not provide a structure SQL preview. The transfer has not started; refresh the preview with a backend that supports structure previews.", previewFailed: "Could not prepare the transfer: {message}", start: "Start Transfer", startConfirmTitle: "Confirm transfer", diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts index 30fcb2b311..9abc371bcb 100644 --- a/apps/desktop/src/i18n/locales/es.ts +++ b/apps/desktop/src/i18n/locales/es.ts @@ -6171,6 +6171,14 @@ export default withEnglishFallback({ 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.", rebuildMissingTargets: "Algunas tablas de destino aún no existen y se crearán sin copia de seguridad.", + structurePreviewTitle: "Vista previa del SQL de estructura", + structurePreviewDanger: + "Estas son las sentencias de estructura que la transferencia ejecutará en el destino, mostradas solo para lectura. DBX vuelve a comprobar la estructura del destino al iniciar la transferencia, así que un destino que cambie mientras tanto puede cambiar lo que finalmente se ejecuta.", + structurePreviewSummary: "Se creará o actualizará la estructura de {count} tabla(s).", + structurePreviewPreexistingTargets: "Algunas tablas de destino ya existen: DBX no ejecuta DDL de estructura para ellas, igual que en la ejecución actual.", + structurePreviewUnexpandedObjects: "Los objetos seleccionados que no son tablas ({objects}) se transfieren durante la ejecución; su DDL generado no se detalla en esta vista previa.", + structurePreviewRevalidation: "Solo vista previa: DBX vuelve a validar la estructura actual del destino antes de ejecutar.", + structurePreviewUnavailable: "El backend no devolvió una vista previa del SQL de estructura. 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", diff --git a/apps/desktop/src/i18n/locales/id.ts b/apps/desktop/src/i18n/locales/id.ts index bc01b8c04a..55389ff091 100644 --- a/apps/desktop/src/i18n/locales/id.ts +++ b/apps/desktop/src/i18n/locales/id.ts @@ -6578,6 +6578,13 @@ export default withEnglishFallback({ rebuildUnsupportedDisabled: "Engine target yang dipilih tidak mendukung pembangunan ulang tabel target.", rebuildPreviewUnavailable: "Backend tidak menyediakan rencana pembangunan ulang. Transfer belum dimulai; segarkan pratinjau dengan backend yang mendukung pembangunan ulang.", rebuildMissingTargets: "Beberapa tabel target belum ada dan akan dibuat tanpa cadangan.", + structurePreviewTitle: "Pratinjau SQL struktur", + structurePreviewDanger: "Ini adalah pernyataan struktur yang akan dijalankan transfer ini pada target, ditampilkan hanya untuk dibaca. DBX memeriksa ulang struktur target saat transfer dimulai, jadi target yang berubah di sela itu dapat mengubah pernyataan yang akhirnya dijalankan.", + structurePreviewSummary: "Struktur akan dibuat atau diperbarui untuk {count} tabel.", + structurePreviewPreexistingTargets: "Beberapa tabel target sudah ada: sama seperti perilaku eksekusi saat ini, DBX tidak menjalankan DDL struktur untuk tabel tersebut.", + structurePreviewUnexpandedObjects: "Objek terpilih selain tabel ({objects}) ditransfer saat eksekusi; DDL yang dihasilkan tidak dijabarkan di pratinjau ini.", + structurePreviewRevalidation: "Hanya pratinjau: DBX memvalidasi ulang struktur target saat ini sebelum menjalankan.", + structurePreviewUnavailable: "Backend tidak menyediakan pratinjau SQL struktur. Transfer belum dimulai; segarkan pratinjau dengan backend yang mendukung pratinjau struktur.", previewFailed: "Tidak dapat menyiapkan transfer: {message}", start: "Mulai Transfer", startConfirmTitle: "Konfirmasi transfer", diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts index 33f427ac1d..4ee7972eb9 100644 --- a/apps/desktop/src/i18n/locales/it.ts +++ b/apps/desktop/src/i18n/locales/it.ts @@ -5987,6 +5987,14 @@ export default withEnglishFallback({ 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.", rebuildMissingTargets: "Alcune tabelle di destinazione non esistono ancora e verranno create senza backup.", + structurePreviewTitle: "Anteprima SQL della struttura", + structurePreviewDanger: + "Queste sono le istruzioni di struttura che il trasferimento eseguirà sulla destinazione, mostrate in sola lettura. DBX ricontrolla la struttura di destinazione all'avvio del trasferimento, quindi una destinazione modificata nel frattempo può cambiare ciò che viene effettivamente eseguito.", + structurePreviewSummary: "La struttura verrà creata o aggiornata per {count} tabelle.", + structurePreviewPreexistingTargets: "Alcune tabelle di destinazione esistono già: DBX non esegue DDL di struttura per esse, come nell'esecuzione attuale.", + structurePreviewUnexpandedObjects: "Gli oggetti selezionati diversi dalle tabelle ({objects}) vengono trasferiti durante l'esecuzione; il DDL generato non è riportato in questa anteprima.", + structurePreviewRevalidation: "Solo anteprima: DBX rivalida la struttura di destinazione attuale prima di eseguire.", + structurePreviewUnavailable: "Il backend non ha restituito un'anteprima SQL della struttura. Il trasferimento non è iniziato; ripetere l'anteprima con un backend compatibile.", previewFailed: "Impossibile preparare il trasferimento: {message}", start: "Avvia Trasferimento", startConfirmTitle: "Conferma trasferimento", diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts index 64539a5ec0..45a9b9a60f 100644 --- a/apps/desktop/src/i18n/locales/ja.ts +++ b/apps/desktop/src/i18n/locales/ja.ts @@ -6009,6 +6009,13 @@ export default withEnglishFallback({ rebuildUnsupportedDisabled: "選択したターゲットエンジンはテーブルの再構築をサポートしていません。", rebuildPreviewUnavailable: "バックエンドから再構築計画が返されなかったため、転送は開始されていません。再構築プレビューに対応したバックエンドで再試行してください。", rebuildMissingTargets: "存在しないターゲットテーブルがあります。バックアップなしで直接作成されます。", + structurePreviewTitle: "構造 SQL プレビュー", + structurePreviewDanger: "これは今回の転送でターゲットに対して実行される構造ステートメントの読み取り専用プレビューです。転送開始時に DBX が現在のターゲット構造を再確認するため、その間にターゲットが変更された場合は実際に実行されるステートメントが変わる可能性があります。", + structurePreviewSummary: "{count} 件のテーブルの構造を作成または更新します。", + structurePreviewPreexistingTargets: "一部のターゲットテーブルは既に存在します。現在の実行動作と同じく、DBX はそれらの構造 DDL を実行しません。", + structurePreviewUnexpandedObjects: "選択された非テーブルオブジェクト({objects})は実行時に転送されますが、生成される DDL はこのプレビューでは展開されません。", + structurePreviewRevalidation: "プレビューのみ:実行前に DBX が現在のターゲット構造を再検証します。", + structurePreviewUnavailable: "バックエンドから構造 SQL プレビューが返らなかったため、転送は開始されていません。構造プレビューに対応したバックエンドで再試行してください。", previewFailed: "転送を準備できませんでした:{message}", start: "転送開始", startConfirmTitle: "転送の開始確認", diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts index 1da193af1c..65526fd659 100644 --- a/apps/desktop/src/i18n/locales/ko.ts +++ b/apps/desktop/src/i18n/locales/ko.ts @@ -5742,6 +5742,13 @@ export default withEnglishFallback({ rebuildUnsupportedDisabled: "선택한 대상 엔진은 대상 테이블 재구축을 지원하지 않습니다.", rebuildPreviewUnavailable: "백엔드가 재구축 계획을 반환하지 않아 전송을 시작하지 않았습니다. 재구축 미리 보기를 지원하는 백엔드에서 다시 시도하세요.", rebuildMissingTargets: "존재하지 않는 대상 테이블이 있습니다. 백업 없이 바로 생성됩니다.", + structurePreviewTitle: "구조 SQL 미리 보기", + structurePreviewDanger: "이것은 이번 전송이 대상에 실행할 구조 문의 읽기 전용 미리 보기입니다. 전송을 시작할 때 DBX가 현재 대상 구조를 다시 확인하므로, 그 사이 대상이 변경되면 실제 실행되는 문이 달라질 수 있습니다.", + structurePreviewSummary: "{count}개 테이블의 구조를 만들거나 갱신합니다.", + structurePreviewPreexistingTargets: "일부 대상 테이블이 이미 있습니다. 현재 실행 동작과 동일하게 DBX는 해당 테이블의 구조 DDL을 실행하지 않습니다.", + structurePreviewUnexpandedObjects: "선택한 비테이블 개체({objects})는 실행 단계에서 전송되며, 생성되는 DDL은 이 미리 보기에 표시되지 않습니다.", + structurePreviewRevalidation: "미리 보기 전용: 실행 전에 DBX가 현재 대상 구조를 다시 검증합니다.", + structurePreviewUnavailable: "백엔드가 구조 SQL 미리 보기를 반환하지 않아 전송을 시작하지 않았습니다. 구조 미리 보기를 지원하는 백엔드에서 다시 시도하세요.", previewFailed: "전송을 준비할 수 없습니다: {message}", start: "이전 시작", startConfirmTitle: "전송 시작 확인", diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts index 2fd56d8c70..ce255e2b5c 100644 --- a/apps/desktop/src/i18n/locales/pt-BR.ts +++ b/apps/desktop/src/i18n/locales/pt-BR.ts @@ -5989,6 +5989,13 @@ export default withEnglishFallback({ 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.", rebuildMissingTargets: "Algumas tabelas de destino ainda não existem e serão criadas sem backup.", + structurePreviewTitle: "Prévia do SQL de estrutura", + structurePreviewDanger: "Estas são as instruções de estrutura que a transferência executará no destino, exibidas somente para leitura. O DBX revalida a estrutura de destino ao iniciar a transferência, então um destino alterado nesse intervalo pode mudar o que será executado.", + structurePreviewSummary: "A estrutura será criada ou atualizada em {count} tabela(s).", + structurePreviewPreexistingTargets: "Algumas tabelas de destino já existem: o DBX não executa DDL de estrutura para elas, igual à execução atual.", + structurePreviewUnexpandedObjects: "Os objetos selecionados que não são tabelas ({objects}) são transferidos durante a execução; o DDL gerado não é detalhado nesta prévia.", + structurePreviewRevalidation: "Apenas prévia: o DBX revalida a estrutura atual do destino antes de executar.", + structurePreviewUnavailable: "O backend não retornou uma prévia do SQL de estrutura. 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", diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts index 560cc3b61e..e6e6e6adbc 100644 --- a/apps/desktop/src/i18n/locales/ru.ts +++ b/apps/desktop/src/i18n/locales/ru.ts @@ -7131,6 +7131,13 @@ export default withEnglishFallback({ rebuildUnsupportedDisabled: "Выбранный целевой движок не поддерживает перестроение целевых таблиц.", rebuildPreviewUnavailable: "Серверная часть не предоставила план перестроения. Перенос не начат; обновите предпросмотр на серверной части с поддержкой перестроения.", rebuildMissingTargets: "Некоторые целевые таблицы ещё не существуют и будут созданы без резервной копии.", + structurePreviewTitle: "Предпросмотр SQL структуры", + structurePreviewDanger: "Это доступные только для чтения структурные операторы, которые перенос выполнит на цели. При запуске переноса DBX заново проверяет текущую структуру целевой базы, поэтому изменённая за это время цель может привести к другим фактическим операторам.", + structurePreviewSummary: "Структура будет создана или обновлена для таблиц: {count}.", + structurePreviewPreexistingTargets: "Некоторые целевые таблицы уже существуют: как и при текущем выполнении, DBX не выполняет для них структурный DDL.", + structurePreviewUnexpandedObjects: "Выбранные объекты, не являющиеся таблицами ({objects}), переносятся во время выполнения; их DDL не раскрывается в этом предпросмотре.", + structurePreviewRevalidation: "Только предпросмотр: перед выполнением DBX повторно проверяет текущую структуру цели.", + structurePreviewUnavailable: "Серверная часть не вернула предпросмотр SQL структуры. Перенос не начат; повторите предпросмотр на серверной части с поддержкой структуры.", previewFailed: "Не удалось подготовить перенос: {message}", start: "Начать перенос", startConfirmTitle: "Подтвердите перенос", diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.ts index 50740b724c..dd1f9b8aa6 100644 --- a/apps/desktop/src/i18n/locales/tr.ts +++ b/apps/desktop/src/i18n/locales/tr.ts @@ -5910,6 +5910,13 @@ export default withEnglishFallback({ ownershipSkipDetails: "Atla seçeneği, nesne sahipliği değiştirme ifadelerini çalıştırmaz. Tablo verisi ve diğer yapı eşitlemesi devam eder.", ownershipTargetOwner: "Onayla seçeneği, sahibi eksik nesneleri hedef bağlantı kullanıcısına atar: {owner}.", ownershipSkip: "Atla", + structurePreviewTitle: "Yapı SQL önizlemesi", + structurePreviewDanger: "Bunlar bu aktarımın hedefte çalıştıracağı yapı ifadeleridir ve yalnızca okunmak üzere gösterilir. Aktarım başlarken DBX güncel hedef yapısını yeniden denetler; bu arada değişen bir hedef, sonunda çalışan ifadeleri değiştirebilir.", + structurePreviewSummary: "{count} tablonun yapısı oluşturulacak veya güncellenecek.", + structurePreviewPreexistingTargets: "Bazı hedef tablolar zaten var: mevcut çalıştırma davranışıyla aynı şekilde DBX onlar için yapı DDL çalıştırmaz.", + structurePreviewUnexpandedObjects: "Seçilen tablo dışı nesneler ({objects}) aktarım sırasında taşınır; üretilen DDL bu önizlemede açılmaz.", + structurePreviewRevalidation: "Yalnızca önizleme: DBX çalıştırmadan önce güncel hedef yapısını yeniden doğrular.", + structurePreviewUnavailable: "Sunucu tarafı yapı SQL önizlemesini sağlamadı. Aktarım başlatılmadı; önizlemeyi yapı önizlemesini destekleyen bir sunucu tarafıyla yenileyin.", ownershipConfirm: "Onayla", selectConnection: "Bağlantı seç", selectDatabase: "Veritabanı seç", diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts index f7c4e41e16..0425041726 100644 --- a/apps/desktop/src/i18n/locales/zh-CN.ts +++ b/apps/desktop/src/i18n/locales/zh-CN.ts @@ -6750,6 +6750,13 @@ export default withEnglishFallback({ rebuildUnsupportedDisabled: "当前目标引擎不支持重建目标表。", rebuildPreviewUnavailable: "后端未返回重建计划,传输尚未开始。请使用支持重建预览的后端后重新预览。", rebuildMissingTargets: "部分目标表尚不存在,将直接创建(无备份)。", + structurePreviewTitle: "结构 SQL 预览", + structurePreviewDanger: "以下是本次传输即将在目标端执行的结构语句,仅只读展示。开始传输时 DBX 会重新检查当前目标结构,若目标在此期间发生变化,最终执行的语句可能与预览不同。", + structurePreviewSummary: "将为 {count} 张表创建或更新结构。", + structurePreviewPreexistingTargets: "部分目标表已存在:与当前执行行为一致,DBX 不会为其执行结构 DDL。", + structurePreviewUnexpandedObjects: "所选的非表对象({objects})会在执行阶段传输,其生成的 DDL 未在本预览中展开。", + structurePreviewRevalidation: "仅为预览:执行前 DBX 会重新校验当前目标结构。", + structurePreviewUnavailable: "后端未返回结构 SQL 预览,传输尚未开始。请使用支持结构预览的后端后重新预览。", previewFailed: "无法准备传输:{message}", start: "开始传输", startConfirmTitle: "确认开始传输", diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts index 46a4468645..401abe29dc 100644 --- a/apps/desktop/src/i18n/locales/zh-TW.ts +++ b/apps/desktop/src/i18n/locales/zh-TW.ts @@ -5319,6 +5319,13 @@ export default withEnglishFallback({ rebuildUnsupportedDisabled: "目前目標引擎不支援重建目標表。", rebuildPreviewUnavailable: "後端未傳回重建計畫,傳輸尚未開始。請使用支援重建預覽的後端後重新預覽。", rebuildMissingTargets: "部分目標資料表尚不存在,將直接建立(無備份)。", + structurePreviewTitle: "結構 SQL 預覽", + structurePreviewDanger: "以下是本次傳輸即將在目標端執行的結構語句,僅供唯讀檢視。開始傳輸時 DBX 會重新檢查目前的目標結構;若目標在這段期間發生變化,最終執行的語句可能與預覽不同。", + structurePreviewSummary: "將為 {count} 個資料表建立或更新結構。", + structurePreviewPreexistingTargets: "部分目標資料表已存在:與目前執行行為一致,DBX 不會為其執行結構 DDL。", + structurePreviewUnexpandedObjects: "所選的非資料表物件({objects})會在執行階段傳輸,其產生的 DDL 未在此預覽中展開。", + structurePreviewRevalidation: "僅為預覽:執行前 DBX 會重新驗証目前的目標結構。", + structurePreviewUnavailable: "後端未傳回結構 SQL 預覽,傳輸尚未開始。請使用支援結構預覽的後端後重新預覽。", previewFailed: "無法準備傳輸:{message}", start: "開始傳輸", startConfirmTitle: "確認開始傳輸", diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts index 12b38304ef..6609819408 100644 --- a/apps/desktop/src/lib/backend/tauri.ts +++ b/apps/desktop/src/lib/backend/tauri.ts @@ -5450,13 +5450,32 @@ export interface TransferRequest { dropTargetConfirmed: boolean; } +export interface TransferStructurePreviewTable { + sourceTable: string; + targetTable: string; + /** The target table already exists, so this transfer plans no structure DDL for it. */ + preexisting: boolean; + sql: string; +} + +export interface TransferStructurePreview { + sql: string; + tables: TransferStructurePreviewTable[]; +} + export interface TransferOwnershipPreview { missingOwners: string[]; targetOwner: string; rebuild?: { sql: string; tables: Array<{ sourceTable: string; targetTable: string; backupTable?: string }>; + /** The rename phase on its own, so the structure plan can sit between rename and cleanup. */ + backupSql?: string; + /** The drop-backups phase on its own. */ + cleanupSql?: string; }; + /** Structure-plan preview: present for structure-only transfers. */ + structure?: TransferStructurePreview; } export interface TransferProgress { diff --git a/crates/dbx-core/src/data/transfer.rs b/crates/dbx-core/src/data/transfer.rs index e51a73a129..aabdff766a 100644 --- a/crates/dbx-core/src/data/transfer.rs +++ b/crates/dbx-core/src/data/transfer.rs @@ -23,6 +23,7 @@ mod iris_tests; mod db2; mod ddl_plan; +mod structure_plan; use crate::connection::{config_for_pool_key, AppState, PoolKind}; use crate::db; @@ -297,6 +298,12 @@ pub struct TransferOwnershipPreview { pub missing_owners: Vec, pub target_owner: String, pub rebuild: Option, + /// Structure statements a structure-only transfer is about to run. Absent for every + /// other content mode (`dataOnly` has no DDL, `structureAndData` keeps its current + /// behavior). Built without executing any DDL, but not a frozen script: `start_transfer` + /// re-reads source and target metadata before executing. + #[serde(skip_serializing_if = "Option::is_none")] + pub structure: Option, } /// SQL plan preview for a `drop_target_before_create` (rebuild) transfer. @@ -309,6 +316,13 @@ pub struct TransferOwnershipPreview { pub struct TransferRebuildPreview { pub sql: String, pub tables: Vec, + /// The backup (rename) phase on its own, for callers that place the structure preview + /// between the rename and the cleanup phases instead of showing the combined `sql`. + #[serde(skip_serializing_if = "Option::is_none")] + pub backup_sql: Option, + /// The cleanup (drop backups) phase on its own. `sql` stays the combined plan. + #[serde(skip_serializing_if = "Option::is_none")] + pub cleanup_sql: Option, } #[derive(Debug, Clone, Serialize)] @@ -320,6 +334,31 @@ pub struct TransferRebuildPreviewTable { pub backup_table: Option, } +/// SQL plan preview for a structure-only transfer. +/// +/// Plans rather than executes: every statement comes from the generator the execution pass +/// uses for the same operation, so preview and execution can never disagree on the DDL they +/// render. It is still a preview — the target is re-inspected when the transfer starts. +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct TransferStructurePreview { + pub sql: String, + pub tables: Vec, +} + +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct TransferStructurePreviewTable { + pub source_table: String, + pub target_table: String, + /// The target table already exists and this transfer plans no structure DDL for it, + /// mirroring the execution pass' skip when the target table is present. + pub preexisting: bool, + /// The structure the transfer plans for this table, or an explanatory comment when the + /// execution pass will skip the table entirely. + pub sql: String, +} + impl TransferRequest { pub fn target_table_name(&self, source_table: &str) -> String { match self.target_table_name_case { @@ -7385,28 +7424,39 @@ async fn get_existing_postgres_sequence_names_for_transfer( .collect()) } -/// Create owned PostgreSQL sequences before executing reused table DDL because -/// serial defaults still reference `nextval('...')` in `CREATE TABLE`. -async fn prepare_postgres_owned_sequences_for_transfer( +/// Read-only half of [`prepare_postgres_owned_sequences_for_transfer`]: resolves which +/// owned sequences the transfer must create and renders their `CREATE SEQUENCE` statements, +/// executing nothing. +/// +/// The structure SQL preview calls this so it can show the same sequence DDL the transfer +/// pass will run (and the serial-column rewrite that DDL implies) without ever triggering a +/// statement. Nothing in here may execute DDL — that is what +/// [`execute_planned_postgres_owned_sequences_for_transfer`] is for. +struct PlannedPostgresOwnedSequences { + create_statements: Vec, + owned_sequences: Vec, +} + +#[allow(clippy::too_many_arguments)] +async fn plan_postgres_owned_sequences_for_transfer( state: &AppState, request: &TransferRequest, table: &str, - target_table: &str, source_pool_key: &str, target_pool_key: &str, pg_compat_transfer: bool, preserves_target_table_name: bool, target_table_preexisting: bool, -) -> Result, String> { +) -> Result { if !(request.create_table && pg_compat_transfer && preserves_target_table_name && !target_table_preexisting) { - return Ok(Vec::new()); + return Ok(PlannedPostgresOwnedSequences { create_statements: Vec::new(), owned_sequences: Vec::new() }); } let owned_sequences = get_postgres_owned_sequences_for_transfer(state, source_pool_key, &request.source_schema, &[table.to_string()]) .await?; if owned_sequences.is_empty() { - return Ok(Vec::new()); + return Ok(PlannedPostgresOwnedSequences { create_statements: Vec::new(), owned_sequences }); } let sequence_names = owned_sequences.iter().map(|sequence| sequence.name.clone()).collect::>(); @@ -7425,6 +7475,7 @@ async fn prepare_postgres_owned_sequences_for_transfer( .collect::>(); let sequence_if_not_exists = target_supports_if_not_exists_ddl(state, target_pool_key).await; + let mut create_statements = Vec::new(); for sequence in &owned_sequences { let should_create = validate_existing_postgres_sequence( sequence, @@ -7435,18 +7486,69 @@ async fn prepare_postgres_owned_sequences_for_transfer( let definition = definitions .get(&sequence.name) .ok_or_else(|| format!("PostgreSQL sequence definition not found: {}", sequence.name))?; - let create_sql = generate_postgres_transfer_sequence_create_ddl( + create_statements.push(generate_postgres_transfer_sequence_create_ddl( definition, &request.target_schema, sequence_if_not_exists, - ); - execute_on_pool(state, target_pool_key, &create_sql) - .await - .map_err(|e| format!("Failed to create PostgreSQL sequence for {target_table}: {e}"))?; + )); } } - Ok(owned_sequences) + Ok(PlannedPostgresOwnedSequences { create_statements, owned_sequences }) +} + +/// Executes the `CREATE SEQUENCE` statements a [`PlannedPostgresOwnedSequences`] planned. +async fn execute_planned_postgres_owned_sequences_for_transfer( + state: &AppState, + target_pool_key: &str, + target_table: &str, + plan: &PlannedPostgresOwnedSequences, +) -> Result<(), String> { + for create_sql in &plan.create_statements { + execute_on_pool(state, target_pool_key, create_sql) + .await + .map_err(|e| format!("Failed to create PostgreSQL sequence for {target_table}: {e}"))?; + } + Ok(()) +} + +/// Create owned PostgreSQL sequences before executing reused table DDL because +/// serial defaults still reference `nextval('...')` in `CREATE TABLE`. +async fn prepare_postgres_owned_sequences_for_transfer( + state: &AppState, + request: &TransferRequest, + table: &str, + target_table: &str, + source_pool_key: &str, + target_pool_key: &str, + pg_compat_transfer: bool, + preserves_target_table_name: bool, + target_table_preexisting: bool, +) -> Result, String> { + let plan = plan_postgres_owned_sequences_for_transfer( + state, + request, + table, + source_pool_key, + target_pool_key, + pg_compat_transfer, + preserves_target_table_name, + target_table_preexisting, + ) + .await?; + execute_planned_postgres_owned_sequences_for_transfer(state, target_pool_key, target_table, &plan).await?; + Ok(plan.owned_sequences) +} + +/// Bind a planned sequence to its column after the table exists. Shared with the structure +/// SQL preview so both render the identical statement. +fn postgres_owned_sequence_bind_sql(request: &TransferRequest, sequence: &PostgresOwnedSequence) -> String { + format!( + "ALTER SEQUENCE {} OWNED BY {}.{}", + postgres_sequence_qualified_name(&request.target_schema, &sequence.name), + qualified_table(&sequence.owner_table, &request.target_schema, &DatabaseType::Postgres, None), + quote_identifier(&sequence.owner_column, &DatabaseType::Postgres) + ) } /// Bind created or reused sequences after the table exists so @@ -7459,12 +7561,7 @@ async fn bind_postgres_owned_sequences_for_transfer( owned_sequences: &[PostgresOwnedSequence], ) -> Result<(), String> { for sequence in owned_sequences { - let owner_sql = format!( - "ALTER SEQUENCE {} OWNED BY {}.{}", - postgres_sequence_qualified_name(&request.target_schema, &sequence.name), - qualified_table(&sequence.owner_table, &request.target_schema, &DatabaseType::Postgres, None), - quote_identifier(&sequence.owner_column, &DatabaseType::Postgres) - ); + let owner_sql = postgres_owned_sequence_bind_sql(request, sequence); execute_on_pool(state, target_pool_key, &owner_sql) .await .map_err(|e| format!("Failed to bind PostgreSQL sequence for {target_table}: {e}"))?; @@ -8535,18 +8632,28 @@ async fn build_rebuild_preview( } let mut phases: Vec = Vec::new(); - if !rename_statements.is_empty() { - phases.push(format!("-- 1. Backup existing target tables\n{}", rename_statements.join(";\n"))); + let backup_sql = if rename_statements.is_empty() { + None + } else { + Some(format!("-- 1. Backup existing target tables\n{}", rename_statements.join(";\n"))) + }; + let cleanup_sql = if drop_statements.is_empty() { + None + } else { + Some(format!("-- 3. Drop backups after success\n{}", drop_statements.join(";\n"))) + }; + if let Some(sql) = &backup_sql { + phases.push(sql.clone()); } 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"))); + if let Some(sql) = &cleanup_sql { + phases.push(sql.clone()); } - Ok(TransferRebuildPreview { sql: phases.join("\n\n"), tables }) + Ok(TransferRebuildPreview { sql: phases.join("\n\n"), tables, backup_sql, cleanup_sql }) } pub async fn preview_transfer_ownership( @@ -8592,7 +8699,26 @@ pub async fn preview_transfer_ownership( None }; - Ok(TransferOwnershipPreview { missing_owners, target_owner, rebuild }) + // Structure-only transfers expose the statements their create pass will run. The other + // content modes keep their existing previews: data-only runs no DDL, and + // structure-and-data is deliberately unchanged here. + let structure = if matches!(request.content, TransferContent::StructureOnly) { + Some( + structure_plan::build_structure_preview( + state, + request, + source_db_type, + target_db_type, + source_pool_key, + target_pool_key, + ) + .await?, + ) + } else { + None + }; + + Ok(TransferOwnershipPreview { missing_owners, target_owner, rebuild, structure }) } fn postgres_transfer_grant_statements_sql( diff --git a/crates/dbx-core/src/data/transfer/ddl_plan.rs b/crates/dbx-core/src/data/transfer/ddl_plan.rs index 3c26c07ba5..8b6149a1ac 100644 --- a/crates/dbx-core/src/data/transfer/ddl_plan.rs +++ b/crates/dbx-core/src/data/transfer/ddl_plan.rs @@ -1,8 +1,10 @@ //! 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. +//! The transfer pass and the structure-only SQL 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. The +//! preview is still a plan, not a frozen script — the transfer pass re-reads source and +//! target metadata (and re-runs its fail-closed checks) when it starts. use super::*; diff --git a/crates/dbx-core/src/data/transfer/structure_plan.rs b/crates/dbx-core/src/data/transfer/structure_plan.rs new file mode 100644 index 0000000000..fab43c2141 --- /dev/null +++ b/crates/dbx-core/src/data/transfer/structure_plan.rs @@ -0,0 +1,603 @@ +//! Read-only planning for the structure-only transfer SQL preview. +//! +//! A structure-only transfer used to start with no idea what it would run. This module +//! renders the statements the create pass is about to execute so the confirmation dialog can +//! show them first. It is strictly planning: target names, source metadata and the SQL are +//! read from the same helpers the execution pass uses (`ddl_plan::prepare_table_ddl`, +//! `plan_postgres_owned_sequences_for_transfer`, `generate_comment_ddl_with_column_quoting`, +//! `generate_postgres_index_ddl`, `generate_postgres_foreign_key_ddl`, +//! `generate_mysql_foreign_key_alter_statements`), and no statement is ever executed here. +//! +//! The result is a plan, not a frozen script: `start_transfer` re-reads source and target +//! metadata before it executes, and the existing execution-time fail-closed checks stay in +//! force. Callers must therefore never present the preview as "these exact statements will +//! run". +//! +//! Where the create pass normalizes before executing (splitting a reused PostgreSQL table +//! script, stripping inline foreign keys, dropping the post-table index/foreign-key statements +//! it re-applies from metadata), the preview runs the same normalization — a statement the +//! executor filters out must not be shown. Re-applied statements are shown once per step, +//! including the idempotent `COMMENT` the reused script may already contain. + +use super::*; + +/// Emitted when the request asks for no structure DDL at all (`createTable = false`). +const CREATE_TABLE_DISABLED_NOTE: &str = + "-- This transfer has structure DDL disabled (createTable = false): no structure statements will run."; + +/// Emitted when the transfer also moves non-table schema objects whose DDL this preview +/// deliberately does not expand (views, routines, triggers, standalone sequences, ...). +const UNEXPANDED_OBJECTS_NOTE: &str = "\ +-- Additional selected schema objects are transferred during execution. +-- Their generated DDL is not expanded in this preview."; + +/// Plan the structure DDL a structure-only transfer is about to run. +/// +/// Everything inside is read-only: metadata reads plus SQL rendering. The only statements +/// handed to `execute_on_pool` are catalog queries (`SELECT`), never DDL. +pub(super) async fn build_structure_preview( + state: &Arc, + request: &TransferRequest, + source_db_type: &DatabaseType, + target_db_type: &DatabaseType, + source_pool_key: &str, + target_pool_key: &str, +) -> Result { + if !request.create_table { + return Ok(TransferStructurePreview { sql: CREATE_TABLE_DISABLED_NOTE.to_string(), tables: Vec::new() }); + } + + let pg_compat_transfer = is_postgres_compat_transfer(source_db_type, target_db_type); + let index_if_not_exists = pg_compat_transfer && target_supports_if_not_exists_ddl(state, target_pool_key).await; + // Two execution paths create the target schema before any table does: the inline ensure in + // `create_transfer_target_table` (PostgreSQL-dialect target from another family) and + // `transfer_postgres_schema_dependencies` (PostgreSQL→PostgreSQL). Plan the same statement + // for either, deciding it with a read-only existence check instead of executing anything. + let create_schema_sql = if is_postgres_transfer_dialect(target_db_type) + && !request.target_schema.trim().is_empty() + && !postgres_schema_exists(state, target_pool_key, &request.target_schema).await? + { + Some(format!("CREATE SCHEMA {}", quote_identifier(&request.target_schema, target_db_type))) + } else { + None + }; + + // Same order and same foreign key metadata the create pass uses. + let (tables, known_foreign_keys) = sorted_source_tables_with_foreign_keys(state, request).await; + + let mut sections: Vec = Vec::new(); + if let Some(create_schema_sql) = &create_schema_sql { + sections.push(format!( + "-- Ensure the target schema exists\n{}", + statement_block(std::slice::from_ref(create_schema_sql)) + )); + } + + let mut planned_tables: Vec = Vec::with_capacity(tables.len()); + let mut table_sections: Vec = Vec::new(); + let mut deferred_fk_alters: Vec = Vec::new(); + + for table in &tables { + let ResolvedTransferTargetTable { name: target_table, 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; + // A rebuild renames every preexisting target aside before the create pass runs, so + // those tables are created fresh — the same reset the create pass performs. + if preexisting && !request.drop_target_before_create { + let note = format!( + "-- {table} -> {target_table}: the target table already exists, so this transfer plans no structure \ + DDL for it" + ); + planned_tables.push(TransferStructurePreviewTable { + source_table: table.clone(), + target_table, + preexisting: true, + sql: note.clone(), + }); + table_sections.push(note); + continue; + } + + let planned = plan_table_structure( + state, + request, + table, + &target_table, + source_db_type, + target_db_type, + source_pool_key, + target_pool_key, + &known_foreign_keys, + pg_compat_transfer, + index_if_not_exists, + ) + .await?; + deferred_fk_alters.extend(planned.deferred_fk_alters); + + let section = format!("-- {} -> {}\n{}", table, target_table, statement_block(&planned.statements)); + planned_tables.push(TransferStructurePreviewTable { + source_table: table.clone(), + target_table, + preexisting: false, + sql: section.clone(), + }); + table_sections.push(section); + } + + sections.extend(table_sections); + if !deferred_fk_alters.is_empty() { + // MySQL-family targets defer foreign keys so creation order never has to satisfy + // them; the create pass flushes these after every table exists. + sections.push(format!( + "-- Foreign keys added after every table exists, so creation order never has to satisfy them\n{}", + statement_block(&deferred_fk_alters) + )); + } + sections.extend(unexpanded_schema_object_notes(source_db_type, target_db_type, request)); + + Ok(TransferStructurePreview { sql: sections.join("\n\n"), tables: planned_tables }) +} + +struct PlannedTableStructure { + statements: Vec, + deferred_fk_alters: Vec, +} + +/// Render the statements the create pass runs for one table, in execution order. +#[allow(clippy::too_many_arguments)] +async fn plan_table_structure( + state: &Arc, + 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>, + pg_compat_transfer: bool, + index_if_not_exists: bool, +) -> Result { + let preserves_target_table_name = target_table == table; + let columns = source_transfer_columns(state, request, table, source_pool_key).await?; + let table_comment = source_table_comment(state, request, table, source_db_type).await; + + // Planned here, created by the execution pass. + let owned_sequences = plan_postgres_owned_sequences_for_transfer( + state, + request, + table, + source_pool_key, + target_pool_key, + pg_compat_transfer, + preserves_target_table_name, + false, + ) + .await?; + // Shared with `create_transfer_target_table`: the same helper renders the DDL that runs. + let prepared = ddl_plan::prepare_table_ddl( + state, + request, + table, + target_table, + source_db_type, + target_db_type, + source_pool_key, + &columns, + table_comment.as_deref(), + known_foreign_keys, + ) + .await?; + let ddl = if pg_compat_transfer && !owned_sequences.owned_sequences.is_empty() { + rewrite_postgres_serial_columns_for_transfer( + &prepared.ddl, + &owned_sequences.owned_sequences, + &request.target_schema, + ) + } else { + prepared.ddl + }; + + let mut statements = owned_sequences.create_statements.clone(); + // Normalize the DDL exactly like the executor does before running it: the reused + // PostgreSQL script spans several statements, has its inline foreign keys stripped, and + // drops the post-table index/foreign-key statements that are re-applied from structured + // metadata below. A statement the create pass filters out must never appear here. + statements.extend(transfer_ddl_statements(&ddl, target_db_type)); + statements.extend(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 sequence in &owned_sequences.owned_sequences { + statements.push(postgres_owned_sequence_bind_sql(request, sequence)); + } + if pg_compat_transfer && preserves_target_table_name { + // PostgreSQL-compatible targets restore indexes and foreign keys from structured + // source metadata once the table exists. + let indexes = get_postgres_indexes_for_transfer( + state, + source_pool_key, + &request.source_database, + &request.source_schema, + table, + ) + .await?; + statements.extend(generate_postgres_index_ddl( + &indexes, + target_table, + &request.target_schema, + index_if_not_exists, + )); + let foreign_keys = get_postgres_foreign_keys_for_transfer( + state, + source_pool_key, + &request.source_database, + &request.source_schema, + table, + ) + .await?; + statements.extend(generate_postgres_foreign_key_ddl( + &foreign_keys, + target_table, + &request.source_schema, + &request.target_schema, + )); + } + + Ok(PlannedTableStructure { statements, deferred_fk_alters: prepared.deferred_fk_alters }) +} + +/// Read and de-duplicate the source columns the create pass uses, failing the same way the +/// pass does when the source returns nothing. +async fn source_transfer_columns( + state: &AppState, + request: &TransferRequest, + table: &str, + source_pool_key: &str, +) -> Result, String> { + 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 = HashSet::new(); + let columns = raw.into_iter().filter(|column| seen.insert(column.name.clone())).collect::>(); + if columns.is_empty() { + return Err(format!("No columns found for table {table}")); + } + Ok(columns) +} + +/// Source table comment, via the same fallback chain the create pass uses. A metadata read +/// failure only drops the comment, exactly like execution. +async fn source_table_comment( + state: &Arc, + request: &TransferRequest, + table: &str, + source_db_type: &DatabaseType, +) -> Option { + if *source_db_type == DatabaseType::Postgres { + get_transfer_table_comment_isolated( + state.clone(), + request.source_connection_id.clone(), + request.source_database.clone(), + request.source_schema.clone(), + table.to_string(), + ) + .await + .unwrap_or_default() + } else { + list_transfer_tables_isolated( + state.clone(), + request.source_connection_id.clone(), + request.source_database.clone(), + request.source_schema.clone(), + request.source_catalog.clone(), + *source_db_type, + table.to_string(), + 1, + ) + .await + .unwrap_or_default() + .into_iter() + .next() + .and_then(|info| info.comment) + } +} + +/// Table creation order plus the foreign key metadata behind the deferred MySQL alters, using +/// the same helper (and the same external-catalog skip) the transfer pass uses. +async fn sorted_source_tables_with_foreign_keys( + state: &Arc, + request: &TransferRequest, +) -> (Vec, HashMap>) { + if request.tables.len() <= 1 { + return (request.tables.clone(), HashMap::new()); + } + let skip_fk_sort = { + let configs = state.configs.read().await; + configs + .get(&request.source_connection_id) + .and_then(|config| resolve_external_transfer_catalog_for_config(request.source_catalog.as_deref(), config)) + .is_some() + }; + if skip_fk_sort { + return (request.tables.clone(), HashMap::new()); + } + sort_tables_by_fk_dependency_with_foreign_keys( + state, + &request.source_connection_id, + &request.source_database, + &request.source_schema, + &request.tables, + true, + ) + .await + .unwrap_or_else(|error| { + log::warn!("[transfer] structure preview could not sort tables by FK dependency: {error}"); + (request.tables.clone(), HashMap::new()) + }) +} + +async fn postgres_schema_exists(state: &AppState, target_pool_key: &str, target_schema: &str) -> Result { + let result = execute_on_pool(state, target_pool_key, &postgres_schema_exists_sql(target_schema)).await?; + Ok(query_result_has_rows(&result)) +} + +/// The statement block the preview never expands: selected non-table schema objects. +fn unexpanded_schema_object_notes( + source_db_type: &DatabaseType, + target_db_type: &DatabaseType, + request: &TransferRequest, +) -> Vec { + if !should_transfer_schema_objects(source_db_type, target_db_type, &request.content, &request.objects) { + return Vec::new(); + } + let mut notes = vec![UNEXPANDED_OBJECTS_NOTE.to_string()]; + // An empty selection is the legacy PostgreSQL default (everything is transferred), so + // there is no concrete list to print — and the note above already says so. + for selection in &request.objects { + if selection.object_type == TransferObjectKind::Table || selection.names.is_empty() { + continue; + } + notes.push(format!("-- {}: {}", preview_object_kind_label(&selection.object_type), selection.names.join(", "))); + } + notes +} + +fn preview_object_kind_label(kind: &TransferObjectKind) -> &'static str { + match kind { + TransferObjectKind::Table => "Tables", + TransferObjectKind::View => "Views", + TransferObjectKind::MaterializedView => "Materialized views", + TransferObjectKind::Procedure => "Procedures", + TransferObjectKind::Function => "Functions", + TransferObjectKind::Trigger => "Triggers", + TransferObjectKind::Sequence => "Sequences", + TransferObjectKind::Event => "Events", + } +} + +fn statement_block(statements: &[String]) -> String { + statements + .iter() + .map(|statement| ensure_sql_statement_terminated(statement)) + .filter(|statement| !statement.is_empty() && statement != ";") + .collect::>() + .join("\n") +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + async fn sqlite_fixture() -> (tempfile::TempDir, Arc, String, String) { + let directory = tempfile::tempdir().unwrap(); + let storage = crate::persistence::test_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(); + } + (directory, state, source_pool, target_pool) + } + + fn structure_request(overrides: serde_json::Value) -> TransferRequest { + let mut 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": "structureOnly", + "mode": "append", "batchSize": 10 + }); + let map = value.as_object_mut().unwrap(); + for (key, override_value) in overrides.as_object().unwrap() { + map.insert(key.clone(), override_value.clone()); + } + serde_json::from_value(value).unwrap() + } + + async fn preview( + state: &Arc, + request: &TransferRequest, + source_pool: &str, + target_pool: &str, + ) -> Result { + preview_transfer_ownership( + state, + request, + &DatabaseType::Sqlite, + &DatabaseType::Sqlite, + source_pool, + target_pool, + ) + .await + } + + async fn target_table_names(state: &AppState, target_pool: &str) -> Vec { + let result = execute_read_on_pool( + state, + target_pool, + "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name", + ) + .await + .unwrap(); + result.rows.iter().filter_map(|row| json_string_cell(row, 0)).collect() + } + + #[tokio::test] + async fn structure_only_preview_plans_create_table_without_executing_ddl() { + let (_directory, state, source_pool, target_pool) = sqlite_fixture().await; + let request = structure_request(json!({})); + + let preview = preview(&state, &request, &source_pool, &target_pool).await.unwrap(); + let structure = preview.structure.expect("structure-only must expose its structure SQL plan"); + + assert_eq!(structure.tables.len(), 2, "every selected table must be planned: {:?}", structure.tables); + for table in &structure.tables { + assert!(!table.preexisting, "a fresh target has no preexisting tables: {table:?}"); + assert!(table.sql.contains("CREATE TABLE"), "{}", table.sql); + } + assert!(structure.sql.contains("orders"), "{}", structure.sql); + assert!(structure.sql.contains("users"), "{}", structure.sql); + + // Planning must not run any of it: the target database stays empty. + assert_eq!(target_table_names(&state, &target_pool).await, Vec::::new()); + } + + #[tokio::test] + async fn structure_only_preview_handles_preexisting_target_consistently() { + let (_directory, state, source_pool, target_pool) = sqlite_fixture().await; + execute_on_pool(&state, &target_pool, "CREATE TABLE orders(id INTEGER PRIMARY KEY, legacy TEXT)") + .await + .unwrap(); + execute_on_pool(&state, &target_pool, "INSERT INTO orders VALUES(7, 'original')").await.unwrap(); + let request = structure_request(json!({ "tables": ["orders"] })); + + let preview = preview(&state, &request, &source_pool, &target_pool).await.unwrap(); + let structure = preview.structure.expect("structure-only must expose its structure SQL plan"); + + assert_eq!(structure.tables.len(), 1); + assert!(structure.tables[0].preexisting, "an existing target must be reported as preexisting: {structure:?}"); + assert!( + !structure.sql.contains("CREATE TABLE"), + "execution skips create DDL for a preexisting target, so the preview must too: {}", + structure.sql + ); + assert!(structure.sql.contains("already exists"), "{}", structure.sql); + + // The preview must not have touched the preexisting table. + let rows = execute_read_on_pool(&state, &target_pool, "SELECT legacy FROM orders WHERE id = 7").await.unwrap(); + assert_eq!(rows.rows[0][0], json!("original")); + } + + #[tokio::test] + async fn structure_only_preview_without_create_table_reports_no_structure_ddl() { + let (_directory, state, source_pool, target_pool) = sqlite_fixture().await; + let request = structure_request(json!({ "createTable": false })); + + let preview = preview(&state, &request, &source_pool, &target_pool).await.unwrap(); + let structure = preview + .structure + .expect("structure-only always answers with a structure preview so clients can fail closed"); + + assert!(!structure.sql.contains("CREATE TABLE"), "{}", structure.sql); + assert!(structure.sql.contains("createTable = false"), "{}", structure.sql); + } + + #[tokio::test] + async fn data_only_has_no_structure_preview() { + let (_directory, state, source_pool, target_pool) = sqlite_fixture().await; + let request = structure_request(json!({ "content": "dataOnly", "createTable": false })); + + let preview = preview(&state, &request, &source_pool, &target_pool).await.unwrap(); + + assert!(preview.structure.is_none(), "data-only runs no structure DDL: {preview:?}"); + assert!(preview.rebuild.is_none()); + } + + #[tokio::test] + async fn structure_and_data_keeps_existing_preview_behavior() { + let (_directory, state, source_pool, target_pool) = sqlite_fixture().await; + execute_on_pool(&state, &target_pool, "CREATE TABLE orders(id INTEGER PRIMARY KEY, legacy TEXT)") + .await + .unwrap(); + let request = structure_request(json!({ "content": "structureAndData", "tables": ["orders"] })); + + let preview = preview(&state, &request, &source_pool, &target_pool).await.unwrap(); + + assert!( + preview.structure.is_none(), + "structure-and-data keeps its current behavior in this phase: {preview:?}" + ); + assert!(preview.rebuild.is_none()); + assert!(preview.missing_owners.is_empty()); + } + + #[tokio::test] + async fn rebuild_preview_still_contains_existing_rename_and_cleanup_sql() { + let (_directory, state, source_pool, target_pool) = sqlite_fixture().await; + for table in ["orders", "users"] { + execute_on_pool( + &state, + &target_pool, + &format!("CREATE TABLE {table}(id INTEGER PRIMARY KEY, legacy TEXT)"), + ) + .await + .unwrap(); + } + let request = structure_request(json!({ "dropTargetBeforeCreate": true, "dropTargetConfirmed": true })); + + let preview = preview(&state, &request, &source_pool, &target_pool).await.unwrap(); + let rebuild = preview.rebuild.expect("a rebuild transfer must expose its SQL plan"); + + 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); + assert!(rebuild.backup_sql.as_deref().unwrap_or_default().contains("RENAME"), "{rebuild:?}"); + assert!(rebuild.cleanup_sql.as_deref().unwrap_or_default().contains("DROP TABLE"), "{rebuild:?}"); + + // The structure plan is rendered without repeating the rename/cleanup operations. + let structure = preview.structure.expect("structure-only must expose its structure SQL plan"); + assert!(structure.sql.contains("CREATE TABLE"), "{}", structure.sql); + assert!(!structure.sql.contains("RENAME"), "{}", structure.sql); + assert!(!structure.sql.contains("DROP TABLE"), "{}", structure.sql); + for table in &structure.tables { + assert!(!table.preexisting, "a rebuild renames the old target aside, so it is created fresh: {table:?}"); + } + + // Still pure planning: nothing was renamed, nothing was dropped. + assert_eq!(target_table_names(&state, &target_pool).await, vec!["orders".to_string(), "users".to_string()]); + } +} diff --git a/crates/dbx-core/tests/live_postgres_transfer.rs b/crates/dbx-core/tests/live_postgres_transfer.rs index e103c9f688..64d0efc0b2 100644 --- a/crates/dbx-core/tests/live_postgres_transfer.rs +++ b/crates/dbx-core/tests/live_postgres_transfer.rs @@ -2,9 +2,10 @@ use dbx_core::connection::{AppState, PoolKind}; use dbx_core::db::postgres; use dbx_core::models::connection::{ConnectionConfig, DatabaseType}; use dbx_core::transfer::{ - 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, + drop_backup_tables, get_db_type, preview_transfer_ownership, 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; @@ -2112,3 +2113,175 @@ async fn live_postgres_keyset_large_batch_copies_every_row() { postgres::execute_batch(&target_pool, &[format!("DROP SCHEMA \"{target_schema}\" CASCADE")]).await.unwrap(); let _ = std::fs::remove_dir_all(dir); } + +/// The structure-only SQL preview is shown to the operator before anything runs, so it must +/// render the real PostgreSQL structure DDL — and it must not touch either database. +#[tokio::test] +#[ignore = "requires PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"] +async fn live_postgres_structure_only_preview_renders_ddl_without_touching_the_target() { + 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_scalar(&source_pool, "SELECT current_database()").await.as_str().unwrap().to_string(); + let target_database = query_scalar(&target_pool, "SELECT current_database()").await.as_str().unwrap().to_string(); + + let suffix = uuid::Uuid::new_v4().simple().to_string(); + let source_schema = format!("dbx_src_preview_{}", &suffix[..8]); + let target_schema = format!("dbx_dst_preview_{}", &suffix[..8]); + let missing_target_schema = format!("dbx_dst_missing_{}", &suffix[..8]); + + postgres::execute_batch( + &source_pool, + &[ + format!("CREATE SCHEMA \"{source_schema}\""), + format!("CREATE TABLE \"{source_schema}\".\"parent\" (\"id\" serial PRIMARY KEY)"), + format!( + "CREATE TABLE \"{source_schema}\".\"items\" (\"id\" serial PRIMARY KEY, \"parent_id\" integer REFERENCES \"{source_schema}\".\"parent\"(\"id\"), \"name\" text NOT NULL)" + ), + format!("COMMENT ON TABLE \"{source_schema}\".\"items\" IS 'preview items'"), + format!("COMMENT ON COLUMN \"{source_schema}\".\"items\".\"name\" IS 'preview name'"), + format!("CREATE INDEX \"items_name_idx\" ON \"{source_schema}\".\"items\" (\"name\")"), + format!("INSERT INTO \"{source_schema}\".\"parent\" DEFAULT VALUES"), + ], + ) + .await + .unwrap(); + postgres::execute_batch(&target_pool, &[format!("CREATE SCHEMA \"{target_schema}\"")]).await.unwrap(); + + let dir = std::env::temp_dir().join(format!("dbx-live-pg-structpreview-{suffix}")); + std::fs::create_dir_all(&dir).unwrap(); + let storage = dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.unwrap(); + let state = Arc::new(AppState::new(storage)); + let source_connection_id = "live-pg-preview-source"; + let target_connection_id = "live-pg-preview-target"; + let source_pool_key = format!("{source_connection_id}:{source_database}"); + let target_pool_key = format!("{target_connection_id}:{target_database}"); + 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; + state + .configs + .write() + .await + .insert(source_connection_id.to_string(), postgres_test_config(source_connection_id, &source_database)); + state + .configs + .write() + .await + .insert(target_connection_id.to_string(), postgres_test_config(target_connection_id, &target_database)); + + let request = TransferRequest { + transfer_id: format!("live-pg-preview-{suffix}"), + source_connection_id: source_connection_id.to_string(), + source_database: source_database.clone(), + source_schema: source_schema.clone(), + source_catalog: None, + target_connection_id: target_connection_id.to_string(), + target_database: target_database.clone(), + target_schema: target_schema.clone(), + target_catalog: None, + tables: vec!["items".to_string()], + create_table: true, + drop_target_before_create: false, + drop_target_confirmed: false, + content: TransferContent::StructureOnly, + // A selected non-table object must be disclosed as not expanded, never silently dropped. + objects: vec![TransferObjectSelection { + object_type: TransferObjectKind::Function, + names: vec!["preview_probe_function".to_string()], + }], + mode: TransferMode::Append, + target_table_name_case: TransferTableNameCase::Preserve, + quote_target_column_names: true, + ownership_policy: TransferOwnershipPolicy::Preserve, + batch_size: 1000, + }; + let source_db_type = get_db_type(&state, source_connection_id).await.unwrap(); + let target_db_type = get_db_type(&state, target_connection_id).await.unwrap(); + + let preview = preview_transfer_ownership( + &state, + &request, + &source_db_type, + &target_db_type, + &source_pool_key, + &target_pool_key, + ) + .await + .unwrap(); + let structure = preview.structure.expect("a structure-only transfer must plan its structure SQL"); + let sql = &structure.sql; + println!("--- structure-only preview ---\n{sql}\n--- end ---"); + + assert_eq!(structure.tables.len(), 1, "{:?}", structure.tables); + assert_eq!(structure.tables[0].source_table, "items"); + assert!(!structure.tables[0].preexisting); + assert!(sql.contains("CREATE TABLE"), "{sql}"); + assert!(sql.contains("items"), "{sql}"); + assert!( + sql.contains("CREATE INDEX IF NOT EXISTS") && sql.contains("items_name_idx"), + "indexes must be planned: {sql}" + ); + assert_eq!( + sql.matches("CREATE INDEX").count(), + 1, + "the create pass filters the source script's index statement, so the preview must not show it: {sql}" + ); + assert_eq!( + sql.matches("\nCREATE TABLE").count(), + 1, + "the reused multi-statement script must be split, not repeated: {sql}" + ); + assert!(sql.contains("FOREIGN KEY"), "foreign keys must be planned: {sql}"); + assert!(sql.contains("COMMENT ON TABLE") && sql.contains("COMMENT ON COLUMN"), "comments must be planned: {sql}"); + assert!(sql.contains("CREATE SEQUENCE"), "owned sequences must be planned: {sql}"); + assert!(sql.contains("ALTER SEQUENCE") && sql.contains("OWNED BY"), "sequence binding must be planned: {sql}"); + assert!(sql.contains("not expanded in this preview"), "unexpanded objects must be disclosed: {sql}"); + assert!(sql.contains("-- Functions: preview_probe_function"), "{sql}"); + + // Planning only: nothing was created on the target, nothing changed on the source. + assert_eq!( + schema_count(&target_pool, &format!("tables WHERE table_schema = '{target_schema}'")).await, + "0", + "the preview must not create anything on the target" + ); + assert_eq!( + schema_count(&source_pool, &format!("tables WHERE table_schema = '{source_schema}'")).await, + "2", + "the preview must not modify the source" + ); + + // A missing PostgreSQL target schema is created during execution, so the preview shows it. + let mut missing_schema_request = request.clone(); + missing_schema_request.transfer_id = format!("live-pg-preview-missing-{suffix}"); + missing_schema_request.target_schema = missing_target_schema.clone(); + missing_schema_request.objects = Vec::new(); + let missing_preview = preview_transfer_ownership( + &state, + &missing_schema_request, + &source_db_type, + &target_db_type, + &source_pool_key, + &target_pool_key, + ) + .await + .unwrap(); + let missing_sql = &missing_preview.structure.expect("structure-only must plan its structure SQL").sql; + assert!( + missing_sql.contains(&format!("CREATE SCHEMA \"{missing_target_schema}\"")), + "a missing target schema must be planned: {missing_sql}" + ); + assert_eq!( + schema_count(&target_pool, &format!("schemata WHERE schema_name = '{missing_target_schema}'")).await, + "0", + "the preview must not create the target schema" + ); + + postgres::execute_batch(&source_pool, &[format!("DROP SCHEMA \"{source_schema}\" CASCADE")]).await.unwrap(); + postgres::execute_batch(&target_pool, &[format!("DROP SCHEMA \"{target_schema}\" CASCADE")]).await.unwrap(); + let _ = std::fs::remove_dir_all(dir); +} diff --git a/docs/content/docs/data-transfer.cn.mdx b/docs/content/docs/data-transfer.cn.mdx index e9427c418b..4647bbcd26 100644 --- a/docs/content/docs/data-transfer.cn.mdx +++ b/docs/content/docs/data-transfer.cn.mdx @@ -72,6 +72,25 @@ description: 在不同连接、数据库、Schema 或数据库引擎之间批量 **重建结构和数据**会替换现有目标表及其索引、触发器、约束、注释和对象权限为源结构。原表会先被重命名为备份表,传输成功后删除。任一步骤失败则保留备份表,可手工恢复。 +## 结构 SQL 预览 + +“仅结构”传输不会静默修改目标库:DBX 会先生成即将执行的结构语句,在只读确认对话框中展示(语法高亮、可复制、可换行),此时取消则不会执行任何语句。 + +预览覆盖传输即将执行的表级结构操作: + +- `CREATE TABLE`(必要时还包括需要内联创建的 PostgreSQL 兼容 schema) +- `COMMENT` 注释语句 +- MySQL 系列延后执行的 `ALTER TABLE ... ADD CONSTRAINT ... FOREIGN KEY` +- PostgreSQL 兼容的索引与外键 +- 源结构对应的 PostgreSQL 序列语句 +- 启用重建时,还包括改名为备份表与最终清理备份的语句 + +这是预览,不是冻结脚本。开始执行时 DBX 会重新读取源/目标元数据并重新执行现有安全检查,因此期间目标结构发生变化时,实际执行可能与预览不同——DBX 是重新校验,而不是照搬预览的语句。 + +所选的非表对象(视图、例程、触发器、独立序列等)仍会在执行阶段传输,但其生成的 DDL 不会在预览中展开,对话框中会明确说明这一点。 + +本阶段“结构和数据”模式的确认流程保持不变。 + ## PostgreSQL 结构和所有者 PostgreSQL 到 PostgreSQL 且启用创建表时,DBX 会在能力允许时处理序列、索引、外键以及部分 Schema 级对象和依赖。若源对象所有者在目标实例中不存在,开始前会提示选择: diff --git a/docs/content/docs/data-transfer.mdx b/docs/content/docs/data-transfer.mdx index f953a56dd2..8d81233b3d 100644 --- a/docs/content/docs/data-transfer.mdx +++ b/docs/content/docs/data-transfer.mdx @@ -72,6 +72,25 @@ If table creation is disabled, compatible target tables must already exist. Even **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. +## Structure SQL Preview + +Structure-only transfers do not change the target silently: DBX plans the structure statements first and shows them in a read-only confirmation dialog (syntax highlighted, copyable, wrapped) before anything runs. Cancel there and nothing is executed. + +The preview covers the table-level structure operations the transfer is about to run: + +- `CREATE TABLE` (and the inline PostgreSQL-compatible schema, when one has to be created) +- `COMMENT` statements +- Deferred MySQL-family `ALTER TABLE ... ADD CONSTRAINT ... FOREIGN KEY` statements +- PostgreSQL-compatible indexes and foreign keys +- PostgreSQL sequence statements implied by the source structure, +- plus the rebuild rename/backup and cleanup statements when rebuild is enabled. + +It is a preview, not a frozen script. Starting the transfer re-reads source and target metadata and re-runs the existing safety checks, so a target changed in the meantime can make execution differ from the preview — DBX re-validates the structure rather than replaying the shown statements blindly. + +Selected non-table objects (views, routines, triggers, standalone sequences, and similar) are still transferred, but their generated DDL is not expanded in the preview; the dialog says so explicitly. + +Structure and data transfers keep their current confirmation flow in this phase. + ## 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: