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。

fix(data-compare): reduce UI blocking during comparison and sync

Zzza266cf0253cd
diff --git a/apps/desktop/src/components/diff/DataCompareDialog.vue b/apps/desktop/src/components/diff/DataCompareDialog.vue
index 15d610b142..91bd7abb4f 100644
--- a/apps/desktop/src/components/diff/DataCompareDialog.vue
+++ b/apps/desktop/src/components/diff/DataCompareDialog.vue
@@ -1,5 +1,8 @@
<script setup lang="ts">
-import { computed, nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { computed, nextTick, onBeforeUnmount, ref, shallowRef, watch } from "vue";
+import { DynamicScroller, DynamicScrollerItem } from "vue-virtual-scroller";
+import { createBoundedTextPreview } from "@/lib/common/boundedTextPreview";
+import { countCompareSelection, isCompareRowSelected, setCompareSelection, toggleCompareSelection } from "@/lib/dataGrid/dataCompareSelection";
import { useI18n } from "vue-i18n";
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
@@ -13,7 +16,7 @@ import { useToast } from "@/composables/useToast";
import { databaseOptionsForConnection, fetchNamespaceOptionsForConnection } from "@/composables/useDatabaseOptions";
import { isSchemaAware } from "@/lib/database/databaseCapabilities";
import { copyToClipboard } from "@/lib/common/clipboard";
-import { inferCompareKeyColumns, normalizeKeyColumns, sameKeyColumns, type CompareKeyColumnOption, type DataCompareCellValue, type DataCompareSyncPlan } from "@/lib/dataGrid/dataCompare";
+import { inferCompareKeyColumns, normalizeKeyColumns, sameKeyColumns, type CompareKeyColumnOption, type DataCompareCellValue, type DataCompareRow, type DataCompareModifiedRow, type DataCompareSyncPlan } from "@/lib/dataGrid/dataCompare";
import {
buildDataCompareSyncPlanTables,
emptyDataCompareSyncPlan,
@@ -25,8 +28,6 @@ import {
type DataCompareTableStatus,
type DataCompareTableTask,
type DiffKind,
- type SelectableDataCompareModifiedRow,
- type SelectableDataCompareRow,
} from "@/composables/useDataCompareSession";
import CompareKeyColumnsSelect from "@/components/diff/CompareKeyColumnsSelect.vue";
import DataCompareConfigSelector from "@/components/diff/DataCompareConfigSelector.vue";
@@ -40,6 +41,10 @@ import { ArrowLeftRight, CheckSquare, ChevronDown, ChevronRight, Copy, GitCompar
const PREVIEW_LIMIT_OPTIONS = [50, 100, 200, 500];
const SYNC_EXECUTE_BATCH_SIZE = 500;
+const DIFF_ROW_MIN_HEIGHT = 64;
+const DIFF_LIST_MAX_HEIGHT = 288;
+const SQL_PREVIEW_MAX_CHARACTERS = 8192;
+const SQL_PREVIEW_MAX_LINES = 200;
const { t } = useI18n();
const { toast } = useToast();
@@ -82,8 +87,10 @@ const targetSchemas = ref<string[]>([]);
const targetTables = ref<string[]>([]);
const detailPreviewLimit = ref(String(PREVIEW_LIMIT_OPTIONS[1]));
-const batchResults = ref<DataCompareTableResult[]>([]);
-const syncPlan = ref<DataCompareSyncPlan>(emptyDataCompareSyncPlan());
+const batchResults = shallowRef<DataCompareTableResult[]>([]);
+const syncPlan = shallowRef<DataCompareSyncPlan>(emptyDataCompareSyncPlan());
+const sqlPreview = computed(() => createBoundedTextPreview(syncPlan.value.syncSql, { maxCharacters: SQL_PREVIEW_MAX_CHARACTERS, maxLines: SQL_PREVIEW_MAX_LINES }));
+const sqlPreviewText = computed(() => (sqlPreview.value.truncated ? `${sqlPreview.value.head}\n…\n${sqlPreview.value.tail}` : sqlPreview.value.head));
const comparing = ref(false);
const planningSync = ref(false);
const compareProgressCurrent = ref(0);
@@ -810,7 +817,7 @@ function hasDiffRows(table: DataCompareTableResult, kind: DiffKind): boolean {
}
function selectedRows(table: DataCompareTableResult, kind: DiffKind): number {
- return table.diff[kind].filter((row) => row.selected).length;
+ return countCompareSelection(table.selection[kind], table.diff[kind].length);
}
function rowsForDisplay(table: DataCompareTableResult, kind: DiffKind) {
@@ -833,37 +840,34 @@ function toggleShowAll(table: DataCompareTableResult, kind: DiffKind) {
function setDiffSelection(kind: DiffKind, selected: boolean) {
if (executionLocked.value) return;
batchResults.value.forEach((table) => {
- if (!table.syncEligible) return;
- table.diff[kind].forEach((row) => {
- row.selected = selected;
- });
+ if (table.syncEligible) setCompareSelection(table.selection[kind], selected);
});
rebuildSyncPlan().catch((e) => toast(String(e), 5000));
}
function setTableDiffSelection(table: DataCompareTableResult, kind: DiffKind, selected: boolean) {
if (executionLocked.value || !table.syncEligible) return;
- table.diff[kind].forEach((row) => {
- row.selected = selected;
- });
+ setCompareSelection(table.selection[kind], selected);
rebuildSyncPlan().catch((e) => toast(String(e), 5000));
}
function clearAllSelections() {
if (executionLocked.value) return;
- (["added", "removed", "modified"] as DiffKind[]).forEach((kind) => {
- batchResults.value.forEach((table) => {
- table.diff[kind].forEach((row) => {
- row.selected = false;
- });
- });
+ batchResults.value.forEach((table) => {
+ for (const kind of ["added", "removed", "modified"] as DiffKind[]) setCompareSelection(table.selection[kind], false);
});
rebuildSyncPlan().catch((e) => toast(String(e), 5000));
}
-function toggleRowSelection(table: DataCompareTableResult, row: SelectableDataCompareRow | SelectableDataCompareModifiedRow) {
+// Diff arrays retain their order. A missing target can have duplicate match keys,
+// so both virtual items and selection use row positions instead of SQL keys.
+function diffRowKey(_row: DataCompareRow | DataCompareModifiedRow, index: number): number {
+ return index;
+}
+
+function toggleRowSelection(table: DataCompareTableResult, kind: DiffKind, index: number) {
if (executionLocked.value || !table.syncEligible) return;
- row.selected = !row.selected;
+ toggleCompareSelection(table.selection[kind], index);
rebuildSyncPlan().catch((e) => toast(String(e), 5000));
}
@@ -977,7 +981,9 @@ async function executeSql() {
database,
sql: syncPlan.value.syncSql,
source: t("production.sourceDataCompare"),
+ analyzeInBackground: true,
execute: async () => {
+ if (componentUnmounted || executionInterrupted) return undefined;
syncErrors.value = [];
executeTotal.value = statements.length;
executedCount.value = 0;
@@ -1111,7 +1117,7 @@ function formatRowValues(values: Record<string, DataCompareCellValue>): string {
);
}
-function formatModifiedSummary(row: SelectableDataCompareModifiedRow): string {
+function formatModifiedSummary(row: DataCompareModifiedRow): string {
return truncateText(row.changes.map((change) => `${change.column}: ${formatValue(change.target)} -> ${formatValue(change.source)}`).join(", "), 220);
}
@@ -1643,25 +1649,22 @@ onBeforeUnmount(() => {
</Button>
</div>
- <div class="max-h-72 overflow-auto divide-y">
- <button
- v-for="row in rowsForDisplay(item, kind)"
- :key="`${item.sourceTable}:${kind}:${row.key}`"
- type="button"
- class="flex w-full items-start gap-3 px-3 py-2 text-left text-xs hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-60"
- :disabled="!item.syncEligible"
- @click="toggleRowSelection(item, row)"
- >
- <CheckSquare v-if="row.selected" class="mt-0.5 h-3.5 w-3.5 shrink-0 text-primary" />
- <Square v-else class="mt-0.5 h-3.5 w-3.5 shrink-0 text-muted-foreground/40" />
- <div class="min-w-0 flex-1">
- <div class="font-mono">{{ formatKeyValues(row.keyValues) }}</div>
- <div class="mt-1 text-muted-foreground break-words">
- {{ kind === "modified" ? formatModifiedSummary(row as SelectableDataCompareModifiedRow) : formatRowValues((row as SelectableDataCompareRow).values) }}
- </div>
- </div>
- </button>
- </div>
+ <DynamicScroller :items="rowsForDisplay(item, kind)" :min-item-size="DIFF_ROW_MIN_HEIGHT" :key-field="diffRowKey" class="max-h-72 overflow-auto" :style="{ height: `${Math.min(rowsForDisplay(item, kind).length * DIFF_ROW_MIN_HEIGHT, DIFF_LIST_MAX_HEIGHT)}px` }">
+ <template #default="{ item: row, active, index }">
+ <DynamicScrollerItem :item="row" :index="index" :active="active" :data-index="index">
+ <button type="button" class="flex w-full items-start gap-3 px-3 py-2 text-left text-xs hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-60" :disabled="!item.syncEligible" @click="toggleRowSelection(item, kind, index)">
+ <CheckSquare v-if="isCompareRowSelected(item.selection[kind], index)" class="mt-0.5 h-3.5 w-3.5 shrink-0 text-primary" />
+ <Square v-else class="mt-0.5 h-3.5 w-3.5 shrink-0 text-muted-foreground/40" />
+ <div class="min-w-0 flex-1">
+ <div class="font-mono">{{ formatKeyValues(row.keyValues) }}</div>
+ <div class="mt-1 text-muted-foreground break-words">
+ {{ kind === "modified" ? formatModifiedSummary(row as DataCompareModifiedRow) : formatRowValues((row as DataCompareRow).values) }}
+ </div>
+ </div>
+ </button>
+ </DynamicScrollerItem>
+ </template>
+ </DynamicScroller>
<div v-if="remainingRows(item, kind) > 0 && !item.showAll[kind]" class="border-t px-3 py-2 text-xs text-muted-foreground">
{{ t("dataCompare.remainingRows", { count: remainingRows(item, kind) }) }}
@@ -1675,8 +1678,9 @@ onBeforeUnmount(() => {
{{ t("dataCompare.planningSync") }}
</div>
<div v-else-if="syncPlan.syncSql.trim()" class="space-y-1">
+ <p v-if="sqlPreview.truncated" class="text-xs text-muted-foreground">{{ t("dangerDialog.previewTruncated", { lines: sqlPreview.omittedLines.toLocaleString(), characters: sqlPreview.omittedCharacters.toLocaleString() }) }}</p>
<Label class="text-xs font-medium">{{ t("diff.generatedSql") }}</Label>
- <textarea :value="syncPlan.syncSql" readonly class="w-full h-48 rounded-[6px] border bg-muted/20 p-3 font-mono text-xs resize-none focus:outline-none focus:ring-1 focus:ring-ring" />
+ <textarea :value="sqlPreviewText" readonly class="w-full h-48 rounded-[6px] border bg-muted/20 p-3 font-mono text-xs resize-none focus:outline-none focus:ring-1 focus:ring-ring" />
</div>
<div v-else-if="differentTableCount === 0 && failedTableCount === 0" class="text-sm text-muted-foreground">
{{ t("dataCompare.noDifferences") }}
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 0fd2b2d8a8..b930e6e82d 100644
--- a/apps/desktop/src/components/diff/__tests__/DataCompareDialog.prefill.spec.ts
+++ b/apps/desktop/src/components/diff/__tests__/DataCompareDialog.prefill.spec.ts
@@ -2,12 +2,33 @@
import { createApp, defineComponent, h, nextTick, type App } from "vue";
import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDataCompareSelection, isCompareRowSelected } from "@/lib/dataGrid/dataCompareSelection";
import i18n from "@/i18n";
import DataCompareDialog from "@/components/diff/DataCompareDialog.vue";
import type { DataCompareSession } from "@/composables/useDataCompareSession";
+vi.mock("vue-virtual-scroller", () => ({
+ DynamicScroller: defineComponent({
+ props: ["items"],
+ setup:
+ (props, { slots }) =>
+ () =>
+ h(
+ "div",
+ props.items.map((item: unknown, index: number) => slots.default?.({ item, index, active: true })),
+ ),
+ }),
+ DynamicScrollerItem: defineComponent({
+ setup:
+ (_, { slots }) =>
+ () =>
+ h("div", slots.default?.()),
+ }),
+}));
+
const mocks = vi.hoisted(() => ({
toast: vi.fn(),
+ copyToClipboard: vi.fn().mockResolvedValue(undefined),
ensureConnected: vi.fn().mockResolvedValue(undefined),
listDatabases: vi.fn().mockResolvedValue([]),
listSchemas: vi.fn().mockResolvedValue(["DBX_TEST", "REPORTING", "SYS"]),
@@ -21,6 +42,8 @@ const mocks = vi.hoisted(() => ({
rollbackManualTransaction: vi.fn().mockResolvedValue({}),
}));
+vi.mock("@/lib/common/clipboard", () => ({ copyToClipboard: mocks.copyToClipboard }));
+
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
const sessionMocks = vi.hoisted(() => ({
@@ -132,10 +155,11 @@ function completedSession(): DataCompareSession {
rowBudget: 100_000,
syncEligible: true,
databaseType: "oracle",
+ selection: { added: createDataCompareSelection(true), removed: createDataCompareSelection(true), modified: createDataCompareSelection(true) },
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 },
+ { key: "1", keyValues: { ID: 1 }, values: { ID: 1, NAME: "first" } },
+ { key: "2", keyValues: { ID: 2 }, values: { ID: 2, NAME: "second" } },
],
removed: [],
modified: [],
@@ -483,7 +507,7 @@ describe("DataCompareDialog session restore", () => {
});
await flushAsyncSetup();
- expect(session.batchResults[0]?.diff.added[0]?.selected).toBe(false);
+ expect(isCompareRowSelected(session.batchResults[0]!.selection.added, 0)).toBe(false);
expect(session.syncPlan.syncStatements).toEqual(["INSERT 2"]);
expect(session.syncPlan.syncSql).toBe("INSERT 2;");
});
@@ -536,3 +560,20 @@ describe("DataCompareDialog truncation warning", () => {
expect(document.body.textContent ?? "").not.toContain(i18n.global.t("dataCompare.truncatedTitle"));
});
});
+
+it("bounds the SQL preview while executing the complete plan", async () => {
+ const session = completedSession();
+ const statements = Array.from({ length: 1000 }, (_, index) => `UPDATE orders SET name = '${"x".repeat(32)}' WHERE id = ${index};`);
+ session.syncPlan = { insertCount: 0, updateCount: 1000, deleteCount: 0, statementCount: statements.length, syncStatements: statements, syncSql: statements.join("\n") };
+ mountSessionDialog(session);
+ await flushAsyncSetup();
+ const preview = document.querySelector<HTMLTextAreaElement>("textarea[readonly]")!.value;
+ expect(preview.length).toBeLessThan(9000);
+ expect(preview).toContain("WHERE id = 999;");
+ buttonFor("diff.copySql").click();
+ await vi.waitFor(() => expect(mocks.copyToClipboard).toHaveBeenCalledWith(session.syncPlan.syncSql));
+ mocks.executeBatch.mockResolvedValue(undefined);
+ buttonFor("diff.executeSync").click();
+ await vi.waitFor(() => expect(mocks.executeBatch).toHaveBeenCalledTimes(2));
+ expect(mocks.executeBatch.mock.calls.flatMap((call) => call[2])).toEqual(statements);
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts b/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
index 845fdfe7ad..6dd416157c 100644
--- a/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
@@ -1,3 +1,4 @@
+import { isCompareRowSelected, setCompareSelection, toggleCompareSelection, countCompareSelection } from "@/lib/dataGrid/dataCompareSelection";
import { strict as assert } from "node:assert";
import { beforeEach, test, vi } from "vitest";
import type { ColumnInfo } from "@/types/database";
@@ -108,7 +109,7 @@ test("runs a data compare session independently of the dialog and retains its re
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(isCompareRowSelected(session.batchResults[0]!.selection.added, 0), 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");
@@ -228,6 +229,24 @@ test("keeps the configured per-table match columns after cloning the session con
assert.deepEqual(session.config.keyColumnsByTable, { users: ["user_id", "email"] });
});
+test("selects missing-target rows independently when their chosen match keys are equal", async () => {
+ const rows = [
+ { key: "same", keyValues: { email: "same" }, values: { user_id: 1, email: "same" } },
+ { key: "same", keyValues: { email: "same" }, values: { user_id: 2, email: "same" } },
+ ];
+ apiMock.prepareDataCompareMissingTarget.mockResolvedValue({ ...preparationFor("users"), result: { added: rows, removed: [], modified: [] } });
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users"], targetTable: "users", keyColumnsByTable: { users: ["email"] }, targetTables: [] }), [{ sourceTable: "users", targetTable: "users" }]);
+ const table = session.batchResults[0]!;
+ toggleCompareSelection(table.selection.added, 0);
+ assert.equal(countCompareSelection(table.selection.added, rows.length), 1);
+ assert.equal(isCompareRowSelected(table.selection.added, 0), false);
+ assert.equal(isCompareRowSelected(table.selection.added, 1), true);
+ assert.deepEqual(buildDataCompareSyncPlanTables([table], "public")[0]?.diff.added, [rows[1]]);
+ setCompareSelection(table.selection.added, false);
+ toggleCompareSelection(table.selection.added, 0);
+ assert.deepEqual(buildDataCompareSyncPlanTables([table], "public")[0]?.diff.added, [rows[0]]);
+});
+
test("carries the row budget and truncation flags from the backend into the table result", async () => {
apiMock.prepareDataCompareFromTables.mockImplementation((options: { targetTable: string }) => Promise.resolve({ ...preparationFor(options.targetTable), sourceRowCount: 4_000_000, sourceTruncated: true, targetTruncated: true, rowBudget: 100_000, syncEligible: false }));
@@ -238,7 +257,7 @@ test("carries the row budget and truncation flags from the backend into the tabl
assert.equal(session.batchResults[0]?.targetTruncated, true);
assert.equal(session.batchResults[0]?.syncEligible, false);
assert.equal(buildDataCompareSyncPlanTables(session.batchResults, "public").length, 0);
- assert.equal(session.batchResults[0]?.diff.added[0]?.selected, false);
+ assert.equal(isCompareRowSelected(session.batchResults[0]!.selection.added, 0), false);
});
test("keeps a truncated missing-target table on the same row budget", async () => {
@@ -261,3 +280,34 @@ test("normalizes a per-table match-column map", () => {
assert.deepEqual(normalizeKeyColumnOverrides({ users: [" id ", ""], orders: [], "": ["x"] }), { users: ["id"], orders: [] });
assert.deepEqual(normalizeKeyColumnOverrides(undefined), {});
});
+
+test("keeps selection counts and generated plans consistent without changing diff rows", async () => {
+ apiMock.prepareDataCompareFromTables.mockResolvedValue({
+ ...preparationFor("users"),
+ result: {
+ added: [
+ { key: "1", keyValues: { id: 1 }, values: { id: 1 } },
+ { key: "2", keyValues: { id: 2 }, values: { id: 2 } },
+ ],
+ removed: [],
+ modified: [],
+ },
+ });
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users"], targetTable: "users" }), [{ sourceTable: "users", targetTable: "users" }]);
+ const table = session.batchResults[0]!;
+ const rows = table.diff.added;
+ const keys = () => buildDataCompareSyncPlanTables(session.batchResults, "public")[0]?.diff.added.map((row) => row.key) ?? [];
+ assert.deepEqual(keys(), ["1", "2"]);
+ toggleCompareSelection(table.selection.added, 0);
+ assert.equal(countCompareSelection(table.selection.added, rows.length), 1);
+ assert.deepEqual(keys(), ["2"]);
+ setCompareSelection(table.selection.added, false);
+ assert.deepEqual(keys(), []);
+ toggleCompareSelection(table.selection.added, 0);
+ assert.deepEqual(keys(), ["1"]);
+ setCompareSelection(table.selection.added, true);
+ assert.equal(countCompareSelection(table.selection.added, rows.length), 2);
+ assert.deepEqual(keys(), ["1", "2"]);
+ assert.equal(table.diff.added, rows);
+ assert.deepEqual(rows[0], { key: "1", keyValues: { id: 1 }, values: { id: 1 } });
+});
diff --git a/apps/desktop/src/composables/useDataCompareSession.ts b/apps/desktop/src/composables/useDataCompareSession.ts
index 29247fc84f..84fb1ef125 100644
--- a/apps/desktop/src/composables/useDataCompareSession.ts
+++ b/apps/desktop/src/composables/useDataCompareSession.ts
@@ -1,9 +1,10 @@
-import { reactive, shallowReactive } from "vue";
+import { markRaw, 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, normalizeKeyColumns, type DataCompareCellValue, type DataCompareFromTablesPreparation, type DataCompareResult, type DataCompareSyncPlan, type DataCompareSyncPlanTableOptions } from "@/lib/dataGrid/dataCompare";
+import { inferCompareKeyColumns, intersectCompareColumns, matchColumnNameIgnoreCase, normalizeKeyColumns, type DataCompareFromTablesPreparation, type DataCompareResult, type DataCompareSyncPlan, type DataCompareSyncPlanTableOptions } from "@/lib/dataGrid/dataCompare";
+import { createDataCompareSelection, selectedCompareRows, type DataCompareSelection } from "@/lib/dataGrid/dataCompareSelection";
import type { ColumnInfo, DatabaseType } from "@/types/database";
export type CompareColumn = ColumnInfo;
@@ -23,28 +24,6 @@ export interface DataCompareTableTask {
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;
@@ -64,7 +43,8 @@ export interface DataCompareTableResult {
syncEligible: boolean;
databaseType?: DatabaseType;
preSyncStatements?: string[];
- diff: SelectableDataCompareResult;
+ diff: DataCompareResult;
+ selection: Record<DiffKind, DataCompareSelection>;
expanded: boolean;
showAll: Record<DiffKind, boolean>;
error?: string;
@@ -180,12 +160,17 @@ function compareErrorMessage(dependencies: DataCompareSessionDependencies, kind:
return dependencies.formatError?.(kind, columns) ?? fallbackCompareErrorMessage(kind, columns);
}
-function toSelectableDiff(diff: DataCompareResult, selected: boolean): SelectableDataCompareResult {
- return {
- added: diff.added.map((row) => ({ ...row, selected })),
- removed: diff.removed.map((row) => ({ ...row, selected })),
- modified: diff.modified.map((row) => ({ ...row, selected })),
- };
+function tableResult(result: Omit<DataCompareTableResult, "selection">): DataCompareTableResult {
+ return shallowReactive({
+ ...result,
+ diff: markRaw(result.diff),
+ showAll: reactive(result.showAll),
+ selection: {
+ added: createDataCompareSelection(result.syncEligible),
+ removed: createDataCompareSelection(result.syncEligible),
+ modified: createDataCompareSelection(result.syncEligible),
+ },
+ });
}
export function buildDataCompareSyncPlanTables(results: DataCompareTableResult[], targetSchema: string): DataCompareSyncPlanTableOptions[] {
@@ -198,9 +183,9 @@ export function buildDataCompareSyncPlanTables(results: DataCompareTableResult[]
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),
+ added: selectedCompareRows(table.diff.added, table.selection.added),
+ removed: selectedCompareRows(table.diff.removed, table.selection.removed),
+ modified: selectedCompareRows(table.diff.modified, table.selection.modified),
},
databaseType: table.databaseType,
preSyncStatements: table.preSyncStatements ?? [],
@@ -254,7 +239,7 @@ function buildTableResult(task: DataCompareTableTask, preparation: DataCompareFr
const removed = preparation.result.removed.length;
const modified = preparation.result.modified.length;
const status: DataCompareTableStatus = added || removed || modified ? "different" : "same";
- return {
+ return tableResult({
sourceTable: task.sourceTable,
targetTable: task.targetTable,
keyColumns,
@@ -272,14 +257,14 @@ function buildTableResult(task: DataCompareTableTask, preparation: DataCompareFr
syncEligible: preparation.syncEligible,
databaseType,
preSyncStatements: preparation.preSyncStatements,
- diff: toSelectableDiff(preparation.result, preparation.syncEligible),
+ diff: 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 {
+ return tableResult({
sourceTable: task.sourceTable,
targetTable: task.targetTable,
keyColumns,
@@ -297,14 +282,14 @@ function buildMissingTargetResult(task: DataCompareTableTask, preparation: DataC
syncEligible: preparation.syncEligible,
databaseType,
preSyncStatements: preparation.preSyncStatements,
- diff: toSelectableDiff(preparation.result, preparation.syncEligible),
+ diff: 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 {
+ return tableResult({
sourceTable: task.sourceTable,
targetTable: task.targetTable,
keyColumns,
@@ -326,7 +311,7 @@ function buildErrorResult(task: DataCompareTableTask, keyColumns: string[], data
expanded: false,
showAll: { added: false, removed: false, modified: false },
error: sessionError(error),
- };
+ });
}
/**
diff --git a/apps/desktop/src/lib/dataGrid/dataCompareSelection.ts b/apps/desktop/src/lib/dataGrid/dataCompareSelection.ts
new file mode 100644
index 0000000000..21f4ffe497
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataCompareSelection.ts
@@ -0,0 +1,35 @@
+import { reactive } from "vue";
+
+export interface DataCompareSelection {
+ all: boolean;
+ exceptions: Set<number>;
+}
+
+// Rows are immutable. Only the default selection and its exceptions are reactive,
+// so selecting an entire comparison never mutates thousands of row objects.
+export function createDataCompareSelection(all: boolean): DataCompareSelection {
+ return reactive({ all, exceptions: new Set<number>() });
+}
+
+export function isCompareRowSelected(selection: DataCompareSelection, index: number): boolean {
+ return selection.all !== selection.exceptions.has(index);
+}
+
+export function setCompareSelection(selection: DataCompareSelection, all: boolean): void {
+ selection.all = all;
+ selection.exceptions = new Set();
+}
+
+export function toggleCompareSelection(selection: DataCompareSelection, index: number): void {
+ if (selection.exceptions.has(index)) selection.exceptions.delete(index);
+ else selection.exceptions.add(index);
+}
+
+export function countCompareSelection(selection: DataCompareSelection, total: number): number {
+ return selection.all ? total - selection.exceptions.size : selection.exceptions.size;
+}
+
+export function selectedCompareRows<T>(rows: T[], selection: DataCompareSelection): T[] {
+ if (!selection.exceptions.size) return selection.all ? rows : [];
+ return rows.filter((_, index) => isCompareRowSelected(selection, index));
+}
diff --git a/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts b/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts
index 26c2c24668..e2ffe98734 100644
--- a/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts
+++ b/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts
@@ -241,3 +241,29 @@ describe("production context execution guard (non-SQL)", () => {
expect(useProductionSafetyStore().pending).toBeUndefined();
});
});
+
+describe("background SQL safety for data compare", () => {
+ beforeEach(() => setActivePinia(createPinia()));
+
+ it("retains production confirmation for a large script referencing another database", async () => {
+ const sql = "/*" + "x".repeat(70_000) + "*/ UPDATE prod_app.users SET active = 1 WHERE id = 1";
+ const execute = vi.fn().mockResolvedValue("done");
+ const pending = executeWithProductionSqlGuard({ connection: connection(), database: "scratch", sql, analyzeInBackground: true, execute });
+ await vi.waitFor(() => expect(useProductionSafetyStore().pending?.sql).toBe(sql));
+ expect(execute).not.toHaveBeenCalled();
+ useProductionSafetyStore().cancel();
+ await expect(pending).resolves.toBeUndefined();
+ expect(execute).not.toHaveBeenCalled();
+ });
+
+ it("retains read-only unlocking for a large generated script", async () => {
+ const sql = "/*" + "x".repeat(70_000) + "*/ UPDATE users SET active = 1 WHERE id = 1";
+ const execute = vi.fn();
+ const pending = executeWithProductionSqlGuard({ connection: connection({ read_only: true }), database: "scratch", sql, analyzeInBackground: true, execute });
+ await vi.waitFor(() => expect(useReadOnlyUnlockStore().pending?.connectionId).toBe("conn-1"));
+ expect(execute).not.toHaveBeenCalled();
+ useReadOnlyUnlockStore().cancel();
+ await expect(pending).resolves.toBeUndefined();
+ expect(execute).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/lib/database/__tests__/productionSafetyWorker.spec.ts b/apps/desktop/src/lib/database/__tests__/productionSafetyWorker.spec.ts
new file mode 100644
index 0000000000..024b64b312
--- /dev/null
+++ b/apps/desktop/src/lib/database/__tests__/productionSafetyWorker.spec.ts
@@ -0,0 +1,76 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { reactive } from "vue";
+import { assessProductionSqlInBackground, type ProductionSafetyRequest } from "../productionSafetyWorker";
+import { assessProductionSql } from "../productionSafety";
+
+class TestWorker {
+ static instances: TestWorker[] = [];
+ onmessage?: (event: { data: unknown }) => void;
+ onerror?: () => void;
+ onmessageerror?: () => void;
+ terminate = vi.fn();
+ request?: { id: number; input: ProductionSafetyRequest };
+ constructor() {
+ TestWorker.instances.push(this);
+ }
+ postMessage(request: { id: number; input: ProductionSafetyRequest }) {
+ // Also catches accidentally passing a Vue connection proxy to the worker.
+ this.request = structuredClone(request);
+ }
+ respond() {
+ const { id, input } = this.request!;
+ this.onmessage?.({ data: { id, result: assessProductionSql(input.sql, input.connection, input.database) } });
+ }
+}
+
+afterEach(() => {
+ TestWorker.instances = [];
+ vi.unstubAllGlobals();
+ vi.useRealTimers();
+});
+
+it("assesses qualified production targets without sending connection secrets", async () => {
+ vi.stubGlobal("Worker", TestWorker);
+ const pending = assessProductionSqlInBackground({
+ sql: "UPDATE prod_app.users SET active = 1 WHERE id = 1",
+ database: "scratch",
+ connection: reactive({ db_type: "mysql" as const, production_databases: ["prod_app"], password: "not-for-worker" }),
+ });
+ const worker = TestWorker.instances[0]!;
+ expect(worker.request?.input.connection).toEqual({ db_type: "mysql", is_production: undefined, production_databases: ["prod_app"] });
+ worker.respond();
+ await expect(pending).resolves.toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+ expect(worker.terminate).toHaveBeenCalledOnce();
+});
+
+it("preserves safety checks if the worker cannot start", async () => {
+ vi.stubGlobal(
+ "Worker",
+ class {
+ constructor() {
+ throw new Error("workers unavailable");
+ }
+ },
+ );
+ await expect(assessProductionSqlInBackground({ sql: "DELETE FROM users", database: "prod", connection: { db_type: "mysql", production_databases: ["prod"] } })).resolves.toMatchObject({ active: true, isMutation: true });
+});
+
+it("does not cancel a concurrent assessment", async () => {
+ vi.stubGlobal("Worker", TestWorker);
+ const first = assessProductionSqlInBackground({ sql: "SELECT 1" });
+ const second = assessProductionSqlInBackground({ sql: "DELETE FROM users" });
+ TestWorker.instances[1]!.respond();
+ TestWorker.instances[0]!.respond();
+ await expect(first).resolves.toMatchObject({ isMutation: false });
+ await expect(second).resolves.toMatchObject({ isMutation: true });
+});
+
+it("rejects a stalled analysis and releases the worker", async () => {
+ vi.useFakeTimers();
+ vi.stubGlobal("Worker", TestWorker);
+ const pending = assessProductionSqlInBackground({ sql: "DELETE FROM users" });
+ const assertion = expect(pending).rejects.toThrow("SQL safety analysis timed out");
+ await vi.advanceTimersByTimeAsync(30_000);
+ await assertion;
+ expect(TestWorker.instances[0]!.terminate).toHaveBeenCalledOnce();
+});
diff --git a/apps/desktop/src/lib/database/productionExecutionGuard.ts b/apps/desktop/src/lib/database/productionExecutionGuard.ts
index dfd31282ea..5c225a2bb3 100644
--- a/apps/desktop/src/lib/database/productionExecutionGuard.ts
+++ b/apps/desktop/src/lib/database/productionExecutionGuard.ts
@@ -1,6 +1,7 @@
import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
import { assessProductionSql, productionContextForDatabase, productionDatabases } from "@/lib/database/productionSafety";
import { ensureReadOnlyWriteAccess } from "@/lib/database/readOnlyWriteAccess";
+import { assessProductionSqlInBackground } from "./productionSafetyWorker";
import type { ConnectionConfig } from "@/types/database";
export interface ProductionSqlExecutionGuardOptions<T> {
@@ -9,13 +10,16 @@ export interface ProductionSqlExecutionGuardOptions<T> {
sql: string;
source?: string;
execute: () => Promise<T>;
+ /** Offload large generated scripts while preserving the same safety assessment. */
+ analyzeInBackground?: boolean;
}
export async function executeWithProductionSqlGuard<T>(options: ProductionSqlExecutionGuardOptions<T>): Promise<T | undefined> {
- if (!(await ensureReadOnlyWriteAccess({ connection: options.connection, sql: options.sql, source: options.source }))) {
+ const backgroundAssessment = options.analyzeInBackground && options.sql.length > 64 * 1024 ? await assessProductionSqlInBackground({ sql: options.sql, connection: options.connection, database: options.database }) : undefined;
+ if (!(await ensureReadOnlyWriteAccess({ connection: options.connection, sql: options.sql, source: options.source, treatAsMutation: backgroundAssessment?.isMutation }))) {
return undefined;
}
- const assessment = assessProductionSql(options.sql, options.connection, options.database);
+ const assessment = backgroundAssessment ?? assessProductionSql(options.sql, options.connection, options.database);
if (assessment.active && assessment.isMutation) {
// Centralize production write confirmation so secondary tool surfaces cannot
// bypass the same explicit review step used by the SQL editor.
diff --git a/apps/desktop/src/lib/database/productionSafety.ts b/apps/desktop/src/lib/database/productionSafety.ts
index ef1f51285a..1c1dc9f773 100644
--- a/apps/desktop/src/lib/database/productionSafety.ts
+++ b/apps/desktop/src/lib/database/productionSafety.ts
@@ -2,6 +2,8 @@ import type { ConnectionConfig, DatabaseType } from "@/types/database";
import { nacosNamespaceIdentity } from "@/lib/nacos/nacosNamespaceVisibility";
import { classifySqlRisk, endsWithEscapeStringPrefix, isSqlRiskMutation, readOracleAlternativeQuoteEnd, usesMysqlLexerRules, usesOracleAlternativeQuotes, usesPostgresEscapeStrings } from "@/lib/sql/sqlRisk";
+export type ProductionConnection = Pick<ConnectionConfig, "db_type" | "is_production" | "production_databases">;
+
export type ProductionContextReason = "connection" | "database" | "sql_target";
export interface ProductionContext {
@@ -94,7 +96,7 @@ export function normalizeProductionDatabase(value: string | undefined | null): s
.toLowerCase();
}
-export function productionDatabases(connection: ConnectionConfig | undefined): string[] {
+export function productionDatabases(connection: ProductionConnection | undefined): string[] {
if (!connection?.production_databases?.length) return [];
if (connection.db_type === "nacos") {
return [...new Set(connection.production_databases.map(nacosNamespaceIdentity))];
@@ -102,7 +104,7 @@ export function productionDatabases(connection: ConnectionConfig | undefined): s
return [...new Set(connection.production_databases.map(normalizeProductionDatabase).filter(Boolean))];
}
-export function productionContextForDatabase(connection: ConnectionConfig | undefined, database: string | undefined | null): ProductionContext {
+export function productionContextForDatabase(connection: ProductionConnection | undefined, database: string | undefined | null): ProductionContext {
if (!connection) return { active: false, databases: [] };
if (connection.is_production) return { active: true, reason: "connection", databases: [] };
@@ -123,7 +125,7 @@ export function isProductionMutation(sql: string): boolean {
* authoritative for ordinary statements; MySQL-style USE and qualified names
* additionally protect production databases referenced from another context.
*/
-export function assessProductionSql(sql: string, connection: ConnectionConfig | undefined, activeDatabase: string | undefined | null): ProductionSqlAssessment {
+export function assessProductionSql(sql: string, connection: ProductionConnection | undefined, activeDatabase: string | undefined | null): ProductionSqlAssessment {
const activeContext = productionContextForDatabase(connection, activeDatabase);
const targetText = sqlTargetSafetyText(sql, connection?.db_type);
const statements = splitTargetStatements(targetText.text);
diff --git a/apps/desktop/src/lib/database/productionSafety.worker.ts b/apps/desktop/src/lib/database/productionSafety.worker.ts
new file mode 100644
index 0000000000..eaeb168a42
--- /dev/null
+++ b/apps/desktop/src/lib/database/productionSafety.worker.ts
@@ -0,0 +1,11 @@
+import { assessProductionSql } from "./productionSafety";
+import type { ProductionSafetyRequest } from "./productionSafetyWorker";
+
+self.onmessage = (event: MessageEvent<{ id: number; input: ProductionSafetyRequest }>) => {
+ const { id, input } = event.data;
+ try {
+ self.postMessage({ id, result: assessProductionSql(input.sql, input.connection, input.database) });
+ } catch (error) {
+ self.postMessage({ id, error: error instanceof Error ? error.message : String(error) });
+ }
+};
diff --git a/apps/desktop/src/lib/database/productionSafetyWorker.ts b/apps/desktop/src/lib/database/productionSafetyWorker.ts
new file mode 100644
index 0000000000..bee633e86e
--- /dev/null
+++ b/apps/desktop/src/lib/database/productionSafetyWorker.ts
@@ -0,0 +1,36 @@
+import { createSqlAnalysisWorker } from "@/lib/sql/sqlAnalysisWorker";
+import { assessProductionSql, type ProductionConnection, type ProductionSqlAssessment } from "./productionSafety";
+
+export interface ProductionSafetyRequest {
+ sql: string;
+ connection?: ProductionConnection;
+ database?: string | null;
+}
+
+export async function assessProductionSqlInBackground(input: ProductionSafetyRequest): Promise<ProductionSqlAssessment> {
+ const analyzer = createSqlAnalysisWorker<ProductionSafetyRequest, ProductionSqlAssessment>(
+ () => new Worker(new URL("./productionSafety.worker.ts", import.meta.url), { type: "module" }),
+ ({ sql, connection, database }) => assessProductionSql(sql, connection, database),
+ );
+ let timeout: ReturnType<typeof setTimeout> | undefined;
+ try {
+ // Project the connection explicitly: Vue proxies are not cloneable, and SQL
+ // analysis needs neither credentials nor the rest of the connection config.
+ const connection = input.connection;
+ const result = await Promise.race([
+ analyzer.analyze({
+ sql: input.sql,
+ database: input.database,
+ connection: connection ? { db_type: connection.db_type, is_production: connection.is_production, production_databases: connection.production_databases ? [...connection.production_databases] : undefined } : undefined,
+ }),
+ new Promise<never>((_, reject) => {
+ timeout = setTimeout(() => reject(new Error("SQL safety analysis timed out")), 30_000);
+ }),
+ ]);
+ if (!result) throw new Error("SQL safety analysis failed");
+ return result;
+ } finally {
+ clearTimeout(timeout);
+ analyzer.dispose();
+ }
+}