Skip to content

armgit / dbx

Public Imported from GitHub
0

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

feat(compare): keep schema and data compares running in background

jearhedc7b90522001
diff --git a/apps/desktop/src/components/diff/DataCompareDialog.vue b/apps/desktop/src/components/diff/DataCompareDialog.vue
index ab89e53046..19764e1b30 100644
--- a/apps/desktop/src/components/diff/DataCompareDialog.vue
+++ b/apps/desktop/src/components/diff/DataCompareDialog.vue
@@ -1,5 +1,5 @@
<script setup lang="ts">
-import { computed, ref, watch } from "vue";
+import { computed, nextTick, onBeforeUnmount, ref, watch } from "vue";
import { useI18n } from "vue-i18n";
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
@@ -13,60 +13,27 @@ import { useToast } from "@/composables/useToast";
import { databaseOptionsForConnection, fetchNamespaceOptionsForConnection } from "@/composables/useDatabaseOptions";
import { isSchemaAware } from "@/lib/database/databaseCapabilities";
import { copyToClipboard } from "@/lib/common/clipboard";
-import type { DataCompareCellValue, DataCompareModifiedRow, DataCompareResult, DataCompareRow, DataCompareSyncPlan, DataCompareSyncPlanTableOptions } from "@/lib/dataGrid/dataCompare";
-import { inferCompareKeyColumns, intersectCompareColumns, matchColumnNameIgnoreCase } from "@/lib/dataGrid/dataCompare";
-import type { ColumnInfo, DatabaseType } from "@/types/database";
+import type { DataCompareCellValue, DataCompareSyncPlan } from "@/lib/dataGrid/dataCompare";
+import { inferCompareKeyColumns } from "@/lib/dataGrid/dataCompare";
+import {
+ buildDataCompareSyncPlanTables,
+ emptyDataCompareSyncPlan,
+ getDataCompareSession,
+ startDataCompareSession,
+ type CompareColumn,
+ type DataCompareSession,
+ type DataCompareTableResult,
+ type DataCompareTableStatus,
+ type DataCompareTableTask,
+ type DiffKind,
+ type SelectableDataCompareModifiedRow,
+ type SelectableDataCompareRow,
+} from "@/composables/useDataCompareSession";
import * as api from "@/lib/backend/api";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import TableMultiSelect from "@/components/diff/TableMultiSelect.vue";
import { ArrowLeftRight, CheckSquare, ChevronDown, ChevronRight, Copy, GitCompareArrows, Loader2, Play, Square } from "@lucide/vue";
-type CompareColumn = ColumnInfo;
-
-interface DataCompareTableTask {
- sourceTable: string;
- targetTable: string;
-}
-
-type DataCompareTableStatus = "different" | "same" | "error";
-type DiffKind = "added" | "removed" | "modified";
-
-interface SelectableDataCompareRow extends DataCompareRow {
- selected: boolean;
-}
-
-interface SelectableDataCompareModifiedRow extends DataCompareModifiedRow {
- selected: boolean;
-}
-
-interface SelectableDataCompareResult {
- added: SelectableDataCompareRow[];
- removed: SelectableDataCompareRow[];
- modified: SelectableDataCompareModifiedRow[];
-}
-
-interface DataCompareTableResult {
- sourceTable: string;
- targetTable: string;
- keyColumns: string[];
- columns: string[];
- columnInfo: CompareColumn[];
- status: DataCompareTableStatus;
- added: number;
- removed: number;
- modified: number;
- sourceRowCount: number;
- targetRowCount: number;
- sourceTruncated: boolean;
- targetTruncated: boolean;
- databaseType?: DatabaseType;
- preSyncStatements?: string[];
- diff: SelectableDataCompareResult;
- expanded: boolean;
- showAll: Record<DiffKind, boolean>;
- error?: string;
-}
-
const PREVIEW_LIMIT_OPTIONS = [50, 100, 200, 500];
const SYNC_EXECUTE_BATCH_SIZE = 500;
@@ -80,6 +47,7 @@ const props = defineProps<{
prefillDatabase?: string;
prefillSchema?: string;
prefillTable?: string;
+ sessionId?: string | null;
}>();
const sourceConnectionId = ref("");
@@ -102,7 +70,7 @@ const targetTables = ref<string[]>([]);
const keyColumnsText = ref("");
const detailPreviewLimit = ref(String(PREVIEW_LIMIT_OPTIONS[1]));
const batchResults = ref<DataCompareTableResult[]>([]);
-const syncPlan = ref<DataCompareSyncPlan>(emptySyncPlan());
+const syncPlan = ref<DataCompareSyncPlan>(emptyDataCompareSyncPlan());
const comparing = ref(false);
const planningSync = ref(false);
const compareProgressCurrent = ref(0);
@@ -116,8 +84,12 @@ const showAdded = ref(true);
const showRemoved = ref(true);
const showModified = ref(true);
+const activeSessionId = ref<string | null>(props.sessionId ?? null);
let syncPlanRequestId = 0;
let initializingPrefill = false;
+let initializingPrefillGeneration = 0;
+let componentUnmounted = false;
+let shownSessionError = "";
const sqlConnections = computed(() => store.connections.filter((connection) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos"].includes(connection.db_type)));
const selectedSourceTableNames = computed(() => sourceTables.value.filter((table) => selectedSourceTables.value.has(table)));
@@ -196,21 +168,6 @@ const compareProgressLabel = computed(() => {
});
});
-function emptySyncPlan(): DataCompareSyncPlan {
- return {
- insertCount: 0,
- updateCount: 0,
- deleteCount: 0,
- statementCount: 0,
- syncStatements: [],
- syncSql: "",
- };
-}
-
-function targetDatabaseType(): DatabaseType | undefined {
- return store.getConfig(targetConnectionId.value)?.db_type;
-}
-
function resetSelectedSourceTables(nextTables: Iterable<string>) {
selectedSourceTables.value = new Set(nextTables);
}
@@ -229,16 +186,77 @@ function buildCompareTasks(): DataCompareTableTask[] {
function clearResult() {
batchResults.value = [];
- syncPlan.value = emptySyncPlan();
+ syncPlan.value = emptyDataCompareSyncPlan();
syncErrors.value = [];
compareProgressCurrent.value = 0;
compareProgressTotal.value = 0;
compareProgressTable.value = "";
executedCount.value = 0;
executeTotal.value = 0;
+ planningSync.value = false;
syncPlanRequestId++;
}
+function comparisonEndpointLabel(connectionId: string, database: string, schema: string): string {
+ const connection = store.getConfig(connectionId);
+ return [connection?.name || connectionId, database, schema].filter(Boolean).join(" / ");
+}
+
+async function restoreDataCompareSession(session: DataCompareSession): Promise<void> {
+ const config = session.config;
+ const generation = ++initializingPrefillGeneration;
+ initializingPrefill = true;
+ try {
+ sourceConnectionId.value = config.sourceConnectionId;
+ sourceDatabase.value = config.sourceDatabase;
+ sourceSchema.value = config.sourceSchema;
+ sourceDatabases.value = [...config.sourceDatabases];
+ sourceSchemas.value = [...config.sourceSchemas];
+ sourceTables.value = [...config.sourceTables];
+ resetSelectedSourceTables(config.selectedSourceTables);
+ sourceTable.value = config.selectedSourceTables.length === 1 ? (config.selectedSourceTables[0] ?? "") : "";
+ targetConnectionId.value = config.targetConnectionId;
+ targetDatabase.value = config.targetDatabase;
+ targetSchema.value = config.targetSchema;
+ targetDatabases.value = [...config.targetDatabases];
+ targetSchemas.value = [...config.targetSchemas];
+ targetTables.value = [...config.targetTables];
+ targetTable.value = config.targetTable;
+ keyColumnsText.value = config.keyColumns.join(", ");
+ batchResults.value = session.batchResults;
+ syncPlan.value = session.syncPlan;
+ syncErrors.value = [];
+ compareProgressCurrent.value = session.progress?.current ?? 0;
+ compareProgressTotal.value = session.progress?.total ?? 0;
+ compareProgressTable.value = session.progress?.table ?? "";
+ comparing.value = session.status === "running";
+ } finally {
+ await nextTick();
+ if (generation === initializingPrefillGeneration) initializingPrefill = false;
+ }
+}
+
+function applyDataCompareSession(session: DataCompareSession | undefined): void {
+ if (!session) return;
+ batchResults.value = session.batchResults;
+ syncPlan.value = session.syncPlan;
+ if (session.status === "running") {
+ comparing.value = true;
+ compareProgressCurrent.value = session.progress?.current ?? 0;
+ compareProgressTotal.value = session.progress?.total ?? 0;
+ compareProgressTable.value = session.progress?.table ?? "";
+ return;
+ }
+ comparing.value = false;
+ compareProgressCurrent.value = 0;
+ compareProgressTotal.value = 0;
+ compareProgressTable.value = "";
+ if (session.status === "failed" && session.error && shownSessionError !== session.error) {
+ shownSessionError = session.error;
+ toast(session.error, 5000);
+ }
+}
+
function swapSourceTarget() {
const previousSelectedTables = [...selectedSourceTableNames.value];
const nextSingleTarget = previousSelectedTables.length === 1 ? (previousSelectedTables[0] ?? "") : "";
@@ -393,32 +411,6 @@ function resultStatusClass(status: DataCompareTableStatus): string {
return "bg-destructive/15 text-destructive";
}
-function toSelectableDiff(diff: DataCompareResult): SelectableDataCompareResult {
- return {
- added: diff.added.map((row) => ({ ...row, selected: true })),
- removed: diff.removed.map((row) => ({ ...row, selected: true })),
- modified: diff.modified.map((row) => ({ ...row, selected: true })),
- };
-}
-
-function buildSelectedDiff(table: DataCompareTableResult): DataCompareResult {
- return {
- added: table.diff.added.filter((row) => row.selected).map(stripSelectedRow),
- removed: table.diff.removed.filter((row) => row.selected).map(stripSelectedRow),
- modified: table.diff.modified.filter((row) => row.selected).map(stripSelectedModifiedRow),
- };
-}
-
-function stripSelectedRow(row: SelectableDataCompareRow): DataCompareRow {
- const { selected: _selected, ...rest } = row;
- return rest;
-}
-
-function stripSelectedModifiedRow(row: SelectableDataCompareModifiedRow): DataCompareModifiedRow {
- const { selected: _selected, ...rest } = row;
- return rest;
-}
-
function hasDiffRows(table: DataCompareTableResult, kind: DiffKind): boolean {
return table.diff[kind].length > 0;
}
@@ -480,27 +472,26 @@ function selectedDiffCount(kind: DiffKind) {
return batchResults.value.reduce((sum, table) => sum + selectedRows(table, kind), 0);
}
-function buildSyncPlanTables(): DataCompareSyncPlanTableOptions[] {
- return batchResults.value
- .filter((table) => table.status === "different")
- .map((table) => ({
- tableName: table.targetTable,
- schema: targetSchema.value,
- columns: table.columns,
- keyColumns: table.keyColumns,
- columnInfo: table.columnInfo,
- diff: buildSelectedDiff(table),
- databaseType: table.databaseType,
- preSyncStatements: table.preSyncStatements ?? [],
- }))
- .filter((table) => table.preSyncStatements.length > 0 || table.diff.added.length > 0 || table.diff.removed.length > 0 || table.diff.modified.length > 0);
+function buildSyncPlanTables() {
+ return buildDataCompareSyncPlanTables(batchResults.value, targetSchema.value);
+}
+
+function updateSyncPlan(nextPlan: DataCompareSyncPlan, sessionId = activeSessionId.value): void {
+ if (!componentUnmounted) syncPlan.value = nextPlan;
+ const session = getDataCompareSession(sessionId);
+ if (session?.status === "completed") {
+ session.syncPlan = nextPlan;
+ session.batchResults = batchResults.value;
+ }
}
async function rebuildSyncPlan() {
+ if (componentUnmounted) return;
const requestId = ++syncPlanRequestId;
+ const sessionId = activeSessionId.value;
const tables = buildSyncPlanTables();
if (tables.length === 0) {
- syncPlan.value = emptySyncPlan();
+ updateSyncPlan(emptyDataCompareSyncPlan(), sessionId);
planningSync.value = false;
return;
}
@@ -508,17 +499,17 @@ async function rebuildSyncPlan() {
try {
const plan = await api.buildDataCompareSyncPlan({ tables });
if (requestId !== syncPlanRequestId) return;
- syncPlan.value = plan;
+ updateSyncPlan(plan, sessionId);
} catch (e: any) {
if (requestId !== syncPlanRequestId) return;
- syncPlan.value = emptySyncPlan();
- toast(e?.message || String(e), 5000);
+ updateSyncPlan(emptyDataCompareSyncPlan(), sessionId);
+ if (!componentUnmounted) toast(e?.message || String(e), 5000);
} finally {
- if (requestId === syncPlanRequestId) planningSync.value = false;
+ if (!componentUnmounted && requestId === syncPlanRequestId) planningSync.value = false;
}
}
-async function startCompare() {
+function startCompare(): void {
if (!canCompare.value || comparing.value) return;
const tasks = buildCompareTasks();
if (tasks.length === 0) {
@@ -526,174 +517,39 @@ async function startCompare() {
return;
}
- comparing.value = true;
clearResult();
- compareProgressTotal.value = tasks.length;
-
- const sourceColumnCache = new Map<string, CompareColumn[]>();
- const targetColumnCache = new Map<string, CompareColumn[]>();
- const results: DataCompareTableResult[] = [];
- const currentTargetDatabaseType = targetDatabaseType();
-
- try {
- await Promise.all([store.ensureConnected(sourceConnectionId.value), store.ensureConnected(targetConnectionId.value)]);
-
- for (const [index, task] of tasks.entries()) {
- compareProgressCurrent.value = index + 1;
- compareProgressTable.value = task.sourceTable;
-
- try {
- if (!targetTables.value.includes(task.targetTable)) {
- const sourceColumns = await loadColumnsWithCache(sourceColumnCache, sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, task.sourceTable);
- const resolvedKeys = keyColumns.value.length > 0 ? keyColumns.value : [];
- const sourceColumnNames = sourceColumns.map((column) => column.name);
- const sourceKeyColumns = resolvedKeys.map((key) => matchColumnNameIgnoreCase(key, sourceColumnNames) ?? key);
- const preparation = await api.prepareDataCompareMissingTarget({
- sourceConnectionId: sourceConnectionId.value,
- sourceDatabase: sourceDatabase.value,
- sourceSchema: sourceSchema.value,
- sourceTable: task.sourceTable,
- targetConnectionId: targetConnectionId.value,
- targetDatabase: targetDatabase.value,
- targetSchema: targetSchema.value,
- targetTable: task.targetTable,
- keyColumns: sourceKeyColumns,
- });
- results.push({
- sourceTable: task.sourceTable,
- targetTable: task.targetTable,
- keyColumns: sourceKeyColumns,
- columns: sourceColumns.map((column) => column.name),
- columnInfo: sourceColumns,
- status: "different",
- added: preparation.result.added.length,
- removed: 0,
- modified: 0,
- sourceRowCount: preparation.sourceRowCount,
- targetRowCount: 0,
- sourceTruncated: preparation.sourceTruncated,
- targetTruncated: false,
- databaseType: currentTargetDatabaseType,
- preSyncStatements: preparation.preSyncStatements,
- diff: toSelectableDiff(preparation.result),
- expanded: preparation.result.added.length > 0,
- showAll: {
- added: false,
- removed: false,
- modified: false,
- },
- });
- continue;
- }
-
- const resolvedKeys = keyColumns.value.length > 0 ? keyColumns.value : await inferKeyColumnsForTable(task.sourceTable, sourceColumnCache);
- if (resolvedKeys.length === 0) {
- throw new Error(t("dataCompare.noKeyColumns"));
- }
-
- const sourceColumns = await loadColumnsWithCache(sourceColumnCache, sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, task.sourceTable);
- const targetColumns = await loadColumnsWithCache(targetColumnCache, targetConnectionId.value, targetDatabase.value, targetSchema.value, task.targetTable);
- const matched = intersectCompareColumns(sourceColumns, targetColumns);
- const columns = matched.columns;
- const columnInfo = columns.map((column) => targetColumns.find((target) => target.name === column)).filter((column): column is CompareColumn => !!column);
- const canonicalKeyColumns: string[] = [];
- const missingKeys: string[] = [];
- for (const key of resolvedKeys) {
- const canonical = matchColumnNameIgnoreCase(key, columns);
- if (!canonical) {
- missingKeys.push(key);
- } else if (!canonicalKeyColumns.includes(canonical)) {
- canonicalKeyColumns.push(canonical);
- }
- }
- if (missingKeys.length > 0) {
- throw new Error(t("dataCompare.missingKeyColumns", { columns: missingKeys.join(", ") }));
- }
- if (columns.length === 0) {
- throw new Error(t("dataCompare.noCommonColumns"));
- }
-
- const preparation = await api.prepareDataCompareFromTables({
- sourceConnectionId: sourceConnectionId.value,
- sourceDatabase: sourceDatabase.value,
- sourceSchema: sourceSchema.value,
- sourceTable: task.sourceTable,
- targetConnectionId: targetConnectionId.value,
- targetDatabase: targetDatabase.value,
- targetSchema: targetSchema.value,
- targetTable: task.targetTable,
- columns,
- keyColumns: canonicalKeyColumns,
- sourceColumns: matched.sourceColumns,
- });
-
- const added = preparation.result.added.length;
- const removed = preparation.result.removed.length;
- const modified = preparation.result.modified.length;
- const status: DataCompareTableStatus = added || removed || modified ? "different" : "same";
-
- results.push({
- sourceTable: task.sourceTable,
- targetTable: task.targetTable,
- keyColumns: canonicalKeyColumns,
- columns,
- columnInfo,
- status,
- added,
- removed,
- modified,
- sourceRowCount: preparation.sourceRowCount,
- targetRowCount: preparation.targetRowCount,
- sourceTruncated: preparation.sourceTruncated,
- targetTruncated: preparation.targetTruncated,
- databaseType: currentTargetDatabaseType,
- diff: toSelectableDiff(preparation.result),
- expanded: status === "different",
- showAll: {
- added: false,
- removed: false,
- modified: false,
- },
- });
- } catch (e: any) {
- results.push({
- sourceTable: task.sourceTable,
- targetTable: task.targetTable,
- keyColumns: keyColumns.value,
- columns: [],
- columnInfo: [],
- status: "error",
- added: 0,
- removed: 0,
- modified: 0,
- sourceRowCount: 0,
- targetRowCount: 0,
- sourceTruncated: false,
- targetTruncated: false,
- databaseType: currentTargetDatabaseType,
- preSyncStatements: [],
- diff: { added: [], removed: [], modified: [] },
- expanded: false,
- showAll: {
- added: false,
- removed: false,
- modified: false,
- },
- error: e?.message || String(e),
- });
- }
- }
-
- batchResults.value = results;
- await rebuildSyncPlan();
- } catch (e: any) {
- toast(e?.message || String(e), 5000);
- } finally {
- comparing.value = false;
- compareProgressCurrent.value = 0;
- compareProgressTotal.value = 0;
- compareProgressTable.value = "";
- }
+ shownSessionError = "";
+ const session = startDataCompareSession(
+ {
+ sourceConnectionId: sourceConnectionId.value,
+ sourceDatabase: sourceDatabase.value,
+ sourceSchema: sourceSchema.value,
+ sourceDatabases: [...sourceDatabases.value],
+ sourceSchemas: [...sourceSchemas.value],
+ sourceTables: [...sourceTables.value],
+ selectedSourceTables: [...selectedSourceTables.value],
+ targetConnectionId: targetConnectionId.value,
+ targetDatabase: targetDatabase.value,
+ targetSchema: targetSchema.value,
+ targetDatabases: [...targetDatabases.value],
+ targetSchemas: [...targetSchemas.value],
+ targetTables: [...targetTables.value],
+ targetTable: targetTable.value,
+ keyColumns: [...keyColumns.value],
+ label: `${comparisonEndpointLabel(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value)} → ${comparisonEndpointLabel(targetConnectionId.value, targetDatabase.value, targetSchema.value)}`,
+ },
+ tasks,
+ {
+ ensureConnected: (connectionId) => store.ensureConnected(connectionId),
+ getConfig: (connectionId) => store.getConfig(connectionId),
+ formatError: (kind, columns) => {
+ if (kind === "missingKeyColumns") return t("dataCompare.missingKeyColumns", { columns: columns ?? "" });
+ return kind === "noCommonColumns" ? t("dataCompare.noCommonColumns") : t("dataCompare.noKeyColumns");
+ },
+ },
+ );
+ activeSessionId.value = session.id;
+ applyDataCompareSession(session);
}
async function copySql() {
@@ -798,6 +654,7 @@ watch(sourceConnectionId, (id) => {
loadDatabases(id, "source").catch((e) => toast(String(e), 5000));
});
watch(targetConnectionId, (id) => {
+ if (initializingPrefill) return;
clearResult();
targetDatabase.value = "";
targetSchema.value = "";
@@ -817,6 +674,7 @@ watch(sourceDatabase, () => {
loadSchemas("source", props.prefillSchema).catch((e) => toast(String(e), 5000));
});
watch(targetDatabase, () => {
+ if (initializingPrefill) return;
clearResult();
targetSchema.value = "";
targetSchemas.value = [];
@@ -833,12 +691,14 @@ watch(sourceSchema, () => {
if (sourceSchema.value) loadTables("source").catch((e) => toast(String(e), 5000));
});
watch(targetSchema, () => {
+ if (initializingPrefill) return;
clearResult();
targetTables.value = [];
targetTable.value = "";
if (targetSchema.value) loadTables("target").catch((e) => toast(String(e), 5000));
});
watch(selectedSourceTableNames, (tables, previous) => {
+ if (initializingPrefill) return;
clearResult();
sourceTable.value = tables.length === 1 ? tables[0] : "";
if (tables.length !== 1) {
@@ -856,13 +716,27 @@ watch(selectedSourceTableNames, (tables, previous) => {
}
inferKeyColumns().catch(() => {});
});
-watch(targetTable, () => clearResult());
+watch(targetTable, () => {
+ if (initializingPrefill) return;
+ clearResult();
+});
watch(
- open,
- async (value) => {
+ [() => open.value, () => props.sessionId],
+ async ([value, sessionId]) => {
if (!value) return;
clearResult();
+ shownSessionError = "";
+ const session = getDataCompareSession(sessionId);
+ if (session) {
+ activeSessionId.value = session.id;
+ await restoreDataCompareSession(session);
+ applyDataCompareSession(session);
+ return;
+ }
+
+ activeSessionId.value = null;
if (props.prefillConnectionId) {
+ const generation = ++initializingPrefillGeneration;
initializingPrefill = true;
try {
sourceConnectionId.value = props.prefillConnectionId;
@@ -877,12 +751,26 @@ watch(
}
}
} finally {
- initializingPrefill = false;
+ await nextTick();
+ if (generation === initializingPrefillGeneration) initializingPrefill = false;
}
}
},
{ immediate: true },
);
+watch(
+ () => {
+ const session = getDataCompareSession(activeSessionId.value);
+ return session ? { id: session.id, version: session.version } : null;
+ },
+ () => {
+ if (!componentUnmounted) applyDataCompareSession(getDataCompareSession(activeSessionId.value));
+ },
+ { immediate: true },
+);
+onBeforeUnmount(() => {
+ componentUnmounted = true;
+});
</script>
<template>
@@ -901,6 +789,7 @@ watch(
<Label class="text-xs font-medium">{{ t("diff.source") }}</Label>
<ConnectionTreeSelect
v-model="sourceConnectionId"
+ :disabled="comparing"
:connections="sqlConnections"
:layout="store.sidebarLayout"
:placeholder="t('diff.selectConnection')"
@@ -915,7 +804,7 @@ watch(
:placeholder="t('diff.selectDatabase')"
:search-placeholder="t('diff.searchDatabase')"
:empty-text="t('common.noResults')"
- :disabled="!sourceDatabases.length"
+ :disabled="comparing || !sourceDatabases.length"
trigger-variant="outline"
trigger-class="h-8 w-full justify-between text-xs"
content-class="w-[var(--reka-popover-trigger-width)]"
@@ -924,6 +813,7 @@ watch(
v-if="sourceSchemas.length"
v-model="sourceSchema"
:options="sourceSchemas"
+ :disabled="comparing"
:placeholder="t('diff.selectSchema')"
:search-placeholder="t('diff.searchSchema')"
:empty-text="t('common.noResults')"
@@ -938,11 +828,12 @@ watch(
:tables="sourceTables"
:title="t('dataCompare.sourceTables')"
:empty-text="!sourceConnectionId || !sourceDatabase ? t('dataCompare.selectSourceTables') : t('dataCompare.noTables')"
+ :disabled="comparing"
/>
</div>
<div class="flex items-center pt-6">
- <Button variant="ghost" size="icon" class="h-7 w-7" :title="t('diff.swap')" @click="swapSourceTarget">
+ <Button variant="ghost" size="icon" class="h-7 w-7" :title="t('diff.swap')" :disabled="comparing" @click="swapSourceTarget">
<ArrowLeftRight class="w-3.5 h-3.5" />
</Button>
</div>
@@ -951,6 +842,7 @@ watch(
<Label class="text-xs font-medium">{{ t("diff.target") }}</Label>
<ConnectionTreeSelect
v-model="targetConnectionId"
+ :disabled="comparing"
:connections="sqlConnections"
:layout="store.sidebarLayout"
:placeholder="t('diff.selectConnection')"
@@ -965,7 +857,7 @@ watch(
:placeholder="t('diff.selectDatabase')"
:search-placeholder="t('diff.searchDatabase')"
:empty-text="t('common.noResults')"
- :disabled="!targetDatabases.length"
+ :disabled="comparing || !targetDatabases.length"
trigger-variant="outline"
trigger-class="h-8 w-full justify-between text-xs"
content-class="w-[var(--reka-popover-trigger-width)]"
@@ -974,6 +866,7 @@ watch(
v-if="targetSchemas.length"
v-model="targetSchema"
:options="targetSchemas"
+ :disabled="comparing"
:placeholder="t('diff.selectSchema')"
:search-placeholder="t('diff.searchSchema')"
:empty-text="t('common.noResults')"
@@ -990,6 +883,7 @@ watch(
:placeholder="t('dataCompare.selectTable')"
:search-placeholder="t('dataCompare.searchTable')"
:empty-text="t('common.noResults')"
+ :disabled="comparing"
trigger-variant="outline"
trigger-class="h-8 w-full justify-between text-xs"
content-class="w-[var(--reka-popover-trigger-width)]"
@@ -1018,12 +912,17 @@ watch(
<div class="space-y-1">
<Label class="text-xs font-medium">{{ t("dataCompare.keyColumns") }}</Label>
- <Input v-model="keyColumnsText" class="h-8 text-xs" :placeholder="t('dataCompare.keyColumnsPlaceholder')" />
+ <Input v-model="keyColumnsText" class="h-8 text-xs" :placeholder="t('dataCompare.keyColumnsPlaceholder')" :disabled="comparing" />
<div class="text-[11px] text-muted-foreground">
{{ t("dataCompare.keyColumnsAutoHint") }}
</div>
</div>
+ <div v-if="comparing" class="flex items-center gap-2 rounded-lg border border-primary/30 bg-primary/5 px-3 py-2 text-xs text-muted-foreground">
+ <Loader2 class="h-3.5 w-3.5 animate-spin text-primary" />
+ <span>{{ compareProgressLabel || t("diff.progress.comparing") }}</span>
+ </div>
+
<div v-if="hasResults" class="space-y-3">
<div class="rounded-lg border p-3 text-sm space-y-2">
<div>{{ summary }}</div>
@@ -1211,7 +1110,8 @@ watch(
<DialogFooter v-else class="flex items-center gap-2">
<Button variant="outline" @click="open = false">{{ t("common.close") }}</Button>
- <span v-if="executing" class="text-xs text-muted-foreground mr-auto">
+ <span v-if="comparing" class="text-xs text-muted-foreground mr-auto">{{ compareProgressLabel || t("diff.progress.comparing") }}</span>
+ <span v-else-if="executing" class="text-xs text-muted-foreground mr-auto">
{{ t("diff.syncProgress", { current: executedCount, total: executeTotal }) }}
</span>
<span v-else-if="planningSync" class="text-xs text-muted-foreground mr-auto">
diff --git a/apps/desktop/src/components/diff/SchemaDiffDialog.vue b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
index 52412bae2d..00459776e4 100644
--- a/apps/desktop/src/components/diff/SchemaDiffDialog.vue
+++ b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
@@ -18,18 +18,19 @@ import SchemaDiffOptionsPanel from "@/components/diff/SchemaDiffOptionsPanel.vue
import { getSchemaDiffOptionsForDbType } from "@/lib/schema/schemaDiffOptions";
import { buildDeployTxResult } from "@/lib/schema/deployTxResult";
-import { loadSchemaDetails } from "@/lib/schema/schemaDiffMetadataLoad";
-import { getSchemaDiffNextProgressStep, isSchemaDiffPostgresLike, shouldLoadSchemaDiffExtraObjects, type SchemaDiffProgressPhase } from "@/lib/schema/schemaDiffProgress";
-import { createSchemaDiffTableListLoader, type SchemaDiffTableIdentity } from "@/lib/schema/schemaDiffTableList";
+import { getSchemaDiffNextProgressStep, shouldLoadSchemaDiffExtraObjects, type SchemaDiffProgressPhase } from "@/lib/schema/schemaDiffProgress";
+import { createSchemaDiffTableListLoader } from "@/lib/schema/schemaDiffTableList";
import { normalizeSchemaDiffCompareOptions } from "@/types/schemaDiff";
import type { SchemaDiffCompareOptions, SchemaDiffConfig, FieldMappingEntry, SchemaDiffTableMapping } from "@/types/schemaDiff";
+import { getSchemaDiffSession, schemaDiffSessionObjects, startSchemaDiffSession, type SchemaDiffSession } from "@/composables/useSchemaDiffSession";
import type { DatabaseType, ObjectSourceKind } from "@/types/database";
import {
- convertToSchemaDiffObjects,
detectDestructiveSchemaDiffStatements,
groupDiffObjects,
injectColumnRenameSql,
schemaDiffDeployTargetSchema,
+ normalizeDialectKind,
+ databaseTypeToDialectKind,
findSchemaDiffObject,
flattenSchemaDiffObjects,
schemaDiffSelectionTargets,
@@ -39,8 +40,6 @@ import {
setSchemaDiffObjectSelected,
setSchemaDiffObjectSelectedWithDependencies,
summarizeSchemaDiffOperations,
- databaseTypeToDialectKind,
- normalizeDialectKind,
type OperationGroup,
type SchemaDiffObject,
type DiffOperationType,
@@ -53,7 +52,7 @@ import {
type DependencyGraph,
normalizeSchemaDiffDependencyGraph,
} from "@/lib/schema/schemaDiff";
-import { compileSchemaDiffTableFilter, filterSchemaDiffTables } from "@/lib/schema/schemaDiffTableFilter";
+
import { swapSchemaDiffTableMappings } from "@/lib/schema/schemaDiffTableMapping";
import { Splitpanes, Pane } from "splitpanes";
import "splitpanes/dist/splitpanes.css";
@@ -71,6 +70,7 @@ const props = defineProps<{
prefillConnectionId?: string;
prefillDatabase?: string;
prefillSchema?: string;
+ sessionId?: string | null;
}>();
// Wizard state
@@ -117,7 +117,10 @@ interface SchemaDiffProgress {
const loading = ref(false);
const schemaDiffProgress = ref<SchemaDiffProgress | null>(null);
const schemaDiffHasExtraObjectPhase = ref(false);
-let comparisonRequestId = 0;
+const activeSessionId = ref<string | null>(props.sessionId ?? null);
+let appliedSessionResult: SchemaDiffPreparation | null = null;
+let shownSessionError = "";
+let componentUnmounted = false;
const diffObjects = ref<SchemaDiffObject[]>([]);
const diffGroups = ref<OperationGroup[]>([]);
const selectedObjectId = ref<string | null>(null);
@@ -221,6 +224,7 @@ let resizeObserver: ResizeObserver | null = null;
let saveTimeout: number | null = null;
function setupResizeObserver() {
+ if (componentUnmounted) return;
const el = document.querySelector('[data-slot="dialog-content"]') as HTMLElement;
if (!el) return;
@@ -254,7 +258,9 @@ watch(
() => step.value,
(newStep) => {
if (newStep === "result") {
- setTimeout(setupResizeObserver, 100);
+ setTimeout(() => {
+ if (!componentUnmounted) setupResizeObserver();
+ }, 100);
} else {
teardownResizeObserver();
}
@@ -262,6 +268,7 @@ watch(
);
onBeforeUnmount(() => {
+ componentUnmounted = true;
teardownResizeObserver();
});
@@ -325,7 +332,6 @@ const schemaDiffNextProgressLabel = computed(() => {
});
function resetComparisonResultState() {
- comparisonRequestId++;
selectedDeploySqlGeneration++;
focusedDeploySqlGeneration++;
loading.value = false;
@@ -354,32 +360,108 @@ function resetComparisonResultState() {
deployResult.value = null;
}
-// Watch for prefilled values
+function comparisonEndpointLabel(connectionId: string, database: string, schema: string): string {
+ const connection = store.getConfig(connectionId);
+ return [connection?.name || connectionId, database, schema].filter(Boolean).join(" / ");
+}
+
+function restoreSchemaDiffSession(session: SchemaDiffSession): void {
+ const config = session.config;
+ sourceConnectionId.value = config.sourceConnectionId;
+ sourceDatabase.value = config.sourceDatabase;
+ sourceSchema.value = config.sourceSchema;
+ targetConnectionId.value = config.targetConnectionId;
+ targetDatabase.value = config.targetDatabase;
+ targetSchema.value = config.targetSchema;
+ ignoreComments.value = config.ignoreComments;
+ ensureDefaultConfig(config.targetDbType);
+ updateActiveConfigConnection({
+ sourceConnectionId: config.sourceConnectionId,
+ sourceDatabase: config.sourceDatabase,
+ sourceSchema: config.sourceSchema,
+ targetConnectionId: config.targetConnectionId,
+ targetDatabase: config.targetDatabase,
+ targetSchema: config.targetSchema,
+ });
+ updateActiveConfigOptions(config.options);
+ schemaDiffHasExtraObjectPhase.value = shouldLoadSchemaDiffExtraObjects(config.targetDbType, config.options);
+}
+
+function applySchemaDiffSession(session: SchemaDiffSession | undefined): void {
+ if (!session) return;
+ schemaDiffHasExtraObjectPhase.value = shouldLoadSchemaDiffExtraObjects(session.config.targetDbType, session.config.options);
+ if (session.status === "running") {
+ loading.value = true;
+ step.value = "compare";
+ schemaDiffProgress.value = session.progress ?? { phase: "loading-table-lists" };
+ return;
+ }
+
+ loading.value = false;
+ schemaDiffProgress.value = null;
+ if (session.status === "failed") {
+ step.value = "config";
+ if (session.error && shownSessionError !== session.error) {
+ shownSessionError = session.error;
+ toast(session.error, 5000);
+ }
+ return;
+ }
+ if (!session.result) return;
+
+ step.value = "result";
+ if (appliedSessionResult === session.result) return;
+ appliedSessionResult = session.result;
+ rollbackSql.value = session.result.rollbackSyncSql ?? "";
+ rollbackCompleteness.value = session.result.rollbackCompleteness ?? "complete";
+ missingRollbackObjects.value = session.result.missingRollbackObjects ?? [];
+ renameCandidates.value = session.result.renameCandidates ?? [];
+ compatibilityWarnings.value = session.result.compatibilityWarnings ?? [];
+ permissionDiffs.value = session.result.permissionDiffs ?? [];
+ dependencyGraph.value = normalizeSchemaDiffDependencyGraph(session.result.dependencyGraph);
+ diffObjects.value = schemaDiffSessionObjects(session.result);
+ diffGroups.value = groupDiffObjects(diffObjects.value);
+ lastDiffResult.value = session.result;
+ deploySqlMode.value = "forward";
+ void regenerateSelectedDeploySql();
+ void regenerateFocusedDeploySql();
+}
+
+// A Compare session deliberately outlives this v-if-mounted dialog. Closing the
+// dialog only removes the view; the session runner keeps updating its task.
watch(
- () => open.value,
- (isOpen) => {
- if (isOpen) {
- resetComparisonResultState();
- ensureDefaultConfig();
- if (props.prefillConnectionId) {
- sourceConnectionId.value = props.prefillConnectionId;
- if (props.prefillDatabase) {
- sourceDatabase.value = props.prefillDatabase;
- }
- if (props.prefillSchema) {
- sourceSchema.value = props.prefillSchema;
- }
- }
- } else {
- comparisonRequestId++;
- loading.value = false;
- schemaDiffProgress.value = null;
- schemaDiffHasExtraObjectPhase.value = false;
+ [() => open.value, () => props.sessionId],
+ ([isOpen]) => {
+ if (!isOpen) return;
+ const session = getSchemaDiffSession(props.sessionId);
+ activeSessionId.value = session?.id ?? null;
+ appliedSessionResult = null;
+ shownSessionError = "";
+ resetComparisonResultState();
+ if (session) {
+ restoreSchemaDiffSession(session);
+ applySchemaDiffSession(session);
+ return;
+ }
+
+ ensureDefaultConfig();
+ if (props.prefillConnectionId) {
+ sourceConnectionId.value = props.prefillConnectionId;
+ if (props.prefillDatabase) sourceDatabase.value = props.prefillDatabase;
+ if (props.prefillSchema) sourceSchema.value = props.prefillSchema;
}
},
{ immediate: true },
);
+watch(
+ () => {
+ const session = getSchemaDiffSession(activeSessionId.value);
+ return [session?.status, session?.progress, session?.result, session?.error] as const;
+ },
+ () => applySchemaDiffSession(getSchemaDiffSession(activeSessionId.value)),
+);
+
// Config sync
watch([sourceConnectionId, sourceDatabase, sourceSchema, targetConnectionId, targetDatabase, targetSchema], ([srcConn, srcDb, srcSchema, tgtConn, tgtDb, tgtSchema]) => {
updateActiveConfigConnection({
@@ -462,195 +544,35 @@ function handleFieldMappingsUpdate(mappings: FieldMappingEntry[]) {
}
}
-async function handleCompare() {
- const requestId = ++comparisonRequestId;
- const isCurrentRequest = () => requestId === comparisonRequestId;
-
- loading.value = true;
- step.value = "compare";
- schemaDiffProgress.value = { phase: "loading-table-lists" };
- schemaDiffHasExtraObjectPhase.value = false;
-
- // Reset Phase 4 state to prevent stale data from previous compares
- rollbackSql.value = "";
- rollbackCompleteness.value = "complete";
- missingRollbackObjects.value = [];
- renameCandidates.value = [];
- compatibilityWarnings.value = [];
- permissionDiffs.value = [];
- dependencyGraph.value = null;
-
- try {
- const sourceConfig = store.getConfig(sourceConnectionId.value);
- const targetConfig = store.getConfig(targetConnectionId.value);
- const dbType = targetConfig?.db_type || "mysql";
- const sourceDbType = sourceConfig?.db_type || dbType;
- const opts = normalizeSchemaDiffCompareOptions(activeConfig.value?.options, dbType);
- const isPostgresLike = isSchemaDiffPostgresLike(dbType);
- const hasExtraObjectPhase = shouldLoadSchemaDiffExtraObjects(dbType, opts);
- schemaDiffHasExtraObjectPhase.value = hasExtraObjectPhase;
- const tableFilter = compileSchemaDiffTableFilter(opts);
-
- const sourceTableIdentity: SchemaDiffTableIdentity = { connectionId: sourceConnectionId.value, database: sourceDatabase.value, schema: sourceSchema.value };
- const targetTableIdentity: SchemaDiffTableIdentity = { connectionId: targetConnectionId.value, database: targetDatabase.value, schema: targetSchema.value };
- // The dialog can remain open while either database changes, so Compare must not reuse
- // the table list cached while configuring the comparison.
- const [srcTables, tgtTables] = await Promise.all([schemaDiffTableListLoader.load(sourceTableIdentity, { refresh: true }), schemaDiffTableListLoader.load(targetTableIdentity, { refresh: true })]);
- if (!isCurrentRequest()) return;
- // Explicit (visual) table selection is applied here, BEFORE any per-table
- // metadata details are loaded, so metadata requests only happen for the
- // final table set. `undefined`/empty means no restriction (legacy path).
- const { sourceTables, targetTables } = filterSchemaDiffTables(srcTables, tgtTables, tableFilter, opts, opts.selectedTables);
-
- schemaDiffProgress.value = { phase: "loading-source-details", current: 0, total: sourceTables.length };
- const sourceDetails = await loadSchemaDetails(
- sourceTables,
- {
- connectionId: sourceConnectionId.value,
- database: sourceDatabase.value,
- schema: sourceSchema.value,
- dbType: sourceDbType,
- options: opts,
- onProgress: (progress) => {
- if (isCurrentRequest()) schemaDiffProgress.value = { phase: "loading-source-details", ...progress };
- },
- },
- api,
- );
- if (!isCurrentRequest()) return;
-
- schemaDiffProgress.value = { phase: "loading-target-details", current: 0, total: targetTables.length };
- const targetDetails = await loadSchemaDetails(
- targetTables,
- {
- connectionId: targetConnectionId.value,
- database: targetDatabase.value,
- schema: targetSchema.value,
- dbType,
- options: opts,
- onProgress: (progress) => {
- if (isCurrentRequest()) schemaDiffProgress.value = { phase: "loading-target-details", ...progress };
- },
- },
- api,
- );
- if (!isCurrentRequest()) return;
-
- // Fetch new object types for PostgreSQL-like databases
- const promises: Promise<any>[] = [];
- if (isPostgresLike && opts?.functions) {
- promises.push(api.listFunctions(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value));
- promises.push(api.listFunctions(targetConnectionId.value, targetDatabase.value, targetSchema.value));
- }
- if (isPostgresLike && opts?.sequences) {
- promises.push(api.listSequences(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, !!opts?.sequenceLastValues));
- promises.push(api.listSequences(targetConnectionId.value, targetDatabase.value, targetSchema.value, !!opts?.sequenceLastValues));
- }
- if (isPostgresLike && opts?.rules) {
- promises.push(api.listRules(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value));
- promises.push(api.listRules(targetConnectionId.value, targetDatabase.value, targetSchema.value));
- }
- if (isPostgresLike && opts?.owners) {
- promises.push(api.listOwners(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value));
- promises.push(api.listOwners(targetConnectionId.value, targetDatabase.value, targetSchema.value));
- }
-
- if (hasExtraObjectPhase) schemaDiffProgress.value = { phase: "loading-extra-objects" };
- const results = await Promise.all(promises);
- if (!isCurrentRequest()) return;
- let idx = 0;
- const srcFunctions = opts?.functions && isPostgresLike ? results[idx++] : [];
- const tgtFunctions = opts?.functions && isPostgresLike ? results[idx++] : [];
- const srcSequences = opts?.sequences && isPostgresLike ? results[idx++] : [];
- const tgtSequences = opts?.sequences && isPostgresLike ? results[idx++] : [];
- const srcRules = opts?.rules && isPostgresLike ? results[idx++] : [];
- const tgtRules = opts?.rules && isPostgresLike ? results[idx++] : [];
- const srcOwners = opts?.owners && isPostgresLike ? results[idx++] : [];
- const tgtOwners = opts?.owners && isPostgresLike ? results[idx++] : [];
-
- schemaDiffProgress.value = { phase: "comparing" };
- const result = await api.prepareSchemaDiff({
- sourceTables,
- targetTables,
- sourceDetails,
- targetDetails,
- sourceFunctions: srcFunctions,
- targetFunctions: tgtFunctions,
- sourceSequences: srcSequences,
- targetSequences: tgtSequences,
- sourceRules: srcRules,
- targetRules: tgtRules,
- sourceOwners: srcOwners,
- targetOwners: tgtOwners,
- // Mappings only apply to an explicit table selection; the all-tables path
- // (selectedTables === undefined) must stay mapping-free so the Rust side
- // cannot reclassify added/removed tables from stale persisted mappings.
- tableMappings: opts.selectedTables === undefined ? undefined : opts.tableMappings,
- databaseType: dbType,
- targetSchema: schemaDiffDeployTargetSchema(dbType, targetDatabase.value, targetSchema.value),
+function handleCompare(): void {
+ const sourceConfig = store.getConfig(sourceConnectionId.value);
+ const targetConfig = store.getConfig(targetConnectionId.value);
+ const targetDbType = (targetConfig?.db_type || "mysql") as DatabaseType;
+ const sourceDbType = sourceConfig?.db_type || targetDbType;
+ const options = normalizeSchemaDiffCompareOptions(activeConfig.value?.options, targetDbType);
+
+ appliedSessionResult = null;
+ shownSessionError = "";
+ resetComparisonResultState();
+ schemaDiffHasExtraObjectPhase.value = shouldLoadSchemaDiffExtraObjects(targetDbType, options);
+ const session = startSchemaDiffSession(
+ {
+ sourceConnectionId: sourceConnectionId.value,
+ sourceDatabase: sourceDatabase.value,
+ sourceSchema: sourceSchema.value,
+ targetConnectionId: targetConnectionId.value,
+ targetDatabase: targetDatabase.value,
+ targetSchema: targetSchema.value,
+ sourceDbType,
+ targetDbType,
+ options,
ignoreComments: ignoreComments.value,
- cascadeDelete: opts?.cascadeDelete ?? false,
- compareColumnOrder: opts.compareColumnOrder,
- ignoreTableNameCase: opts.ignoreTableNameCase,
- ignoreColumnNameCase: opts.ignoreColumnNameCase,
- detectRenames: opts?.detectRenames ?? false,
- detectTableRenames: opts?.detectTableRenames ?? false,
- renameThreshold: opts?.renameThreshold ?? 0.5,
- enableRollback: opts?.enableRollback ?? false,
- batchPatterns: opts?.batchPatterns
- ? opts.batchPatterns
- .split(",")
- .map((s: string) => s.trim())
- .filter(Boolean)
- : undefined,
- sourceDialect: opts?.sourceDialect ? normalizeDialectKind(opts.sourceDialect) : sourceConfig?.db_type ? databaseTypeToDialectKind(sourceConfig.db_type) : undefined,
- targetDialect: opts?.targetDialect ? normalizeDialectKind(opts.targetDialect) : targetConfig?.db_type ? databaseTypeToDialectKind(targetConfig.db_type) : undefined,
- compatibilityThreshold: opts?.compatibilityThreshold ?? 0.5,
- fieldMappings:
- opts?.fieldMappings?.map((m: FieldMappingEntry) => ({
- sourceType: m.sourceType,
- targetType: m.targetType,
- paramStrategy: m.paramStrategy ?? "preserve",
- customParams: m.customParams,
- })) || [],
- });
- if (!isCurrentRequest()) return;
-
- // Extract new result fields
- rollbackSql.value = result.rollbackSyncSql ?? "";
- rollbackCompleteness.value = result.rollbackCompleteness ?? "complete";
- missingRollbackObjects.value = result.missingRollbackObjects ?? [];
- renameCandidates.value = result.renameCandidates ?? [];
- compatibilityWarnings.value = result.compatibilityWarnings ?? [];
- permissionDiffs.value = result.permissionDiffs ?? [];
- dependencyGraph.value = normalizeSchemaDiffDependencyGraph(result.dependencyGraph);
-
- // Convert to unified objects
- diffObjects.value = convertToSchemaDiffObjects(result.diffs, result.functionDiffs, result.sequenceDiffs, result.ruleDiffs, result.ownerDiffs, result.renameCandidates);
-
- // Group by operation type and object kind
- diffGroups.value = groupDiffObjects(diffObjects.value);
-
- // Save the structured result; both script previews are generated from the
- // current selection projection below rather than from the initial full SQL.
- lastDiffResult.value = result;
- deploySqlMode.value = "forward";
- schemaDiffProgress.value = { phase: "generating" };
- await regenerateSelectedDeploySql();
- await regenerateFocusedDeploySql();
- if (!isCurrentRequest()) return;
-
- schemaDiffProgress.value = null;
- step.value = "result";
- } catch (e: any) {
- if (!isCurrentRequest()) return;
- schemaDiffProgress.value = null;
- schemaDiffHasExtraObjectPhase.value = false;
- toast(e?.message || String(e), 5000);
- step.value = "config";
- } finally {
- if (isCurrentRequest()) loading.value = false;
- }
+ label: `${comparisonEndpointLabel(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value)} → ${comparisonEndpointLabel(targetConnectionId.value, targetDatabase.value, targetSchema.value)}`,
+ },
+ { tableListLoader: schemaDiffTableListLoader },
+ );
+ activeSessionId.value = session.id;
+ applySchemaDiffSession(session);
}
function handleToggleGroup(operationType: DiffOperationType) {
@@ -738,10 +660,10 @@ async function regenerateSelectedDeploySql() {
try {
plan = await api.generateSchemaSyncPlan(input, buildSchemaSyncPlanOptions(options));
} catch (error: any) {
- if (generation === selectedDeploySqlGeneration) toast(error?.message || String(error), 5000);
+ if (!componentUnmounted && generation === selectedDeploySqlGeneration) toast(error?.message || String(error), 5000);
return;
}
- if (generation !== selectedDeploySqlGeneration) return;
+ if (componentUnmounted || generation !== selectedDeploySqlGeneration) return;
const formatted = formatSchemaSyncPlan(plan, input, options);
rollbackCompleteness.value = plan.rollbackCompleteness ?? "complete";
@@ -767,10 +689,10 @@ async function regenerateFocusedDeploySql(objectId: string | null = selectedObje
try {
plan = await api.generateSchemaSyncPlan(input, buildSchemaSyncPlanOptions(options));
} catch (error: any) {
- if (generation === focusedDeploySqlGeneration && selectedObjectId.value === objectId) toast(error?.message || String(error), 5000);
+ if (!componentUnmounted && generation === focusedDeploySqlGeneration && selectedObjectId.value === objectId) toast(error?.message || String(error), 5000);
return;
}
- if (generation !== focusedDeploySqlGeneration || selectedObjectId.value !== objectId) return;
+ if (componentUnmounted || generation !== focusedDeploySqlGeneration || selectedObjectId.value !== objectId) return;
const formatted = formatSchemaSyncPlan(plan, input, options);
focusedForwardDeploySql.value = formatted.forwardSql;
diff --git a/apps/desktop/src/components/diff/__tests__/DataCompareDialog.prefill.spec.ts b/apps/desktop/src/components/diff/__tests__/DataCompareDialog.prefill.spec.ts
index cd2512d5b8..96b8c96cfb 100644
--- a/apps/desktop/src/components/diff/__tests__/DataCompareDialog.prefill.spec.ts
+++ b/apps/desktop/src/components/diff/__tests__/DataCompareDialog.prefill.spec.ts
@@ -4,6 +4,7 @@ import { createApp, defineComponent, h, nextTick, type App } from "vue";
import { afterEach, describe, expect, it, vi } from "vitest";
import i18n from "@/i18n";
import DataCompareDialog from "@/components/diff/DataCompareDialog.vue";
+import type { DataCompareSession } from "@/composables/useDataCompareSession";
const mocks = vi.hoisted(() => ({
ensureConnected: vi.fn().mockResolvedValue(undefined),
@@ -11,8 +12,21 @@ const mocks = vi.hoisted(() => ({
listSchemas: vi.fn().mockResolvedValue(["DBX_TEST", "REPORTING", "SYS"]),
listTables: vi.fn().mockResolvedValue([{ name: "CODEX_7467_META", table_type: "TABLE" }]),
getColumns: vi.fn().mockResolvedValue([{ name: "ID", data_type: "NUMBER", is_primary_key: true }]),
+ buildDataCompareSyncPlan: vi.fn(),
}));
+const sessionMocks = vi.hoisted(() => ({
+ session: null as DataCompareSession | null,
+}));
+
+vi.mock("@/composables/useDataCompareSession", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("@/composables/useDataCompareSession")>();
+ return {
+ ...actual,
+ getDataCompareSession: (id: string | null | undefined) => (id && sessionMocks.session?.id === id ? sessionMocks.session : undefined),
+ };
+});
+
vi.mock("@/stores/connectionStore", () => {
const connections = [
{ id: "oracle-11g", name: "Oracle XE 11g", db_type: "oracle", driver_profile: "oracle", database: "XE" },
@@ -43,6 +57,7 @@ vi.mock("@/lib/backend/api", () => ({
listSchemas: mocks.listSchemas,
listTables: mocks.listTables,
getColumns: mocks.getColumns,
+ buildDataCompareSyncPlan: mocks.buildDataCompareSyncPlan,
}));
const mountedApps: App[] = [];
@@ -57,9 +72,91 @@ async function flushAsyncSetup() {
afterEach(() => {
for (const app of mountedApps.splice(0)) app.unmount();
document.body.textContent = "";
+ sessionMocks.session = null;
vi.clearAllMocks();
});
+function completedSession(): DataCompareSession {
+ return {
+ id: "compare-session",
+ version: 1,
+ status: "completed",
+ config: {
+ sourceConnectionId: "oracle-11g",
+ sourceDatabase: "DBX_TEST",
+ sourceSchema: "DBX_TEST",
+ sourceDatabases: ["DBX_TEST"],
+ sourceSchemas: ["DBX_TEST"],
+ sourceTables: ["ORDERS"],
+ selectedSourceTables: ["ORDERS"],
+ targetConnectionId: "oracle-jdbc-11g",
+ targetDatabase: "REPORTING",
+ targetSchema: "DBX_TEST",
+ targetDatabases: ["REPORTING"],
+ targetSchemas: ["DBX_TEST"],
+ targetTables: ["ORDERS"],
+ targetTable: "ORDERS",
+ keyColumns: ["ID"],
+ label: "Oracle source → Oracle target",
+ },
+ progress: null,
+ batchResults: [
+ {
+ sourceTable: "ORDERS",
+ targetTable: "ORDERS",
+ keyColumns: ["ID"],
+ columns: ["ID", "NAME"],
+ columnInfo: [],
+ status: "different",
+ added: 2,
+ removed: 0,
+ modified: 0,
+ sourceRowCount: 2,
+ targetRowCount: 0,
+ sourceTruncated: false,
+ targetTruncated: false,
+ databaseType: "oracle",
+ diff: {
+ added: [
+ { key: "1", keyValues: { ID: 1 }, values: { ID: 1, NAME: "first" }, selected: true },
+ { key: "2", keyValues: { ID: 2 }, values: { ID: 2, NAME: "second" }, selected: true },
+ ],
+ removed: [],
+ modified: [],
+ },
+ expanded: true,
+ showAll: { added: true, removed: true, modified: true },
+ },
+ ],
+ syncPlan: {
+ insertCount: 2,
+ updateCount: 0,
+ deleteCount: 0,
+ statementCount: 2,
+ syncStatements: ["INSERT 1", "INSERT 2"],
+ syncSql: "INSERT 1;\nINSERT 2;",
+ },
+ error: null,
+ startedAt: 1,
+ finishedAt: 2,
+ };
+}
+
+function mountSessionDialog(session: DataCompareSession): App {
+ sessionMocks.session = session;
+ const container = document.createElement("div");
+ document.body.append(container);
+ const app = createApp(
+ defineComponent({
+ setup: () => () => h(DataCompareDialog, { open: true, sessionId: session.id }),
+ }),
+ );
+ mountedApps.push(app);
+ app.use(i18n);
+ app.mount(container);
+ return app;
+}
+
describe("DataCompareDialog source prefill", () => {
it("keeps the Oracle source table after loading database and schema prefills", async () => {
const container = document.createElement("div");
@@ -148,3 +245,47 @@ describe("DataCompareDialog source prefill", () => {
expect(document.body.textContent).toContain("CODEX_7467_META");
});
});
+
+describe("DataCompareDialog session restore", () => {
+ it("keeps restored fields, results, and sync SQL after queued watchers flush", async () => {
+ const session = completedSession();
+ mountSessionDialog(session);
+
+ await flushAsyncSetup();
+
+ expect(mocks.listSchemas).not.toHaveBeenCalled();
+ expect(document.body.textContent).toContain("ORDERS");
+ expect(document.body.textContent).toContain("ID=1");
+ expect(document.querySelector<HTMLTextAreaElement>("textarea[readonly]")?.value).toBe("INSERT 1;\nINSERT 2;");
+ });
+
+ it("persists the latest selection plan when the dialog closes during planning", async () => {
+ const session = completedSession();
+ let resolvePlan!: (plan: DataCompareSession["syncPlan"]) => void;
+ mocks.buildDataCompareSyncPlan.mockReturnValueOnce(new Promise((resolve) => (resolvePlan = resolve)));
+ const app = mountSessionDialog(session);
+ await flushAsyncSetup();
+
+ const firstRow = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes("ID=1"));
+ expect(firstRow).toBeDefined();
+ firstRow?.click();
+ await nextTick();
+ expect(mocks.buildDataCompareSyncPlan).toHaveBeenCalledOnce();
+
+ mountedApps.splice(mountedApps.indexOf(app), 1);
+ app.unmount();
+ resolvePlan({
+ insertCount: 1,
+ updateCount: 0,
+ deleteCount: 0,
+ statementCount: 1,
+ syncStatements: ["INSERT 2"],
+ syncSql: "INSERT 2;",
+ });
+ await flushAsyncSetup();
+
+ expect(session.batchResults[0]?.diff.added[0]?.selected).toBe(false);
+ expect(session.syncPlan.syncStatements).toEqual(["INSERT 2"]);
+ expect(session.syncPlan.syncSql).toBe("INSERT 2;");
+ });
+});
diff --git a/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts b/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts
index 86a8bb1607..83b5ee835a 100644
--- a/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts
+++ b/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts
@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
const dialogSource = readFileSync(new URL("../SchemaDiffDialog.vue", import.meta.url), "utf8");
+const sessionSource = readFileSync(new URL("../../../composables/useSchemaDiffSession.ts", import.meta.url), "utf8");
const configStepSource = readFileSync(new URL("../SchemaDiffConfigStep.vue", import.meta.url), "utf8");
describe("SchemaDiffDialog fullscreen layout", () => {
@@ -43,20 +44,20 @@ describe("SchemaDiffDialog fullscreen layout", () => {
it("clears stale result and progress state whenever a new dialog session opens", () => {
expect(dialogSource).toContain("function resetComparisonResultState() {");
- expect(dialogSource).toMatch(/if \(isOpen\) \{\s+resetComparisonResultState\(\);/);
+ expect(dialogSource).toMatch(/if \(!isOpen\) return;[\s\S]*?resetComparisonResultState\(\);/);
expect(dialogSource).toContain("diffObjects.value = [];");
expect(dialogSource).toContain("lastDiffResult.value = null;");
expect(dialogSource).toContain("schemaDiffProgress.value = null;");
});
it("shows real metadata progress and indeterminate comparison phases without fabricated percentages", () => {
- expect(dialogSource).toContain('phase: "loading-table-lists"');
- expect(dialogSource).toContain('phase: "loading-source-details"');
- expect(dialogSource).toContain('phase: "loading-target-details"');
- expect(dialogSource).toContain('phase: "loading-extra-objects"');
- expect(dialogSource).toContain('phase: "comparing"');
- expect(dialogSource).toContain('phase: "generating"');
- expect(dialogSource).toContain("onProgress: (progress) =>");
+ expect(sessionSource).toContain('phase: "loading-table-lists"');
+ expect(sessionSource).toContain('phase: "loading-source-details"');
+ expect(sessionSource).toContain('phase: "loading-target-details"');
+ expect(sessionSource).toContain('phase: "loading-extra-objects"');
+ expect(sessionSource).toContain('phase: "comparing"');
+ expect(sessionSource).toContain('phase: "generating"');
+ expect(sessionSource).toContain("onProgress: (progress) =>");
expect(dialogSource).toContain("schemaDiffProgressCount");
expect(dialogSource).toContain('role="progressbar"');
expect(dialogSource).toContain("schema-diff-progress-indeterminate");
@@ -72,15 +73,17 @@ describe("SchemaDiffDialog fullscreen layout", () => {
});
it("clears progress before preserving the existing comparison error flow", () => {
- expect(dialogSource).toMatch(/\} catch \(e: any\) \{\s+if \(!isCurrentRequest\(\)\) return;\s+schemaDiffProgress\.value = null;/);
- expect(dialogSource).toContain("toast(e?.message || String(e), 5000);");
+ expect(sessionSource).toContain("session.error = message;");
+ expect(sessionSource).toContain('session.status = "failed";');
+ expect(dialogSource).toContain("toast(session.error, 5000);");
expect(dialogSource).toContain('step.value = "config";');
});
- it("invalidates an active comparison when the dialog closes", () => {
- expect(dialogSource).toContain("const requestId = ++comparisonRequestId;");
- expect(dialogSource).toContain("if (!isCurrentRequest()) return;");
- expect(dialogSource).toMatch(/\} else \{\s+comparisonRequestId\+\+;\s+loading\.value = false;\s+schemaDiffProgress\.value = null;/);
+ it("keeps an active comparison running after the dialog unmounts", () => {
+ expect(dialogSource).toContain("const session = startSchemaDiffSession(");
+ expect(dialogSource).toContain("onBeforeUnmount(() => {");
+ expect(dialogSource).toContain("componentUnmounted = true;");
+ expect(dialogSource).not.toContain("comparisonRequestId");
});
it("does not restore persisted table matches before source and target identities are ready", () => {
@@ -111,9 +114,9 @@ describe("SchemaDiffDialog fullscreen layout", () => {
expect(configStepSource).toContain('@update:model-value="(value: string) => handleTableMappingUpdate(match.sourceTable, value)"');
expect(configStepSource).toContain("tableMatchStatus.${match.kind}");
expect(dialogSource).toContain('@update:table-mappings="handleTableMappingsUpdate"');
- expect(dialogSource).toContain("tableMappings: opts.selectedTables === undefined ? undefined : opts.tableMappings");
- expect(dialogSource).toContain("ignoreTableNameCase: opts.ignoreTableNameCase");
- expect(dialogSource).toContain("ignoreColumnNameCase: opts.ignoreColumnNameCase");
+ expect(sessionSource).toContain("tableMappings: options.selectedTables === undefined ? undefined : options.tableMappings");
+ expect(sessionSource).toContain("ignoreTableNameCase: options.ignoreTableNameCase");
+ expect(sessionSource).toContain("ignoreColumnNameCase: options.ignoreColumnNameCase");
expect(dialogSource).toContain("const swappedMappings = swapSchemaDiffTableMappings(currentOptions.tableMappings ?? []);");
});
diff --git a/apps/desktop/src/components/export/ExportProgressPopover.vue b/apps/desktop/src/components/export/ExportProgressPopover.vue
index 1c10930553..57f8421da6 100644
--- a/apps/desktop/src/components/export/ExportProgressPopover.vue
+++ b/apps/desktop/src/components/export/ExportProgressPopover.vue
@@ -3,7 +3,7 @@ import { computed, onBeforeUnmount, onMounted, ref } from "vue";
import { useI18n } from "vue-i18n";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
import { Button } from "@/components/ui/button";
-import { Loader2, Check, CheckCircle2, XCircle, AlertCircle, X, FileDown, DatabaseBackup, FileCode2, ArrowRightLeft, Layers3, ChevronRight, FolderOpen, Copy } from "@lucide/vue";
+import { Loader2, Check, CheckCircle2, XCircle, AlertCircle, X, FileDown, DatabaseBackup, FileCode2, ArrowRightLeft, Layers3, GitCompareArrows, ChevronRight, FolderOpen, Copy } from "@lucide/vue";
import { formatDataTransferDuration, useExportTracker, type ExportTask } from "@/composables/useExportTracker";
import { dataTransferFailureCopyText, sqlFileFailureCopyText } from "@/components/export/failureDetailCopyText";
import { translateBackendError } from "@/i18n/backend-errors";
@@ -81,6 +81,11 @@ const progressValue = (task: ExportTask) => {
if (!task.multiDbTotal) return 0;
return Math.min(95, Math.round(((task.multiDbCompleted ?? 0) / task.multiDbTotal) * 100));
}
+ if (task.kind === "schema-diff" || task.kind === "data-compare") {
+ if (task.status === "Done" || task.status === "Error" || task.status === "Cancelled") return 100;
+ if (!task.compareTotal) return 0;
+ return Math.min(95, Math.round(((task.compareCurrent ?? 0) / task.compareTotal) * 100));
+ }
return progressPercent(task.totalRows, task.rowsExported);
};
@@ -105,10 +110,48 @@ const taskTitle = (task: ExportTask) => {
if (task.kind === "sql-file") return t("exportProgress.sqlFileTitle", { name: task.tableName });
if (task.kind === "data-transfer") return t("exportProgress.dataTransferTitle", { name: task.tableName });
if (task.kind === "multi-db-execution") return t("exportProgress.multiDbExecutionTitle", { name: task.tableName });
+ if (task.kind === "schema-diff") return t("exportProgress.schemaDiffTitle", { name: task.tableName });
+ if (task.kind === "data-compare") return t("exportProgress.dataCompareTitle", { name: task.tableName });
return taskFileName(task) || `${task.tableName}.${task.format}`;
};
+const comparePhaseText = (phase?: string) => {
+ if (!phase) return "";
+ const phaseKey: Record<string, string> = {
+ "loading-table-lists": "exportProgress.comparePhase.loadingTableLists",
+ "loading-source-details": "exportProgress.comparePhase.loadingSourceDetails",
+ "loading-target-details": "exportProgress.comparePhase.loadingTargetDetails",
+ "loading-extra-objects": "exportProgress.comparePhase.loadingExtraObjects",
+ comparing: "exportProgress.comparePhase.comparing",
+ generating: "exportProgress.comparePhase.generating",
+ complete: "exportProgress.comparePhase.complete",
+ };
+ return t(phaseKey[phase] ?? phase);
+};
+
const rowsText = (task: ExportTask) => {
+ if (task.kind === "schema-diff") {
+ if (isActive(task.status)) {
+ const progress = task.compareTotal ? `${task.compareCurrent ?? 0}/${task.compareTotal}` : "";
+ return [comparePhaseText(task.comparePhase), task.compareCurrentObject, progress].filter(Boolean).join(" · ");
+ }
+ return t("exportProgress.schemaDiffSummary", { count: task.compareResultCount ?? 0 });
+ }
+ if (task.kind === "data-compare") {
+ if (isActive(task.status)) {
+ const progress = task.compareTotal ? `${task.compareCurrent ?? 0}/${task.compareTotal}` : "";
+ return [comparePhaseText(task.comparePhase), progress, task.compareCurrentObject].filter(Boolean).join(" · ");
+ }
+ return t("exportProgress.dataCompareSummary", {
+ tables: task.compareTotal ?? 0,
+ same: task.compareSameCount ?? 0,
+ different: task.compareDifferentCount ?? 0,
+ failed: task.compareFailedCount ?? 0,
+ added: task.compareAddedCount ?? 0,
+ removed: task.compareRemovedCount ?? 0,
+ modified: task.compareModifiedCount ?? 0,
+ });
+ }
if (task.kind === "database-export") {
if (task.overallPercent !== undefined) return `${task.overallPercent}%`;
if (task.totalObjects) {
@@ -149,7 +192,14 @@ const rowsText = (task: ExportTask) => {
return `${task.rowsExported.toLocaleString()} ${t("exportProgress.rowsShort")}`;
};
-const taskStatusText = (task: ExportTask) => (task.status === "Cancelling" ? t("databaseBackup.cancelling") : "");
+const taskStatusText = (task: ExportTask) => {
+ if (task.status === "Cancelling") return t("databaseBackup.cancelling");
+ if (task.kind !== "schema-diff" && task.kind !== "data-compare") return "";
+ if (task.status === "Running") return t("exportProgress.compareRunning");
+ if (task.status === "Done") return t("exportProgress.compareDone");
+ if (task.status === "Error") return t("exportProgress.compareError");
+ return t("exportProgress.compareCancelled");
+};
const elapsedText = (task: ExportTask) => {
if (task.startedAt === undefined) return "";
@@ -175,6 +225,7 @@ const statusIcon = (task: ExportTask) => {
if (task.kind === "sql-file") return FileCode2;
if (task.kind === "data-transfer") return ArrowRightLeft;
if (task.kind === "multi-db-execution") return Layers3;
+ if (task.kind === "schema-diff" || task.kind === "data-compare") return GitCompareArrows;
}
switch (task.status) {
case "Running":
@@ -276,6 +327,7 @@ async function copyFailureDetail(text: string, key: string): Promise<void> {
}
function openTask(task: ExportTask): void {
+ open.value = false;
task.onOpen?.();
}
</script>
@@ -308,7 +360,13 @@ function openTask(task: ExportTask): void {
<!-- Progress bar -->
<div v-if="isActive(task.status)" class="w-full bg-muted rounded-full h-1.5 overflow-hidden">
<div
- v-if="task.totalRows || (task.kind === 'database-export' && (task.totalObjects || task.overallPercent !== undefined)) || (task.kind === 'data-transfer' && task.totalTables) || (task.kind === 'multi-db-execution' && task.multiDbTotal)"
+ v-if="
+ task.totalRows ||
+ (task.kind === 'database-export' && (task.totalObjects || task.overallPercent !== undefined)) ||
+ (task.kind === 'data-transfer' && task.totalTables) ||
+ (task.kind === 'multi-db-execution' && task.multiDbTotal) ||
+ ((task.kind === 'schema-diff' || task.kind === 'data-compare') && task.compareTotal)
+ "
class="h-full bg-primary rounded-full transition-[width] duration-300"
:style="{ width: `${progressValue(task)}%` }"
/>
@@ -388,14 +446,14 @@ function openTask(task: ExportTask): void {
<!-- Actions: reveal folder for finished exports, stop/cancel for active, delete for finished -->
<div class="flex shrink-0 pt-4">
- <button v-if="task.kind === 'multi-db-execution' && task.onOpen" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.openTask')" @click.stop="openTask(task)">
+ <button v-if="task.onOpen" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.openTask')" @click.stop="openTask(task)">
<ChevronRight class="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
</button>
<button v-if="canRevealTaskFile(task)" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted disabled:opacity-50" :title="t('exportProgress.openFolder')" :disabled="revealingTaskIds.includes(task.exportId)" @click="revealTaskFile(task)">
<FolderOpen class="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
</button>
<button
- v-if="isActive(task.status)"
+ v-if="isActive(task.status) && task.canCancel !== false"
class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted disabled:cursor-not-allowed"
:disabled="task.status === 'Cancelling'"
:title="task.status === 'Cancelling' ? t('databaseBackup.cancelling') : t('exportProgress.cancel')"
@@ -404,7 +462,7 @@ function openTask(task: ExportTask): void {
<Loader2 v-if="task.status === 'Cancelling'" class="h-3.5 w-3.5 animate-spin text-primary" />
<X v-else class="h-3.5 w-3.5 text-muted-foreground hover:text-destructive" />
</button>
- <button v-else class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.delete')" @click="removeTask(task.exportId)">
+ <button v-else-if="!isActive(task.status)" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.delete')" @click="removeTask(task.exportId)">
<X class="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
</button>
</div>
diff --git a/apps/desktop/src/components/layout/AppDialogs.vue b/apps/desktop/src/components/layout/AppDialogs.vue
index 91639a2ba4..1143576e5f 100644
--- a/apps/desktop/src/components/layout/AppDialogs.vue
+++ b/apps/desktop/src/components/layout/AppDialogs.vue
@@ -255,7 +255,14 @@ watch(
:prefill-target-database="dialogs.transferPrefillTargetDatabase.value"
:prefill-target-schema="dialogs.transferPrefillTargetSchema.value"
/>
- <SchemaDiffDialog v-if="dialogs.showSchemaDiffDialog.value" v-model:open="dialogs.showSchemaDiffDialog.value" :prefill-connection-id="dialogs.schemaDiffPrefillConnectionId.value" :prefill-database="dialogs.schemaDiffPrefillDatabase.value" :prefill-schema="dialogs.schemaDiffPrefillSchema.value" />
+ <SchemaDiffDialog
+ v-if="dialogs.showSchemaDiffDialog.value"
+ v-model:open="dialogs.showSchemaDiffDialog.value"
+ :prefill-connection-id="dialogs.schemaDiffPrefillConnectionId.value"
+ :prefill-database="dialogs.schemaDiffPrefillDatabase.value"
+ :prefill-schema="dialogs.schemaDiffPrefillSchema.value"
+ :session-id="dialogs.schemaDiffSessionId.value"
+ />
<DataCompareDialog
v-if="dialogs.showDataCompareDialog.value"
v-model:open="dialogs.showDataCompareDialog.value"
@@ -263,6 +270,7 @@ watch(
:prefill-database="dialogs.dataComparePrefillDatabase.value"
:prefill-schema="dialogs.dataComparePrefillSchema.value"
:prefill-table="dialogs.dataComparePrefillTable.value"
+ :session-id="dialogs.dataCompareSessionId.value"
/>
<SqlFileExecutionDialog v-model:open="dialogs.showSqlFileDialog.value" :prefill-connection-id="dialogs.sqlFilePrefillConnectionId.value" :prefill-database="dialogs.sqlFilePrefillDatabase.value" :prefill-file-path="dialogs.sqlFilePrefillFilePath.value" />
<SchemaDiagramDialog
diff --git a/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts b/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
new file mode 100644
index 0000000000..f570ba82df
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
@@ -0,0 +1,96 @@
+import { strict as assert } from "node:assert";
+import { beforeEach, test, vi } from "vitest";
+
+const apiMock = vi.hoisted(() => ({
+ buildDataCompareSyncPlan: vi.fn(),
+ getColumns: vi.fn(),
+ prepareDataCompareFromTables: vi.fn(),
+ prepareDataCompareMissingTarget: vi.fn(),
+}));
+
+const openMock = vi.hoisted(() => vi.fn());
+const trackerMock = vi.hoisted(() => ({
+ addDataCompareTask: vi.fn(),
+ updateCompareTask: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => apiMock);
+vi.mock("@/composables/useDialogSources", () => ({ openDataCompareSession: openMock }));
+vi.mock("@/composables/useExportTracker", () => ({ useExportTracker: () => trackerMock }));
+
+const { startDataCompareSession } = await import("../useDataCompareSession.ts");
+
+test("runs a data compare session independently of the dialog and retains its result", async () => {
+ apiMock.getColumns.mockResolvedValue([
+ { name: "id", is_primary_key: true },
+ { name: "name", is_primary_key: false },
+ ]);
+ apiMock.prepareDataCompareFromTables.mockResolvedValue({
+ result: {
+ added: [{ key: "1", keyValues: { id: 1 }, values: { id: 1, name: "new" } }],
+ removed: [],
+ modified: [],
+ },
+ syncStatements: ["INSERT INTO users (id, name) VALUES (1, 'new')"],
+ syncSql: "INSERT INTO users (id, name) VALUES (1, 'new')",
+ preSyncStatements: [],
+ sourceRowCount: 1,
+ targetRowCount: 0,
+ sourceTruncated: false,
+ targetTruncated: false,
+ });
+ apiMock.buildDataCompareSyncPlan.mockResolvedValue({
+ insertCount: 1,
+ updateCount: 0,
+ deleteCount: 0,
+ statementCount: 1,
+ syncStatements: ["INSERT"],
+ syncSql: "INSERT",
+ });
+
+ const session = startDataCompareSession(
+ {
+ sourceConnectionId: "source",
+ sourceDatabase: "app",
+ sourceSchema: "public",
+ sourceDatabases: ["app"],
+ sourceSchemas: ["public"],
+ sourceTables: ["users"],
+ selectedSourceTables: ["users"],
+ targetConnectionId: "target",
+ targetDatabase: "warehouse",
+ targetSchema: "public",
+ targetDatabases: ["warehouse"],
+ targetSchemas: ["public"],
+ targetTables: ["users"],
+ targetTable: "users",
+ keyColumns: ["id"],
+ label: "app → warehouse",
+ },
+ [{ sourceTable: "users", targetTable: "users" }],
+ {
+ ensureConnected: vi.fn().mockResolvedValue(undefined),
+ getConfig: () => ({ db_type: "mysql" }),
+ },
+ );
+
+ for (let attempt = 0; attempt < 20 && session.status === "running"; attempt += 1) {
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ }
+
+ assert.equal(session.status, "completed");
+ assert.equal(session.batchResults.length, 1);
+ assert.equal(session.batchResults[0]?.status, "different");
+ assert.equal(session.batchResults[0]?.diff.added[0]?.selected, true);
+ assert.equal(session.syncPlan.statementCount, 1);
+ assert.equal(trackerMock.addDataCompareTask.mock.calls.length, 1);
+ assert.equal(trackerMock.updateCompareTask.mock.calls.at(-1)?.[1].status, "Done");
+
+ const onOpen = trackerMock.addDataCompareTask.mock.calls[0]?.[2] as (() => void) | undefined;
+ onOpen?.();
+ assert.equal(openMock.mock.calls.at(-1)?.[0], session.id);
+});
+
+beforeEach(() => {
+ vi.clearAllMocks();
+});
diff --git a/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.ts b/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.ts
new file mode 100644
index 0000000000..ba488d0978
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.ts
@@ -0,0 +1,66 @@
+import { strict as assert } from "node:assert";
+import { test, vi } from "vitest";
+
+const apiMock = vi.hoisted(() => ({
+ prepareSchemaDiff: vi.fn(),
+}));
+const openMock = vi.hoisted(() => vi.fn());
+const trackerMock = vi.hoisted(() => ({
+ addSchemaDiffTask: vi.fn(),
+ updateCompareTask: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => apiMock);
+vi.mock("@/composables/useDialogSources", () => ({ openSchemaDiffSession: openMock }));
+vi.mock("@/composables/useExportTracker", () => ({ useExportTracker: () => trackerMock }));
+vi.mock("@/lib/schema/schemaDiffMetadataLoad", () => ({ loadSchemaDetails: vi.fn().mockResolvedValue([]) }));
+
+const { startSchemaDiffSession } = await import("../useSchemaDiffSession.ts");
+
+test("runs a schema diff session after the dialog is closed and retains the prepared result", async () => {
+ apiMock.prepareSchemaDiff.mockResolvedValue({
+ diffs: [],
+ functionDiffs: [],
+ sequenceDiffs: [],
+ ruleDiffs: [],
+ ownerDiffs: [],
+ renameCandidates: [],
+ syncSql: "",
+ rollbackSyncSql: "",
+ });
+
+ const tableListLoader = {
+ load: vi.fn().mockResolvedValue([]),
+ };
+ const session = startSchemaDiffSession(
+ {
+ sourceConnectionId: "source",
+ sourceDatabase: "app",
+ sourceSchema: "public",
+ targetConnectionId: "target",
+ targetDatabase: "warehouse",
+ targetSchema: "public",
+ sourceDbType: "mysql",
+ targetDbType: "mysql",
+ options: {},
+ ignoreComments: false,
+ label: "app → warehouse",
+ },
+ { tableListLoader },
+ );
+
+ for (let attempt = 0; attempt < 20 && session.status === "running"; attempt += 1) {
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ }
+
+ assert.equal(session.status, "completed");
+ assert.deepEqual(session.result?.diffs, []);
+ assert.equal(tableListLoader.load.mock.calls.length, 2);
+ assert.equal(tableListLoader.load.mock.calls[0]?.[1]?.refresh, true);
+ assert.equal(trackerMock.addSchemaDiffTask.mock.calls.length, 1);
+ assert.equal(trackerMock.updateCompareTask.mock.calls.at(-1)?.[1].status, "Done");
+
+ const onOpen = trackerMock.addSchemaDiffTask.mock.calls[0]?.[2] as (() => void) | undefined;
+ onOpen?.();
+ assert.equal(openMock.mock.calls.at(-1)?.[0], session.id);
+});
diff --git a/apps/desktop/src/composables/useDataCompareSession.ts b/apps/desktop/src/composables/useDataCompareSession.ts
new file mode 100644
index 0000000000..39f48a5622
--- /dev/null
+++ b/apps/desktop/src/composables/useDataCompareSession.ts
@@ -0,0 +1,436 @@
+import { reactive, shallowReactive } from "vue";
+import { uuid } from "@/lib/common/utils";
+import * as api from "@/lib/backend/api";
+import { openDataCompareSession } from "@/composables/useDialogSources";
+import { useExportTracker } from "@/composables/useExportTracker";
+import { inferCompareKeyColumns, intersectCompareColumns, matchColumnNameIgnoreCase, type DataCompareCellValue, type DataCompareFromTablesPreparation, type DataCompareResult, type DataCompareSyncPlan, type DataCompareSyncPlanTableOptions } from "@/lib/dataGrid/dataCompare";
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+
+export type CompareColumn = ColumnInfo;
+
+export interface DataCompareTableTask {
+ sourceTable: string;
+ targetTable: string;
+}
+
+export type DataCompareTableStatus = "different" | "same" | "error";
+export type DiffKind = "added" | "removed" | "modified";
+
+export interface SelectableDataCompareRow {
+ key: string;
+ keyValues: Record<string, DataCompareCellValue>;
+ values: Record<string, DataCompareCellValue>;
+ selected: boolean;
+}
+
+export interface SelectableDataCompareModifiedRow {
+ key: string;
+ keyValues: Record<string, DataCompareCellValue>;
+ sourceValues: Record<string, DataCompareCellValue>;
+ targetValues: Record<string, DataCompareCellValue>;
+ changes: { column: string; source: DataCompareCellValue; target: DataCompareCellValue }[];
+ selected: boolean;
+}
+
+export interface SelectableDataCompareResult {
+ added: SelectableDataCompareRow[];
+ removed: SelectableDataCompareRow[];
+ modified: SelectableDataCompareModifiedRow[];
+}
+
+export interface DataCompareTableResult {
+ sourceTable: string;
+ targetTable: string;
+ keyColumns: string[];
+ columns: string[];
+ columnInfo: CompareColumn[];
+ status: DataCompareTableStatus;
+ added: number;
+ removed: number;
+ modified: number;
+ sourceRowCount: number;
+ targetRowCount: number;
+ sourceTruncated: boolean;
+ targetTruncated: boolean;
+ databaseType?: DatabaseType;
+ preSyncStatements?: string[];
+ diff: SelectableDataCompareResult;
+ expanded: boolean;
+ showAll: Record<DiffKind, boolean>;
+ error?: string;
+}
+
+export interface DataCompareSessionConfig {
+ sourceConnectionId: string;
+ sourceDatabase: string;
+ sourceSchema: string;
+ sourceDatabases: string[];
+ sourceSchemas: string[];
+ sourceTables: string[];
+ selectedSourceTables: string[];
+ targetConnectionId: string;
+ targetDatabase: string;
+ targetSchema: string;
+ targetDatabases: string[];
+ targetSchemas: string[];
+ targetTables: string[];
+ targetTable: string;
+ keyColumns: string[];
+ label: string;
+}
+
+export interface DataCompareSessionProgress {
+ current: number;
+ total: number;
+ table: string;
+}
+
+export type DataCompareSessionStatus = "running" | "completed" | "failed";
+export type DataCompareSessionErrorKind = "noKeyColumns" | "missingKeyColumns" | "noCommonColumns";
+
+export interface DataCompareSession {
+ id: string;
+ version: number;
+ status: DataCompareSessionStatus;
+ config: DataCompareSessionConfig;
+ progress: DataCompareSessionProgress | null;
+ batchResults: DataCompareTableResult[];
+ syncPlan: DataCompareSyncPlan;
+ error: string | null;
+ startedAt: number;
+ finishedAt?: number;
+}
+
+export interface DataCompareSessionDependencies {
+ ensureConnected(connectionId: string): Promise<unknown>;
+ getConfig(connectionId: string): { db_type?: DatabaseType } | undefined;
+ formatError?: (kind: DataCompareSessionErrorKind, columns?: string) => string;
+}
+
+const sessions = reactive(new Map<string, DataCompareSession>());
+
+export function emptyDataCompareSyncPlan(): DataCompareSyncPlan {
+ return {
+ insertCount: 0,
+ updateCount: 0,
+ deleteCount: 0,
+ statementCount: 0,
+ syncStatements: [],
+ syncSql: "",
+ };
+}
+
+function cloneConfig(config: DataCompareSessionConfig): DataCompareSessionConfig {
+ return {
+ ...config,
+ sourceDatabases: [...config.sourceDatabases],
+ sourceSchemas: [...config.sourceSchemas],
+ sourceTables: [...config.sourceTables],
+ selectedSourceTables: [...config.selectedSourceTables],
+ targetDatabases: [...config.targetDatabases],
+ targetSchemas: [...config.targetSchemas],
+ targetTables: [...config.targetTables],
+ keyColumns: [...config.keyColumns],
+ };
+}
+
+function sessionError(error: unknown): string {
+ return error instanceof Error ? error.message : (error as { message?: string } | null)?.message || String(error);
+}
+
+function compareErrorMessage(dependencies: DataCompareSessionDependencies, kind: DataCompareSessionErrorKind, columns?: string): string {
+ return dependencies.formatError?.(kind, columns) ?? (kind === "missingKeyColumns" ? `Missing key columns: ${columns ?? ""}` : kind === "noCommonColumns" ? "No common columns" : "No key columns available");
+}
+
+function toSelectableDiff(diff: DataCompareResult): SelectableDataCompareResult {
+ return {
+ added: diff.added.map((row) => ({ ...row, selected: true })),
+ removed: diff.removed.map((row) => ({ ...row, selected: true })),
+ modified: diff.modified.map((row) => ({ ...row, selected: true })),
+ };
+}
+
+export function buildDataCompareSyncPlanTables(results: DataCompareTableResult[], targetSchema: string): DataCompareSyncPlanTableOptions[] {
+ return results
+ .filter((table) => table.status === "different")
+ .map((table) => ({
+ tableName: table.targetTable,
+ schema: targetSchema,
+ columns: table.columns,
+ keyColumns: table.keyColumns,
+ columnInfo: table.columnInfo,
+ diff: {
+ added: table.diff.added.filter((row) => row.selected).map(({ selected: _selected, ...row }) => row),
+ removed: table.diff.removed.filter((row) => row.selected).map(({ selected: _selected, ...row }) => row),
+ modified: table.diff.modified.filter((row) => row.selected).map(({ selected: _selected, ...row }) => row),
+ },
+ databaseType: table.databaseType,
+ preSyncStatements: table.preSyncStatements ?? [],
+ }))
+ .filter((table) => table.preSyncStatements.length > 0 || table.diff.added.length > 0 || table.diff.removed.length > 0 || table.diff.modified.length > 0);
+}
+
+function publishProgress(session: DataCompareSession, progress: DataCompareSessionProgress): void {
+ session.version += 1;
+ session.progress = progress;
+ const results = session.batchResults;
+ const failedTableCount = results.filter((item) => item.status === "error").length;
+ const tracker = useExportTracker();
+ tracker.updateCompareTask(session.id, {
+ status: "Running",
+ compareCurrent: progress.current,
+ compareTotal: progress.total,
+ compareCurrentObject: progress.table,
+ compareResultCount: results.length,
+ compareSameCount: results.filter((item) => item.status === "same").length,
+ compareDifferentCount: results.filter((item) => item.status === "different").length,
+ compareFailedCount: failedTableCount,
+ compareAddedCount: results.reduce((sum, item) => sum + item.added, 0),
+ compareRemovedCount: results.reduce((sum, item) => sum + item.removed, 0),
+ compareModifiedCount: results.reduce((sum, item) => sum + item.modified, 0),
+ });
+}
+
+function updateResults(session: DataCompareSession, results: DataCompareTableResult[]): void {
+ session.batchResults = [...results];
+}
+
+async function loadColumnsWithCache(cache: Map<string, CompareColumn[]>, connectionId: string, database: string, schema: string, table: string): Promise<CompareColumn[]> {
+ const key = `${connectionId}:${database}:${schema}:${table}`;
+ const cached = cache.get(key);
+ if (cached) return cached;
+ const columns = (await api.getColumns(connectionId, database, schema, table)) as CompareColumn[];
+ cache.set(key, columns);
+ return columns;
+}
+
+async function inferKeyColumnsForTable(input: DataCompareSessionConfig, table: string, sourceColumnCache: Map<string, CompareColumn[]>): Promise<string[]> {
+ if (!input.sourceConnectionId || !input.sourceDatabase || !input.sourceSchema || !table) return [];
+ const columns = await loadColumnsWithCache(sourceColumnCache, input.sourceConnectionId, input.sourceDatabase, input.sourceSchema, table);
+ return inferCompareKeyColumns(columns);
+}
+
+function buildTableResult(task: DataCompareTableTask, preparation: DataCompareFromTablesPreparation, keyColumns: string[], columns: string[], columnInfo: CompareColumn[], databaseType: DatabaseType | undefined): DataCompareTableResult {
+ const added = preparation.result.added.length;
+ const removed = preparation.result.removed.length;
+ const modified = preparation.result.modified.length;
+ const status: DataCompareTableStatus = added || removed || modified ? "different" : "same";
+ return {
+ sourceTable: task.sourceTable,
+ targetTable: task.targetTable,
+ keyColumns,
+ columns,
+ columnInfo,
+ status,
+ added,
+ removed,
+ modified,
+ sourceRowCount: preparation.sourceRowCount,
+ targetRowCount: preparation.targetRowCount,
+ sourceTruncated: preparation.sourceTruncated,
+ targetTruncated: preparation.targetTruncated,
+ databaseType,
+ preSyncStatements: preparation.preSyncStatements,
+ diff: toSelectableDiff(preparation.result),
+ expanded: status === "different",
+ showAll: { added: false, removed: false, modified: false },
+ };
+}
+
+function buildMissingTargetResult(task: DataCompareTableTask, preparation: DataCompareFromTablesPreparation, sourceColumns: CompareColumn[], keyColumns: string[], databaseType: DatabaseType | undefined): DataCompareTableResult {
+ return {
+ sourceTable: task.sourceTable,
+ targetTable: task.targetTable,
+ keyColumns,
+ columns: sourceColumns.map((column) => column.name),
+ columnInfo: sourceColumns,
+ status: "different",
+ added: preparation.result.added.length,
+ removed: 0,
+ modified: 0,
+ sourceRowCount: preparation.sourceRowCount,
+ targetRowCount: 0,
+ sourceTruncated: preparation.sourceTruncated,
+ targetTruncated: false,
+ databaseType,
+ preSyncStatements: preparation.preSyncStatements,
+ diff: toSelectableDiff(preparation.result),
+ expanded: preparation.result.added.length > 0,
+ showAll: { added: false, removed: false, modified: false },
+ };
+}
+
+function buildErrorResult(task: DataCompareTableTask, keyColumns: string[], databaseType: DatabaseType | undefined, error: unknown): DataCompareTableResult {
+ return {
+ sourceTable: task.sourceTable,
+ targetTable: task.targetTable,
+ keyColumns,
+ columns: [],
+ columnInfo: [],
+ status: "error",
+ added: 0,
+ removed: 0,
+ modified: 0,
+ sourceRowCount: 0,
+ targetRowCount: 0,
+ sourceTruncated: false,
+ targetTruncated: false,
+ databaseType,
+ preSyncStatements: [],
+ diff: { added: [], removed: [], modified: [] },
+ expanded: false,
+ showAll: { added: false, removed: false, modified: false },
+ error: sessionError(error),
+ };
+}
+
+async function runDataCompareSession(session: DataCompareSession, tasks: DataCompareTableTask[], dependencies: DataCompareSessionDependencies): Promise<void> {
+ const input = session.config;
+ const sourceColumnCache = new Map<string, CompareColumn[]>();
+ const targetColumnCache = new Map<string, CompareColumn[]>();
+ const results: DataCompareTableResult[] = [];
+ const databaseType = dependencies.getConfig(input.targetConnectionId)?.db_type;
+
+ try {
+ publishProgress(session, { current: 0, total: tasks.length, table: "" });
+ await Promise.all([dependencies.ensureConnected(input.sourceConnectionId), dependencies.ensureConnected(input.targetConnectionId)]);
+
+ for (const [index, task] of tasks.entries()) {
+ publishProgress(session, { current: index + 1, total: tasks.length, table: task.sourceTable });
+ let keyColumns = input.keyColumns;
+ try {
+ if (input.targetTables.includes(task.targetTable)) {
+ const resolvedKeys = input.keyColumns.length > 0 ? input.keyColumns : await inferKeyColumnsForTable(input, task.sourceTable, sourceColumnCache);
+ if (resolvedKeys.length === 0) throw new Error(compareErrorMessage(dependencies, "noKeyColumns"));
+
+ const sourceColumns = await loadColumnsWithCache(sourceColumnCache, input.sourceConnectionId, input.sourceDatabase, input.sourceSchema, task.sourceTable);
+ const targetColumns = await loadColumnsWithCache(targetColumnCache, input.targetConnectionId, input.targetDatabase, input.targetSchema, task.targetTable);
+ const matched = intersectCompareColumns(sourceColumns, targetColumns);
+ const columns = matched.columns;
+ const columnInfo = columns.map((column) => targetColumns.find((target) => target.name === column)).filter((column): column is CompareColumn => !!column);
+ const canonicalKeyColumns: string[] = [];
+ const missingKeys: string[] = [];
+ for (const key of resolvedKeys) {
+ const canonical = matchColumnNameIgnoreCase(key, columns);
+ if (!canonical) missingKeys.push(key);
+ else if (!canonicalKeyColumns.includes(canonical)) canonicalKeyColumns.push(canonical);
+ }
+ if (missingKeys.length > 0) throw new Error(compareErrorMessage(dependencies, "missingKeyColumns", missingKeys.join(", ")));
+ if (columns.length === 0) throw new Error(compareErrorMessage(dependencies, "noCommonColumns"));
+
+ const preparation = await api.prepareDataCompareFromTables({
+ sourceConnectionId: input.sourceConnectionId,
+ sourceDatabase: input.sourceDatabase,
+ sourceSchema: input.sourceSchema,
+ sourceTable: task.sourceTable,
+ targetConnectionId: input.targetConnectionId,
+ targetDatabase: input.targetDatabase,
+ targetSchema: input.targetSchema,
+ targetTable: task.targetTable,
+ columns,
+ keyColumns: canonicalKeyColumns,
+ sourceColumns: matched.sourceColumns,
+ });
+ keyColumns = canonicalKeyColumns;
+ results.push(buildTableResult(task, preparation, canonicalKeyColumns, columns, columnInfo, databaseType));
+ } else {
+ const sourceColumns = await loadColumnsWithCache(sourceColumnCache, input.sourceConnectionId, input.sourceDatabase, input.sourceSchema, task.sourceTable);
+ const resolvedKeys = input.keyColumns.length > 0 ? input.keyColumns : [];
+ const sourceColumnNames = sourceColumns.map((column) => column.name);
+ keyColumns = resolvedKeys.map((key) => matchColumnNameIgnoreCase(key, sourceColumnNames) ?? key);
+ const preparation = await api.prepareDataCompareMissingTarget({
+ sourceConnectionId: input.sourceConnectionId,
+ sourceDatabase: input.sourceDatabase,
+ sourceSchema: input.sourceSchema,
+ sourceTable: task.sourceTable,
+ targetConnectionId: input.targetConnectionId,
+ targetDatabase: input.targetDatabase,
+ targetSchema: input.targetSchema,
+ targetTable: task.targetTable,
+ keyColumns,
+ });
+ results.push(buildMissingTargetResult(task, preparation, sourceColumns, keyColumns, databaseType));
+ }
+ } catch (error: unknown) {
+ results.push(buildErrorResult(task, keyColumns, databaseType, error));
+ }
+ updateResults(session, results);
+ publishProgress(session, { current: index + 1, total: tasks.length, table: task.sourceTable });
+ }
+
+ const plan = await api.buildDataCompareSyncPlan({ tables: buildDataCompareSyncPlanTables(results, input.targetSchema) });
+ session.syncPlan = plan;
+ session.progress = null;
+ session.status = "completed";
+ session.version += 1;
+ session.finishedAt = Date.now();
+ const sameCount = results.filter((item) => item.status === "same").length;
+ const differentCount = results.filter((item) => item.status === "different").length;
+ const failedCount = results.filter((item) => item.status === "error").length;
+ useExportTracker().updateCompareTask(session.id, {
+ status: failedCount > 0 ? "Error" : "Done",
+ compareCurrent: tasks.length,
+ compareTotal: tasks.length,
+ compareCurrentObject: "",
+ compareResultCount: results.length,
+ compareSameCount: sameCount,
+ compareDifferentCount: differentCount,
+ compareFailedCount: failedCount,
+ compareAddedCount: results.reduce((sum, item) => sum + item.added, 0),
+ compareRemovedCount: results.reduce((sum, item) => sum + item.removed, 0),
+ compareModifiedCount: results.reduce((sum, item) => sum + item.modified, 0),
+ errorMessage: failedCount > 0 ? `${failedCount} table(s) failed` : null,
+ });
+ } catch (error: unknown) {
+ const message = sessionError(error);
+ const lastProgress = session.progress;
+ session.error = message;
+ session.progress = null;
+ session.status = "failed";
+ session.version += 1;
+ session.finishedAt = Date.now();
+ useExportTracker().updateCompareTask(session.id, {
+ status: "Error",
+ errorMessage: message,
+ compareCurrent: lastProgress?.current,
+ compareTotal: lastProgress?.total,
+ compareCurrentObject: lastProgress?.table,
+ });
+ }
+}
+
+export function startDataCompareSession(input: DataCompareSessionConfig, tasks: DataCompareTableTask[], dependencies: DataCompareSessionDependencies): DataCompareSession {
+ const id = uuid();
+ const session = shallowReactive<DataCompareSession>({
+ id,
+ version: 0,
+ status: "running",
+ config: cloneConfig(input),
+ progress: null,
+ batchResults: [],
+ syncPlan: emptyDataCompareSyncPlan(),
+ error: null,
+ startedAt: Date.now(),
+ });
+ sessions.set(id, session);
+
+ const tracker = useExportTracker();
+ tracker.addDataCompareTask(
+ id,
+ input.label,
+ () => openDataCompareSession(id),
+ () => removeDataCompareSession(id),
+ );
+ void runDataCompareSession(session, tasks, dependencies);
+ return session;
+}
+
+export function getDataCompareSession(id: string | null | undefined): DataCompareSession | undefined {
+ return id ? sessions.get(id) : undefined;
+}
+
+export function removeDataCompareSession(id: string): boolean {
+ const session = sessions.get(id);
+ if (session?.status === "running") return false;
+ return sessions.delete(id);
+}
diff --git a/apps/desktop/src/composables/useDialogSources.ts b/apps/desktop/src/composables/useDialogSources.ts
index 4668a05b79..a56a2a1266 100644
--- a/apps/desktop/src/composables/useDialogSources.ts
+++ b/apps/desktop/src/composables/useDialogSources.ts
@@ -45,10 +45,12 @@ const transferPrefillTargetSchema = ref("");
const schemaDiffPrefillConnectionId = ref("");
const schemaDiffPrefillDatabase = ref("");
const schemaDiffPrefillSchema = ref("");
+const schemaDiffSessionId = ref<string | null>(null);
const dataComparePrefillConnectionId = ref("");
const dataComparePrefillDatabase = ref("");
const dataComparePrefillSchema = ref("");
const dataComparePrefillTable = ref("");
+const dataCompareSessionId = ref<string | null>(null);
const sqlFilePrefillConnectionId = ref("");
const sqlFilePrefillDatabase = ref("");
const sqlFilePrefillFilePath = ref("");
@@ -96,6 +98,16 @@ function clearTransferPrefill() {
transferPrefillTargetSchema.value = "";
}
+export function openSchemaDiffSession(sessionId: string): void {
+ schemaDiffSessionId.value = sessionId;
+ showSchemaDiffDialog.value = true;
+}
+
+export function openDataCompareSession(sessionId: string): void {
+ dataCompareSessionId.value = sessionId;
+ showDataCompareDialog.value = true;
+}
+
export function useDialogSources() {
const { t } = useI18n();
const connectionStore = useConnectionStore();
@@ -134,6 +146,7 @@ export function useDialogSources() {
schemaDiffPrefillConnectionId.value = v.connectionId;
schemaDiffPrefillDatabase.value = v.database;
schemaDiffPrefillSchema.value = v.schema ?? "";
+ schemaDiffSessionId.value = null;
showSchemaDiffDialog.value = true;
connectionStore.schemaDiffSource = null;
}
@@ -148,12 +161,21 @@ export function useDialogSources() {
dataComparePrefillDatabase.value = v.database;
dataComparePrefillSchema.value = v.schema ?? "";
dataComparePrefillTable.value = v.tableName ?? "";
+ dataCompareSessionId.value = null;
showDataCompareDialog.value = true;
connectionStore.dataCompareSource = null;
}
},
);
+ watch(showSchemaDiffDialog, (open) => {
+ if (!open) schemaDiffSessionId.value = null;
+ });
+
+ watch(showDataCompareDialog, (open) => {
+ if (!open) dataCompareSessionId.value = null;
+ });
+
watch(
() => connectionStore.sqlFileSource,
(v) => {
@@ -502,10 +524,12 @@ export function useDialogSources() {
schemaDiffPrefillConnectionId,
schemaDiffPrefillDatabase,
schemaDiffPrefillSchema,
+ schemaDiffSessionId,
dataComparePrefillConnectionId,
dataComparePrefillDatabase,
dataComparePrefillSchema,
dataComparePrefillTable,
+ dataCompareSessionId,
sqlFilePrefillConnectionId,
sqlFilePrefillDatabase,
sqlFilePrefillFilePath,
diff --git a/apps/desktop/src/composables/useExportTracker.ts b/apps/desktop/src/composables/useExportTracker.ts
index ca3bac514e..9d3143cb83 100644
--- a/apps/desktop/src/composables/useExportTracker.ts
+++ b/apps/desktop/src/composables/useExportTracker.ts
@@ -2,7 +2,7 @@ import { reactive, computed } from "vue";
import * as api from "@/lib/backend/api";
import { isTerminalTransferProgress } from "@/lib/backend/transferProgress";
-export type BackgroundTaskKind = "table-export" | "database-export" | "sql-file" | "data-transfer" | "multi-db-execution";
+export type BackgroundTaskKind = "table-export" | "database-export" | "sql-file" | "data-transfer" | "multi-db-execution" | "schema-diff" | "data-compare";
export type BackgroundTaskStatus = "Running" | "Writing" | "Cancelling" | "Done" | "Error" | "Cancelled";
export type DatabaseExportSource = "manual" | "scheduled";
@@ -70,7 +70,36 @@ export interface ExportTask {
multiDbSkippedCount?: number;
multiDbNotExecutedCount?: number;
currentTarget?: { connectionId: string; catalog?: string; database: string; schema?: string };
+ comparePhase?: string;
+ compareCurrent?: number;
+ compareTotal?: number;
+ compareCurrentObject?: string;
+ compareResultCount?: number;
+ compareSameCount?: number;
+ compareDifferentCount?: number;
+ compareFailedCount?: number;
+ compareAddedCount?: number;
+ compareRemovedCount?: number;
+ compareModifiedCount?: number;
+ canCancel?: boolean;
onOpen?: () => void;
+ onRemove?: () => void;
+}
+
+export interface CompareTaskProgress {
+ status: Extract<BackgroundTaskStatus, "Running" | "Done" | "Error" | "Cancelled">;
+ comparePhase?: string;
+ compareCurrent?: number;
+ compareTotal?: number;
+ compareCurrentObject?: string;
+ compareResultCount?: number;
+ compareSameCount?: number;
+ compareDifferentCount?: number;
+ compareFailedCount?: number;
+ compareAddedCount?: number;
+ compareRemovedCount?: number;
+ compareModifiedCount?: number;
+ errorMessage?: string | null;
}
export interface MultiDbExecutionTaskProgress {
@@ -458,6 +487,37 @@ export function useExportTracker() {
return task;
}
+ function addCompareTask(kind: "schema-diff" | "data-compare", sessionId: string, label: string, onOpen?: () => void, onRemove?: () => void): ExportTask {
+ const task = reactive<ExportTask>({
+ exportId: sessionId,
+ kind,
+ tableName: label,
+ format: "compare",
+ filePath: "",
+ rowsExported: 0,
+ totalRows: null,
+ status: "Running",
+ errorMessage: null,
+ compareCurrent: 0,
+ compareTotal: 0,
+ compareCurrentObject: "",
+ canCancel: false,
+ onOpen,
+ onRemove,
+ startedAt: Date.now(),
+ });
+ taskMap.set(sessionId, task);
+ return task;
+ }
+
+ function addSchemaDiffTask(sessionId: string, label: string, onOpen?: () => void, onRemove?: () => void): ExportTask {
+ return addCompareTask("schema-diff", sessionId, label, onOpen, onRemove);
+ }
+
+ function addDataCompareTask(sessionId: string, label: string, onOpen?: () => void, onRemove?: () => void): ExportTask {
+ return addCompareTask("data-compare", sessionId, label, onOpen, onRemove);
+ }
+
function addMultiDbExecutionTask(batchId: string, label: string, sourceTabId: string, onOpen?: () => void): ExportTask {
const task = reactive<ExportTask>({
exportId: batchId,
@@ -642,7 +702,36 @@ export function useExportTracker() {
task.totalRows = progress.totalRows ?? task.totalRows;
}
+ function updateCompareTask(sessionId: string, progress: CompareTaskProgress): void {
+ const task = taskMap.get(sessionId);
+ if (!task || (task.kind !== "schema-diff" && task.kind !== "data-compare")) return;
+ task.status = progress.status;
+ task.comparePhase = progress.comparePhase;
+ task.compareCurrent = progress.compareCurrent;
+ task.compareTotal = progress.compareTotal;
+ task.compareCurrentObject = progress.compareCurrentObject;
+ task.compareResultCount = progress.compareResultCount;
+ task.compareSameCount = progress.compareSameCount;
+ task.compareDifferentCount = progress.compareDifferentCount;
+ task.compareFailedCount = progress.compareFailedCount;
+ task.compareAddedCount = progress.compareAddedCount;
+ task.compareRemovedCount = progress.compareRemovedCount;
+ task.compareModifiedCount = progress.compareModifiedCount;
+ task.errorMessage = progress.errorMessage ?? null;
+ if (task.status === "Done" || task.status === "Error" || task.status === "Cancelled") finishExportTask(task);
+ }
+
+ function cleanupFinishedTask(task: ExportTask): void {
+ try {
+ task.onRemove?.();
+ } catch {
+ // cleanup hooks must not prevent the task from being removed
+ }
+ }
+
function removeTask(exportId: string) {
+ const task = taskMap.get(exportId);
+ if (task && (task.status === "Done" || task.status === "Error" || task.status === "Cancelled")) cleanupFinishedTask(task);
taskMap.delete(exportId);
taskCancelHandlers.delete(exportId);
transferFailureStates.delete(exportId);
@@ -652,6 +741,7 @@ export function useExportTracker() {
function clearFinished() {
for (const [id, task] of taskMap) {
if (task.status === "Done" || task.status === "Error" || task.status === "Cancelled") {
+ cleanupFinishedTask(task);
taskMap.delete(id);
taskCancelHandlers.delete(id);
transferFailureStates.delete(id);
@@ -670,6 +760,7 @@ export function useExportTracker() {
async function cancelTask(exportId: string) {
const task = taskMap.get(exportId);
+ if (task?.canCancel === false) return;
try {
const customHandler = taskCancelHandlers.get(exportId);
if (customHandler) {
@@ -696,6 +787,8 @@ export function useExportTracker() {
addDatabaseExportTask,
addSqlFileTask,
addDataTransferTask,
+ addSchemaDiffTask,
+ addDataCompareTask,
addMultiDbExecutionTask,
updateMultiDbExecutionTask,
startDataTransferTask,
@@ -705,6 +798,7 @@ export function useExportTracker() {
restoreDatabaseExportTaskRunning,
updateSqlFileTask,
updateDataTransferTask,
+ updateCompareTask,
registerTaskCancelHandler,
unregisterTaskCancelHandler,
removeTask,
diff --git a/apps/desktop/src/composables/useSchemaDiffSession.ts b/apps/desktop/src/composables/useSchemaDiffSession.ts
new file mode 100644
index 0000000000..c6a1988ba6
--- /dev/null
+++ b/apps/desktop/src/composables/useSchemaDiffSession.ts
@@ -0,0 +1,284 @@
+import { reactive, shallowReactive } from "vue";
+import { uuid } from "@/lib/common/utils";
+import * as api from "@/lib/backend/api";
+import { openSchemaDiffSession } from "@/composables/useDialogSources";
+import { useExportTracker } from "@/composables/useExportTracker";
+import { filterSchemaDiffTables } from "@/lib/schema/schemaDiffTableFilter";
+import { compileSchemaDiffTableFilter } from "@/lib/schema/schemaDiffTableFilter";
+import { loadSchemaDetails } from "@/lib/schema/schemaDiffMetadataLoad";
+import type { SchemaDiffTableIdentity, SchemaDiffTableListLoader } from "@/lib/schema/schemaDiffTableList";
+import { getSchemaDiffNextProgressStep, isSchemaDiffPostgresLike, shouldLoadSchemaDiffExtraObjects, type SchemaDiffProgressPhase } from "@/lib/schema/schemaDiffProgress";
+import { convertToSchemaDiffObjects, databaseTypeToDialectKind, normalizeDialectKind, schemaDiffDeployTargetSchema, type SchemaDiffObject } from "@/lib/schema/schemaDiff";
+import { normalizeSchemaDiffCompareOptions, type SchemaDiffCompareOptions } from "@/types/schemaDiff";
+import type { DatabaseType } from "@/types/database";
+import type { SchemaDiffPreparation } from "@/lib/schema/schemaDiff";
+
+export interface SchemaDiffSessionProgress {
+ phase: SchemaDiffProgressPhase;
+ current?: number;
+ total?: number;
+ objectName?: string;
+}
+
+export interface SchemaDiffSessionConfig {
+ sourceConnectionId: string;
+ sourceDatabase: string;
+ sourceSchema: string;
+ targetConnectionId: string;
+ targetDatabase: string;
+ targetSchema: string;
+ sourceDbType: string;
+ targetDbType: DatabaseType;
+ options: SchemaDiffCompareOptions;
+ ignoreComments: boolean;
+ label: string;
+}
+
+export type SchemaDiffSessionStatus = "running" | "completed" | "failed";
+
+export interface SchemaDiffSession {
+ id: string;
+ version: number;
+ status: SchemaDiffSessionStatus;
+ config: SchemaDiffSessionConfig;
+ progress: SchemaDiffSessionProgress | null;
+ result: SchemaDiffPreparation | null;
+ error: string | null;
+ startedAt: number;
+ finishedAt?: number;
+}
+
+export interface SchemaDiffSessionDependencies {
+ tableListLoader: SchemaDiffTableListLoader;
+}
+
+const sessions = reactive(new Map<string, SchemaDiffSession>());
+
+function cloneOptions(options: SchemaDiffCompareOptions): SchemaDiffCompareOptions {
+ return {
+ ...options,
+ selectedTables: options.selectedTables ? [...options.selectedTables] : options.selectedTables,
+ tableMappings: options.tableMappings?.map((mapping) => ({ ...mapping })),
+ fieldMappings: options.fieldMappings?.map((mapping) => ({ ...mapping })),
+ };
+}
+
+function resultObjectCount(result: SchemaDiffPreparation): number {
+ return result.diffs.length + (result.functionDiffs?.length ?? 0) + (result.sequenceDiffs?.length ?? 0) + (result.ruleDiffs?.length ?? 0) + (result.ownerDiffs?.length ?? 0);
+}
+
+function sessionError(error: unknown): string {
+ return error instanceof Error ? error.message : (error as { message?: string } | null)?.message || String(error);
+}
+
+function publishProgress(session: SchemaDiffSession, progress: SchemaDiffSessionProgress): void {
+ session.version += 1;
+ session.progress = progress;
+ useExportTracker().updateCompareTask(session.id, {
+ status: "Running",
+ comparePhase: progress.phase,
+ compareCurrent: progress.current,
+ compareTotal: progress.total,
+ compareCurrentObject: progress.objectName,
+ });
+}
+
+async function runSchemaDiffSession(session: SchemaDiffSession, dependencies: SchemaDiffSessionDependencies): Promise<void> {
+ const input = session.config;
+ const tracker = useExportTracker();
+ const options = normalizeSchemaDiffCompareOptions(input.options, input.targetDbType);
+ const isPostgresLike = isSchemaDiffPostgresLike(input.targetDbType);
+ const hasExtraObjectPhase = shouldLoadSchemaDiffExtraObjects(input.targetDbType, options);
+ const tableFilter = compileSchemaDiffTableFilter(options);
+
+ try {
+ publishProgress(session, { phase: "loading-table-lists" });
+
+ const sourceTableIdentity: SchemaDiffTableIdentity = {
+ connectionId: input.sourceConnectionId,
+ database: input.sourceDatabase,
+ schema: input.sourceSchema,
+ };
+ const targetTableIdentity: SchemaDiffTableIdentity = {
+ connectionId: input.targetConnectionId,
+ database: input.targetDatabase,
+ schema: input.targetSchema,
+ };
+ const [sourceTableList, targetTableList] = await Promise.all([dependencies.tableListLoader.load(sourceTableIdentity, { refresh: true }), dependencies.tableListLoader.load(targetTableIdentity, { refresh: true })]);
+ const { sourceTables, targetTables } = filterSchemaDiffTables(sourceTableList, targetTableList, tableFilter, options, options.selectedTables);
+
+ publishProgress(session, { phase: "loading-source-details", current: 0, total: sourceTables.length });
+ const sourceDetails = await loadSchemaDetails(
+ sourceTables,
+ {
+ connectionId: input.sourceConnectionId,
+ database: input.sourceDatabase,
+ schema: input.sourceSchema,
+ dbType: input.sourceDbType,
+ options,
+ onProgress: (progress) => publishProgress(session, { phase: "loading-source-details", ...progress }),
+ },
+ api,
+ );
+
+ publishProgress(session, { phase: "loading-target-details", current: 0, total: targetTables.length });
+ const targetDetails = await loadSchemaDetails(
+ targetTables,
+ {
+ connectionId: input.targetConnectionId,
+ database: input.targetDatabase,
+ schema: input.targetSchema,
+ dbType: input.targetDbType,
+ options,
+ onProgress: (progress) => publishProgress(session, { phase: "loading-target-details", ...progress }),
+ },
+ api,
+ );
+
+ const promises: Promise<unknown>[] = [];
+ if (isPostgresLike && options.functions) {
+ promises.push(api.listFunctions(input.sourceConnectionId, input.sourceDatabase, input.sourceSchema));
+ promises.push(api.listFunctions(input.targetConnectionId, input.targetDatabase, input.targetSchema));
+ }
+ if (isPostgresLike && options.sequences) {
+ promises.push(api.listSequences(input.sourceConnectionId, input.sourceDatabase, input.sourceSchema, !!options.sequenceLastValues));
+ promises.push(api.listSequences(input.targetConnectionId, input.targetDatabase, input.targetSchema, !!options.sequenceLastValues));
+ }
+ if (isPostgresLike && options.rules) {
+ promises.push(api.listRules(input.sourceConnectionId, input.sourceDatabase, input.sourceSchema));
+ promises.push(api.listRules(input.targetConnectionId, input.targetDatabase, input.targetSchema));
+ }
+ if (isPostgresLike && options.owners) {
+ promises.push(api.listOwners(input.sourceConnectionId, input.sourceDatabase, input.sourceSchema));
+ promises.push(api.listOwners(input.targetConnectionId, input.targetDatabase, input.targetSchema));
+ }
+
+ if (hasExtraObjectPhase) publishProgress(session, { phase: "loading-extra-objects" });
+ const extraObjects = await Promise.all(promises);
+ let index = 0;
+ const sourceFunctions = options.functions && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listFunctions>>) : [];
+ const targetFunctions = options.functions && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listFunctions>>) : [];
+ const sourceSequences = options.sequences && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listSequences>>) : [];
+ const targetSequences = options.sequences && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listSequences>>) : [];
+ const sourceRules = options.rules && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listRules>>) : [];
+ const targetRules = options.rules && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listRules>>) : [];
+ const sourceOwners = options.owners && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listOwners>>) : [];
+ const targetOwners = options.owners && isPostgresLike ? (extraObjects[index++] as Awaited<ReturnType<typeof api.listOwners>>) : [];
+
+ publishProgress(session, { phase: "comparing" });
+ const result = await api.prepareSchemaDiff({
+ sourceTables,
+ targetTables,
+ sourceDetails,
+ targetDetails,
+ sourceFunctions,
+ targetFunctions,
+ sourceSequences,
+ targetSequences,
+ sourceRules,
+ targetRules,
+ sourceOwners,
+ targetOwners,
+ tableMappings: options.selectedTables === undefined ? undefined : options.tableMappings,
+ databaseType: input.targetDbType,
+ targetSchema: schemaDiffDeployTargetSchema(input.targetDbType, input.targetDatabase, input.targetSchema),
+ ignoreComments: input.ignoreComments,
+ cascadeDelete: options.cascadeDelete ?? false,
+ compareColumnOrder: options.compareColumnOrder,
+ ignoreTableNameCase: options.ignoreTableNameCase,
+ ignoreColumnNameCase: options.ignoreColumnNameCase,
+ detectRenames: options.detectRenames ?? false,
+ detectTableRenames: options.detectTableRenames ?? false,
+ renameThreshold: options.renameThreshold ?? 0.5,
+ enableRollback: options.enableRollback ?? false,
+ batchPatterns: options.batchPatterns
+ ? options.batchPatterns
+ .split(",")
+ .map((value) => value.trim())
+ .filter(Boolean)
+ : undefined,
+ sourceDialect: options.sourceDialect ? normalizeDialectKind(options.sourceDialect) : input.sourceDbType ? databaseTypeToDialectKind(input.sourceDbType as DatabaseType) : undefined,
+ targetDialect: options.targetDialect ? normalizeDialectKind(options.targetDialect) : input.targetDbType ? databaseTypeToDialectKind(input.targetDbType) : undefined,
+ compatibilityThreshold: options.compatibilityThreshold ?? 0.5,
+ fieldMappings:
+ options.fieldMappings?.map((mapping) => ({
+ sourceType: mapping.sourceType,
+ targetType: mapping.targetType,
+ paramStrategy: mapping.paramStrategy ?? "preserve",
+ customParams: mapping.customParams,
+ })) || [],
+ });
+
+ publishProgress(session, { phase: "generating" });
+ session.result = result;
+ session.progress = { phase: "complete" };
+ session.version += 1;
+ session.status = "completed";
+ session.finishedAt = Date.now();
+ tracker.updateCompareTask(session.id, {
+ status: "Done",
+ comparePhase: "complete",
+ compareCurrent: 1,
+ compareTotal: 1,
+ compareResultCount: resultObjectCount(result),
+ });
+ } catch (error: unknown) {
+ const message = sessionError(error);
+ session.error = message;
+ session.progress = null;
+ session.version += 1;
+ session.status = "failed";
+ session.finishedAt = Date.now();
+ tracker.updateCompareTask(session.id, {
+ status: "Error",
+ errorMessage: message,
+ });
+ }
+}
+
+export function startSchemaDiffSession(input: Omit<SchemaDiffSessionConfig, "options"> & { options: SchemaDiffCompareOptions }, dependencies: SchemaDiffSessionDependencies): SchemaDiffSession {
+ const id = uuid();
+ const session = shallowReactive<SchemaDiffSession>({
+ id,
+ version: 0,
+ status: "running",
+ config: {
+ ...input,
+ options: cloneOptions(input.options),
+ },
+ progress: null,
+ result: null,
+ error: null,
+ startedAt: Date.now(),
+ });
+ sessions.set(id, session);
+
+ const tracker = useExportTracker();
+ tracker.addSchemaDiffTask(
+ id,
+ input.label,
+ () => openSchemaDiffSession(id),
+ () => removeSchemaDiffSession(id),
+ );
+ void runSchemaDiffSession(session, dependencies);
+ return session;
+}
+
+export function getSchemaDiffSession(id: string | null | undefined): SchemaDiffSession | undefined {
+ return id ? sessions.get(id) : undefined;
+}
+
+export function removeSchemaDiffSession(id: string): boolean {
+ const session = sessions.get(id);
+ if (session?.status === "running") return false;
+ return sessions.delete(id);
+}
+
+export function schemaDiffSessionNextProgressStep(session: SchemaDiffSession): string | null {
+ return getSchemaDiffNextProgressStep(session.progress?.phase, shouldLoadSchemaDiffExtraObjects(session.config.targetDbType, session.config.options));
+}
+
+export function schemaDiffSessionObjects(result: SchemaDiffPreparation | null): SchemaDiffObject[] {
+ if (!result) return [];
+ return convertToSchemaDiffObjects(result.diffs, result.functionDiffs, result.sequenceDiffs, result.ruleDiffs, result.ownerDiffs, result.renameCandidates);
+}
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index ef6370af41..636c65d233 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -2253,6 +2253,23 @@ export default {
sqlFileTitle: "SQL file: {name}",
dataTransferTitle: "Data transfer: {name}",
multiDbExecutionTitle: "Multi-database execution: {name}",
+ schemaDiffTitle: "Schema compare: {name}",
+ dataCompareTitle: "Data compare: {name}",
+ compareRunning: "Running",
+ compareDone: "Done",
+ compareError: "Error",
+ compareCancelled: "Cancelled",
+ comparePhase: {
+ loadingTableLists: "Loading table lists",
+ loadingSourceDetails: "Loading source details",
+ loadingTargetDetails: "Loading target details",
+ loadingExtraObjects: "Loading extra objects",
+ comparing: "Comparing",
+ generating: "Generating result",
+ complete: "Completed",
+ },
+ schemaDiffSummary: "{count} differing object(s)",
+ dataCompareSummary: "{tables} table(s): {same} same, {different} different, {failed} failed · +{added} / -{removed} / ~{modified}",
multiDbTargets: "Targets {completed}/{total}, succeeded {success}, failed {failed}",
openTask: "Open task",
objectsCount: "{current} / {total} objects",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 52548eabce..860ce27218 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -2187,6 +2187,23 @@ export default withEnglishFallback({
failureDetailCopied: "失败详情已复制",
failureDetailCopyFailed: "复制失败详情失败:{message}",
multiDbExecutionTitle: "多库执行:{name}",
+ schemaDiffTitle: "结构对比:{name}",
+ dataCompareTitle: "数据对比:{name}",
+ compareRunning: "运行中",
+ compareDone: "已完成",
+ compareError: "失败",
+ compareCancelled: "已取消",
+ comparePhase: {
+ loadingTableLists: "正在加载表列表",
+ loadingSourceDetails: "正在加载源端详情",
+ loadingTargetDetails: "正在加载目标端详情",
+ loadingExtraObjects: "正在加载其他对象",
+ comparing: "正在比较",
+ generating: "正在生成结果",
+ complete: "已完成",
+ },
+ schemaDiffSummary: "发现 {count} 个差异对象",
+ dataCompareSummary: "{tables} 张表:相同 {same},不同 {different},失败 {failed} · 新增 {added} / 删除 {removed} / 修改 {modified}",
multiDbTargets: "目标 {completed}/{total},成功 {success},失败 {failed}",
openTask: "打开任务",
},
diff --git a/packages/app-tests/useExportTracker.test.ts b/packages/app-tests/useExportTracker.test.ts
index a771d7a7de..a9a266aeff 100644
--- a/packages/app-tests/useExportTracker.test.ts
+++ b/packages/app-tests/useExportTracker.test.ts
@@ -405,3 +405,45 @@ test("blocks concurrent data transfers that write the same target table", () =>
terminal: true,
});
});
+
+test("tracks compare tasks without exposing cancellation and removes completed sessions", async () => {
+ const tracker = useExportTracker();
+ const onOpen = vi.fn();
+ const onRemove = vi.fn();
+ const task = tracker.addDataCompareTask("data-compare-1", "app → warehouse", onOpen, onRemove);
+
+ assert.equal(task.kind, "data-compare");
+ assert.equal(task.canCancel, false);
+ await tracker.cancelTask(task.exportId);
+ assert.equal(
+ apiMock.cancelTableExport.mock.calls.some(([id]) => id === task.exportId),
+ false,
+ );
+
+ tracker.updateCompareTask(task.exportId, {
+ status: "Running",
+ compareCurrent: 1,
+ compareTotal: 2,
+ compareCurrentObject: "users",
+ compareResultCount: 1,
+ compareDifferentCount: 1,
+ });
+ assert.equal(task.status, "Running");
+ assert.equal(task.compareCurrentObject, "users");
+
+ tracker.updateCompareTask(task.exportId, {
+ status: "Done",
+ compareCurrent: 2,
+ compareTotal: 2,
+ compareResultCount: 2,
+ });
+ assert.equal(task.status, "Done");
+ task.onOpen?.();
+ assert.equal(onOpen.mock.calls.length, 1);
+ tracker.removeTask(task.exportId);
+ assert.equal(onRemove.mock.calls.length, 1);
+ assert.equal(
+ tracker.tasks.value.some((item) => item.exportId === task.exportId),
+ false,
+ );
+});