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(data-compare): support per-table match column configuration

jearhed10216e302e6
diff --git a/apps/desktop/src/components/diff/CompareKeyColumnsSelect.vue b/apps/desktop/src/components/diff/CompareKeyColumnsSelect.vue
new file mode 100644
index 0000000000..78cafb7140
--- /dev/null
+++ b/apps/desktop/src/components/diff/CompareKeyColumnsSelect.vue
@@ -0,0 +1,186 @@
+<script setup lang="ts">
+import { computed, nextTick, ref, watch } from "vue";
+import type { HTMLAttributes } from "vue";
+import { CheckSquare, ChevronDown, Search, Square } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { filterDatabaseOptions } from "@/lib/database/databaseOptionSearch";
+import { cn } from "@/lib/common/utils";
+import type { CompareKeyColumnOption } from "@/lib/dataGrid/dataCompare";
+
+/**
+ * Searchable multi-select for database table columns, used to configure the
+ * match columns (key columns) of one Data Compare task.
+ *
+ * It is deliberately read-only over the column metadata it receives: options
+ * come from `getColumns`, so a user can only pick columns that really exist on
+ * the table. Primary keys are labelled instead of pre-filtered, because a
+ * composite unique key is a legitimate explicit choice.
+ */
+const props = withDefaults(
+ defineProps<{
+ /** Currently selected column names. */
+ modelValue: string[];
+ /** All columns of the table, in table order. */
+ columns: CompareKeyColumnOption[];
+ disabled?: boolean;
+ /** Column metadata is still being fetched for this table. */
+ loading?: boolean;
+ /** Shown on the trigger when nothing is selected. */
+ placeholder?: string;
+ searchPlaceholder?: string;
+ emptyText?: string;
+ /** Extra classes for the popover content, mirroring SearchableSelect. */
+ contentClass?: HTMLAttributes["class"];
+ }>(),
+ {
+ disabled: false,
+ loading: false,
+ placeholder: "",
+ searchPlaceholder: "",
+ emptyText: "",
+ },
+);
+
+const emit = defineEmits<{ "update:modelValue": [value: string[]] }>();
+
+const { t } = useI18n();
+const open = ref(false);
+const searchText = ref("");
+const searchInput = ref<InstanceType<typeof Input>>();
+
+const selectedSet = computed(() => new Set(props.modelValue.map((column) => column.toLowerCase())));
+const columnNames = computed(() => props.columns.map((column) => column.name));
+const filteredColumns = computed(() => {
+ const allowed = new Set(filterDatabaseOptions(columnNames.value, searchText.value));
+ return props.columns.filter((column) => allowed.has(column.name));
+});
+const selectedLabel = computed(() => props.modelValue.join(", "));
+const selectedCountLabel = computed(() => t("dataCompare.keyColumnsSelectedCount", { selected: props.modelValue.length, total: props.columns.length }));
+
+function isSelected(column: CompareKeyColumnOption): boolean {
+ return selectedSet.value.has(column.name.toLowerCase());
+}
+
+function toggleColumn(column: CompareKeyColumnOption): void {
+ if (props.disabled) return;
+ const next = isSelected(column)
+ ? props.modelValue.filter((name) => name.toLowerCase() !== column.name.toLowerCase())
+ : // Append in click order so a composite key keeps the order the user picked.
+ [...props.modelValue, column.name];
+ emit("update:modelValue", next);
+}
+
+watch(open, async (value) => {
+ if (!value) {
+ searchText.value = "";
+ return;
+ }
+ await nextTick();
+ const input = searchInput.value?.$el as HTMLInputElement | undefined;
+ input?.focus();
+});
+</script>
+
+<template>
+ <Popover v-model:open="open">
+ <PopoverTrigger as-child>
+ <Button
+ type="button"
+ variant="outline"
+ :disabled="disabled"
+ :title="selectedLabel || placeholder"
+ :class="
+ cn(
+ 'dbx-compare-key-columns-trigger dbx-control-chrome h-8 w-full min-w-0 justify-between gap-1.5 rounded-md border border-input bg-transparent px-2.5 text-xs font-normal shadow-none hover:bg-muted/40 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 dark:bg-input/30 dark:hover:bg-input/50',
+ )
+ "
+ >
+ <span v-if="loading" class="truncate text-muted-foreground">{{ t("dataCompare.keyColumnsLoading") }}</span>
+ <span v-else-if="selectedLabel" class="truncate font-mono">{{ selectedLabel }}</span>
+ <span v-else class="truncate text-muted-foreground">{{ placeholder || t("dataCompare.keyColumnsSelectPlaceholder") }}</span>
+ <ChevronDown class="h-3.5 w-3.5 shrink-0 opacity-60" />
+ </Button>
+ </PopoverTrigger>
+ <PopoverContent align="start" :class="cn('w-[var(--reka-popover-trigger-width)] min-w-56 max-w-[min(30rem,calc(100vw-1rem))] border-0 bg-transparent p-0 shadow-none ring-0', contentClass)">
+ <div class="rounded-md border bg-popover p-1.5 shadow-md">
+ <div class="relative rounded-md border bg-background">
+ <Search class="pointer-events-none absolute left-2 top-1/2 h-3 w-3 -translate-y-1/2 text-muted-foreground" />
+ <span v-if="!searchText" class="pointer-events-none absolute left-[25px] top-1/2 -translate-y-1/2 text-xs text-muted-foreground">
+ {{ searchPlaceholder || t("dataCompare.keyColumnsSearch") }}
+ </span>
+ <Input ref="searchInput" :model-value="searchText" class="h-6 border-0 pl-6 pr-2 text-xs caret-foreground shadow-none focus-visible:ring-0" @update:model-value="(value) => (searchText = String(value))" @keydown.escape="open = false" />
+ </div>
+ <div class="dbx-compare-key-columns-list max-h-64 overflow-y-auto py-1">
+ <div v-if="loading" class="px-2 py-2 text-xs text-muted-foreground">{{ t("dataCompare.keyColumnsLoading") }}</div>
+ <template v-else-if="filteredColumns.length">
+ <button
+ v-for="column in filteredColumns"
+ :key="column.name"
+ type="button"
+ :data-column-name="column.name"
+ :data-primary-key="column.is_primary_key ? 'true' : 'false'"
+ :disabled="disabled"
+ class="flex h-7 w-full min-w-0 items-center gap-2 rounded-md px-2 text-left text-xs hover:bg-accent hover:text-accent-foreground disabled:cursor-not-allowed disabled:opacity-50"
+ @click="toggleColumn(column)"
+ >
+ <CheckSquare v-if="isSelected(column)" class="h-3.5 w-3.5 shrink-0 text-primary" />
+ <Square v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground/40" />
+ <span class="min-w-0 flex-1 truncate font-mono">{{ column.name }}</span>
+ <span v-if="column.is_primary_key" class="shrink-0 rounded bg-amber-500/15 px-1 text-[10px] font-medium text-amber-700 dark:text-amber-400">
+ {{ t("dataCompare.keyColumnsPrimaryKeyBadge") }}
+ </span>
+ </button>
+ </template>
+ <div v-else class="px-2 py-2 text-xs text-muted-foreground">
+ {{ emptyText || t("dataCompare.keyColumnsEmpty") }}
+ </div>
+ </div>
+ <div class="border-t px-2 pt-1.5 text-[11px] text-muted-foreground">{{ selectedCountLabel }}</div>
+ </div>
+ </PopoverContent>
+ </Popover>
+</template>
+
+<style>
+.dbx-compare-key-columns-list {
+ scrollbar-width: thin;
+ scrollbar-color: color-mix(in oklch, var(--foreground) 30%, transparent) transparent;
+}
+
+.dbx-compare-key-columns-list::-webkit-scrollbar {
+ width: 6px;
+ height: 6px;
+}
+
+.dbx-compare-key-columns-list::-webkit-scrollbar-track {
+ background: transparent;
+}
+
+.dbx-compare-key-columns-list::-webkit-scrollbar-thumb {
+ border: 1px solid transparent;
+ border-radius: 999px;
+ background: color-mix(in oklch, var(--foreground) 30%, transparent);
+ background-clip: padding-box;
+}
+
+.dbx-compare-key-columns-list:hover::-webkit-scrollbar-thumb {
+ border: 0;
+ background: color-mix(in oklch, var(--foreground) 48%, transparent);
+}
+
+.dark .dbx-compare-key-columns-list {
+ scrollbar-color: rgb(82, 82, 91) transparent;
+}
+
+.dark .dbx-compare-key-columns-list::-webkit-scrollbar-thumb {
+ background: rgb(82, 82, 91);
+ background-clip: padding-box;
+}
+
+.dark .dbx-compare-key-columns-list:hover::-webkit-scrollbar-thumb {
+ background: rgb(113, 113, 122);
+}
+</style>
diff --git a/apps/desktop/src/components/diff/DataCompareDialog.vue b/apps/desktop/src/components/diff/DataCompareDialog.vue
index d4ee57133a..21344d527c 100644
--- a/apps/desktop/src/components/diff/DataCompareDialog.vue
+++ b/apps/desktop/src/components/diff/DataCompareDialog.vue
@@ -3,7 +3,6 @@ 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";
-import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
import SearchableSelect from "@/components/ui/searchable-select/SearchableSelect.vue";
@@ -13,14 +12,13 @@ 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, DataCompareSyncPlan } from "@/lib/dataGrid/dataCompare";
-import { inferCompareKeyColumns } from "@/lib/dataGrid/dataCompare";
+import { inferCompareKeyColumns, normalizeKeyColumns, sameKeyColumns, type CompareKeyColumnOption, type DataCompareCellValue, type DataCompareSyncPlan } from "@/lib/dataGrid/dataCompare";
import {
buildDataCompareSyncPlanTables,
emptyDataCompareSyncPlan,
getDataCompareSession,
+ normalizeKeyColumnOverrides,
startDataCompareSession,
- type CompareColumn,
type DataCompareSession,
type DataCompareTableResult,
type DataCompareTableStatus,
@@ -29,6 +27,7 @@ import {
type SelectableDataCompareModifiedRow,
type SelectableDataCompareRow,
} from "@/composables/useDataCompareSession";
+import CompareKeyColumnsSelect from "@/components/diff/CompareKeyColumnsSelect.vue";
import * as api from "@/lib/backend/api";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import TableMultiSelect from "@/components/diff/TableMultiSelect.vue";
@@ -67,7 +66,6 @@ const targetDatabases = ref<string[]>([]);
const targetSchemas = ref<string[]>([]);
const targetTables = ref<string[]>([]);
-const keyColumnsText = ref("");
const detailPreviewLimit = ref(String(PREVIEW_LIMIT_OPTIONS[1]));
const batchResults = ref<DataCompareTableResult[]>([]);
const syncPlan = ref<DataCompareSyncPlan>(emptyDataCompareSyncPlan());
@@ -84,6 +82,21 @@ const showAdded = ref(true);
const showRemoved = ref(true);
const showModified = ref(true);
+/**
+ * Explicit match columns per source table. An absent entry means "auto": the
+ * primary key of that table is inferred, so a batch compare never shares one
+ * global key column list across different tables.
+ */
+const keyColumnOverrides = ref<Record<string, string[]>>({});
+/** Column metadata per source table, keyed by table name; cleared with the source endpoint. */
+const tableColumns = ref<Record<string, CompareKeyColumnOption[]>>({});
+const tableColumnErrors = ref<Record<string, string>>({});
+const loadingColumnTables = ref<string[]>([]);
+const expandedKeyColumnTable = ref("");
+let columnRequests = new Map<string, Promise<CompareKeyColumnOption[]>>();
+/** Invalidates in-flight metadata responses after a source endpoint change. */
+let columnMetadataGeneration = 0;
+
const activeSessionId = ref<string | null>(props.sessionId ?? null);
let syncPlanRequestId = 0;
let initializingPrefill = false;
@@ -112,13 +125,52 @@ const compareTasksPreview = computed(() =>
);
const matchedTaskCount = computed(() => compareTasksPreview.value.filter((task) => task.matched).length);
const missingTargetTables = computed(() => compareTasksPreview.value.filter((task) => !task.matched).map((task) => task.targetTable || task.sourceTable));
-const canCompare = computed(() => sourceConnectionId.value && sourceDatabase.value && sourceSchema.value && selectedSourceTableNames.value.length > 0 && targetConnectionId.value && targetDatabase.value && targetSchema.value);
-const keyColumns = computed(() =>
- keyColumnsText.value
- .split(",")
- .map((value) => value.trim())
- .filter(Boolean),
+
+interface KeyColumnRow {
+ table: string;
+ matched: boolean;
+ manual: boolean;
+ columns: string[];
+ loading: boolean;
+ hint: string;
+ /** Set when the column metadata of this table could not be loaded. */
+ error?: string;
+ /** `missing` means neither a primary key nor a manual selection is available yet. */
+ status: "auto" | "manual" | "missing";
+}
+
+const keyColumnRows = computed<KeyColumnRow[]>(() =>
+ selectedSourceTableNames.value.map((table) => {
+ const matched = !!compareTasksPreview.value.find((task) => task.sourceTable === table)?.matched;
+ const manual = hasKeyColumnOverride(table);
+ const columns = effectiveKeyColumns(table);
+ const error = tableColumnErrors.value[table];
+ return {
+ table,
+ matched,
+ manual,
+ columns,
+ loading: isTableColumnsLoading(table),
+ hint: error || keyColumnHint(table, { matched, manual, columns }),
+ error,
+ status: manual ? "manual" : columns.length > 0 ? "auto" : "missing",
+ };
+ }),
);
+const singleKeyColumnRow = computed(() => (selectedSourceTableNames.value.length === 1 ? keyColumnRows.value[0] : undefined));
+/**
+ * A single-table compare whose target table exists but whose match columns are
+ * unknown: primary key inference found nothing and the user has not picked
+ * columns yet. Blocking here is safe because no other table depends on it.
+ * Unloaded metadata is deliberately not treated as "no primary key".
+ */
+const singleTableNeedsKeyColumns = computed(() => {
+ const row = singleKeyColumnRow.value;
+ if (!row || !row.matched) return false;
+ if (!isTableColumnsKnown(row.table)) return false;
+ return row.columns.length === 0;
+});
+const canCompare = computed(() => sourceConnectionId.value && sourceDatabase.value && sourceSchema.value && selectedSourceTableNames.value.length > 0 && targetConnectionId.value && targetDatabase.value && targetSchema.value && !singleTableNeedsKeyColumns.value);
const detailPreviewLimitNumber = computed(() => Number(detailPreviewLimit.value) || PREVIEW_LIMIT_OPTIONS[1]);
const sameTableCount = computed(() => batchResults.value.filter((item) => item.status === "same").length);
@@ -172,6 +224,157 @@ function resetSelectedSourceTables(nextTables: Iterable<string>) {
selectedSourceTables.value = new Set(nextTables);
}
+// --- Match columns (key columns) -------------------------------------------------
+//
+// Every selected source table owns its match columns: the primary key is the
+// default, and a manual picker selection is stored as a per-table override in
+// `keyColumnOverrides`. The session receives the same per-table shape, so a
+// batch compare is never forced to share one global key column list.
+
+function resetTableColumnMetadata() {
+ columnMetadataGeneration += 1;
+ columnRequests = new Map();
+ tableColumns.value = {};
+ tableColumnErrors.value = {};
+ loadingColumnTables.value = [];
+ expandedKeyColumnTable.value = "";
+}
+
+function columnsForTable(table: string): CompareKeyColumnOption[] {
+ return tableColumns.value[table] ?? [];
+}
+
+function isTableColumnsKnown(table: string): boolean {
+ return tableColumns.value[table] !== undefined;
+}
+
+function isTableColumnsLoading(table: string): boolean {
+ return loadingColumnTables.value.includes(table);
+}
+
+function hasKeyColumnOverride(table: string): boolean {
+ return keyColumnOverrides.value[table] !== undefined;
+}
+
+function inferredKeyColumns(table: string): string[] {
+ return inferCompareKeyColumns(columnsForTable(table));
+}
+
+/** Effective match columns of a table: the manual override, otherwise the inferred primary key. */
+function effectiveKeyColumns(table: string): string[] {
+ const override = keyColumnOverrides.value[table];
+ return override === undefined ? inferredKeyColumns(table) : override;
+}
+
+async function fetchTableColumns(table: string): Promise<CompareKeyColumnOption[]> {
+ const connectionId = sourceConnectionId.value;
+ const database = sourceDatabase.value;
+ const schema = sourceSchema.value;
+ if (!connectionId || !database || !schema || !table) return [];
+ const generation = columnMetadataGeneration;
+ loadingColumnTables.value = [...loadingColumnTables.value, table];
+ try {
+ const columns = (await api.getColumns(connectionId, database, schema, table)) as CompareKeyColumnOption[];
+ if (generation !== columnMetadataGeneration) return [];
+ tableColumns.value = { ...tableColumns.value, [table]: columns };
+ delete tableColumnErrors.value[table];
+ return columns;
+ } catch (error: any) {
+ if (generation === columnMetadataGeneration) tableColumnErrors.value = { ...tableColumnErrors.value, [table]: error?.message || String(error) };
+ return [];
+ } finally {
+ if (generation === columnMetadataGeneration) loadingColumnTables.value = loadingColumnTables.value.filter((item) => item !== table);
+ }
+}
+
+function loadTableColumns(table: string): Promise<CompareKeyColumnOption[]> {
+ const cached = tableColumns.value[table];
+ if (cached) return Promise.resolve(cached);
+ const pending = columnRequests.get(table);
+ if (pending) return pending;
+ const request = fetchTableColumns(table).finally(() => columnRequests.delete(table));
+ columnRequests.set(table, request);
+ return request;
+}
+
+/** Loads metadata for the selected tables with bounded concurrency, so a wide selection cannot flood the backend. */
+async function prefetchSelectedTableColumns(tables: string[]): Promise<void> {
+ const pending = tables.filter((table) => !tableColumns.value[table]);
+ if (pending.length === 0) return;
+ let cursor = 0;
+ const workers = Array.from({ length: Math.min(4, pending.length) }, async () => {
+ while (cursor < pending.length) await loadTableColumns(pending[cursor++]);
+ });
+ await Promise.all(workers);
+}
+
+function setTableKeyColumns(table: string, columns: string[]) {
+ const normalized = normalizeKeyColumns(columns);
+ const next = { ...keyColumnOverrides.value };
+ if (sameKeyColumns(normalized, inferredKeyColumns(table))) delete next[table];
+ else next[table] = normalized;
+ keyColumnOverrides.value = next;
+}
+
+function clearTableKeyColumnsOverride(table: string) {
+ if (keyColumnOverrides.value[table] === undefined) return;
+ const next = { ...keyColumnOverrides.value };
+ delete next[table];
+ keyColumnOverrides.value = next;
+}
+
+/** Drops overrides and metadata of tables that are no longer selected. */
+function pruneKeyColumnState(tables: string[]) {
+ const keep = new Set(tables);
+ const nextOverrides: Record<string, string[]> = {};
+ let overridesChanged = false;
+ for (const [table, columns] of Object.entries(keyColumnOverrides.value)) {
+ if (keep.has(table)) nextOverrides[table] = columns;
+ else overridesChanged = true;
+ }
+ if (overridesChanged) keyColumnOverrides.value = nextOverrides;
+
+ const nextColumns: Record<string, CompareKeyColumnOption[]> = {};
+ const nextErrors: Record<string, string> = {};
+ let columnsChanged = false;
+ for (const [table, columns] of Object.entries(tableColumns.value)) {
+ if (keep.has(table)) {
+ nextColumns[table] = columns;
+ if (tableColumnErrors.value[table]) nextErrors[table] = tableColumnErrors.value[table];
+ } else {
+ columnsChanged = true;
+ }
+ }
+ if (columnsChanged) {
+ tableColumns.value = nextColumns;
+ tableColumnErrors.value = nextErrors;
+ }
+ if (expandedKeyColumnTable.value && !keep.has(expandedKeyColumnTable.value)) expandedKeyColumnTable.value = "";
+}
+
+function toggleKeyColumnTable(table: string) {
+ expandedKeyColumnTable.value = expandedKeyColumnTable.value === table ? "" : table;
+ if (expandedKeyColumnTable.value) void loadTableColumns(table);
+}
+
+function keyColumnHint(table: string, state: { matched: boolean; manual: boolean; columns: string[] }): string {
+ if (!state.matched) return t("dataCompare.keyColumnsTargetMissingHint");
+ if (state.manual) return t("dataCompare.keyColumnsManualHint", { columns: state.columns.length > 0 ? state.columns.join(", ") : t("dataCompare.keyColumnsNoneSelected") });
+ if (state.columns.length > 0) return t("dataCompare.keyColumnsAutoSummary", { columns: state.columns.join(", ") });
+ if (!isTableColumnsKnown(table)) return t("dataCompare.keyColumnsStatusAuto");
+ return t("dataCompare.keyColumnsNoPrimaryKey");
+}
+
+/** Only the selected tables are sent, so a deselected table can never leak a stale override. */
+function buildSessionKeyColumnsByTable(): Record<string, string[]> {
+ const overrides: Record<string, string[]> = {};
+ for (const table of selectedSourceTableNames.value) {
+ const override = keyColumnOverrides.value[table];
+ if (override !== undefined) overrides[table] = [...override];
+ }
+ return overrides;
+}
+
function buildCompareTasks(): DataCompareTableTask[] {
if (!selectedSourceTableNames.value.length) return [];
if (!isBatchCompare.value) {
@@ -222,7 +425,10 @@ async function restoreDataCompareSession(session: DataCompareSession): Promise<v
targetSchemas.value = [...config.targetSchemas];
targetTables.value = [...config.targetTables];
targetTable.value = config.targetTable;
- keyColumnsText.value = config.keyColumns.join(", ");
+ // Restore the per-table match columns so a reopened session keeps every
+ // table's own selection instead of collapsing back to one global list.
+ keyColumnOverrides.value = normalizeKeyColumnOverrides(config.keyColumnsByTable);
+ resetTableColumnMetadata();
batchResults.value = session.batchResults;
syncPlan.value = session.syncPlan;
syncErrors.value = [];
@@ -230,6 +436,7 @@ async function restoreDataCompareSession(session: DataCompareSession): Promise<v
compareProgressTotal.value = session.progress?.total ?? 0;
compareProgressTable.value = session.progress?.table ?? "";
comparing.value = session.status === "running";
+ void prefetchSelectedTableColumns(selectedSourceTableNames.value);
} finally {
await nextTick();
if (generation === initializingPrefillGeneration) initializingPrefill = false;
@@ -377,28 +584,6 @@ async function loadTables(side: "source" | "target") {
}
}
-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(table: string, sourceColumnCache?: Map<string, CompareColumn[]>): Promise<string[]> {
- if (!sourceConnectionId.value || !sourceDatabase.value || !sourceSchema.value || !table) return [];
- const columns = sourceColumnCache ? await loadColumnsWithCache(sourceColumnCache, sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, table) : (((await api.getColumns(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, table)) as CompareColumn[]) ?? []);
- return inferCompareKeyColumns(columns);
-}
-
-async function inferKeyColumns() {
- const table = selectedSourceTableNames.value.length === 1 ? selectedSourceTableNames.value[0] : "";
- if (!table) return;
- const inferred = await inferKeyColumnsForTable(table);
- keyColumnsText.value = inferred.join(", ");
-}
-
function resultStatusLabel(status: DataCompareTableStatus): string {
if (status === "different") return t("dataCompare.statusDifferent");
if (status === "same") return t("dataCompare.statusSame");
@@ -535,7 +720,7 @@ function startCompare(): void {
targetSchemas: [...targetSchemas.value],
targetTables: [...targetTables.value],
targetTable: targetTable.value,
- keyColumns: [...keyColumns.value],
+ keyColumnsByTable: buildSessionKeyColumnsByTable(),
label: `${comparisonEndpointLabel(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value)} → ${comparisonEndpointLabel(targetConnectionId.value, targetDatabase.value, targetSchema.value)}`,
},
tasks,
@@ -651,6 +836,8 @@ watch(sourceConnectionId, (id) => {
sourceTables.value = [];
sourceTable.value = "";
resetSelectedSourceTables([]);
+ // Column metadata and match columns belong to the previous source endpoint.
+ resetTableColumnMetadata();
loadDatabases(id, "source").catch((e) => toast(String(e), 5000));
});
watch(targetConnectionId, (id) => {
@@ -671,6 +858,7 @@ watch(sourceDatabase, () => {
sourceTables.value = [];
sourceTable.value = "";
resetSelectedSourceTables([]);
+ resetTableColumnMetadata();
loadSchemas("source", props.prefillSchema).catch((e) => toast(String(e), 5000));
});
watch(targetDatabase, () => {
@@ -688,6 +876,7 @@ watch(sourceSchema, () => {
sourceTables.value = [];
sourceTable.value = "";
resetSelectedSourceTables([]);
+ resetTableColumnMetadata();
if (sourceSchema.value) loadTables("source").catch((e) => toast(String(e), 5000));
});
watch(targetSchema, () => {
@@ -700,9 +889,12 @@ watch(targetSchema, () => {
watch(selectedSourceTableNames, (tables, previous) => {
if (initializingPrefill) return;
clearResult();
+ // Drop the match columns and metadata of tables that are no longer compared,
+ // so a table that is selected again starts from its own primary key.
+ pruneKeyColumnState(tables);
sourceTable.value = tables.length === 1 ? tables[0] : "";
if (tables.length !== 1) {
- keyColumnsText.value = "";
+ void prefetchSelectedTableColumns(tables);
return;
}
const table = tables[0];
@@ -711,10 +903,7 @@ watch(selectedSourceTableNames, (tables, previous) => {
} else if (previous?.length === 1 && targetTable.value === previous[0]) {
targetTable.value = "";
}
- if (table !== previous?.[0]) {
- keyColumnsText.value = "";
- }
- inferKeyColumns().catch(() => {});
+ void prefetchSelectedTableColumns(tables);
});
watch(targetTable, () => {
if (initializingPrefill) return;
@@ -748,6 +937,7 @@ watch(
if (sourceTables.value.includes(props.prefillTable)) {
resetSelectedSourceTables([props.prefillTable]);
sourceTable.value = props.prefillTable;
+ await loadTableColumns(props.prefillTable);
}
}
} finally {
@@ -917,10 +1107,59 @@ onBeforeUnmount(() => {
</div>
<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')" :disabled="comparing" />
- <div class="text-[11px] text-muted-foreground">
- {{ t("dataCompare.keyColumnsAutoHint") }}
+ <div class="flex flex-wrap items-center gap-2">
+ <Label class="text-xs font-medium">{{ t("dataCompare.keyColumns") }}</Label>
+ <span v-if="singleKeyColumnRow" class="inline-flex items-center rounded px-1.5 py-0.5 text-[10px] font-medium" :class="singleKeyColumnRow.manual ? 'bg-primary/15 text-primary' : 'bg-muted text-muted-foreground'">
+ {{ singleKeyColumnRow.manual ? t("dataCompare.keyColumnsStatusManual") : t("dataCompare.keyColumnsStatusAuto") }}
+ </span>
+ <Button v-if="singleKeyColumnRow?.manual" size="sm" variant="ghost" class="h-6 px-1.5 text-[11px]" :disabled="comparing" @click="clearTableKeyColumnsOverride(singleKeyColumnRow.table)">
+ {{ t("dataCompare.keyColumnsResetAuto") }}
+ </Button>
+ </div>
+
+ <div v-if="!selectedSourceTableNames.length" class="text-[11px] text-muted-foreground">
+ {{ t("dataCompare.keyColumnsSelectTableHint") }}
+ </div>
+
+ <!-- Single table: pick match columns straight from the real database columns. -->
+ <div v-else-if="singleKeyColumnRow" class="space-y-1">
+ <CompareKeyColumnsSelect :model-value="singleKeyColumnRow.columns" :columns="columnsForTable(singleKeyColumnRow.table)" :loading="singleKeyColumnRow.loading" :disabled="comparing" @update:model-value="(columns) => setTableKeyColumns(singleKeyColumnRow!.table, columns)" />
+ <div class="text-[11px]" data-key-column-hint :class="singleKeyColumnRow.error || singleKeyColumnRow.status === 'missing' ? 'text-destructive' : 'text-muted-foreground'">
+ {{ singleKeyColumnRow.hint }}
+ </div>
+ </div>
+
+ <!-- Batch compare: every table keeps its own match columns. -->
+ <div v-else class="space-y-1">
+ <div class="rounded-lg border">
+ <div class="border-b bg-muted/20 px-2 py-1 text-[11px] text-muted-foreground">
+ {{ t("dataCompare.keyColumnsPerTableHint") }}
+ </div>
+ <div class="max-h-56 divide-y overflow-auto">
+ <div v-for="row in keyColumnRows" :key="row.table">
+ <button type="button" class="dbx-compare-key-table-row flex w-full items-center gap-2 px-2 py-1.5 text-left text-xs hover:bg-muted/40" :data-key-column-table="row.table" @click="toggleKeyColumnTable(row.table)">
+ <ChevronDown v-if="expandedKeyColumnTable === row.table" class="h-3.5 w-3.5 shrink-0" />
+ <ChevronRight v-else class="h-3.5 w-3.5 shrink-0" />
+ <span class="min-w-0 flex-1 truncate font-mono">{{ row.table }}</span>
+ <span class="min-w-0 max-w-[45%] shrink-0 truncate font-mono" :class="row.columns.length > 0 ? (row.manual ? 'text-foreground' : 'text-muted-foreground') : 'text-destructive'">
+ {{ row.loading ? t("dataCompare.keyColumnsLoading") : row.columns.length > 0 ? row.columns.join(", ") : t("dataCompare.keyColumnsNeedsSelection") }}
+ </span>
+ <span class="shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium" :class="row.status === 'manual' ? 'bg-primary/15 text-primary' : row.status === 'auto' ? 'bg-muted text-muted-foreground' : 'bg-destructive/15 text-destructive'">
+ {{ row.status === "manual" ? t("dataCompare.keyColumnsStatusManual") : row.status === "auto" ? t("dataCompare.keyColumnsStatusAuto") : t("dataCompare.keyColumnsNeedsSelection") }}
+ </span>
+ </button>
+ <div v-if="expandedKeyColumnTable === row.table" class="space-y-1 border-t bg-muted/10 px-2 py-2">
+ <CompareKeyColumnsSelect :model-value="row.columns" :columns="columnsForTable(row.table)" :loading="row.loading" :disabled="comparing" @update:model-value="(columns) => setTableKeyColumns(row.table, columns)" />
+ <div class="flex flex-wrap items-center gap-2 text-[11px]">
+ <span data-key-column-hint :class="row.error || (row.status === 'missing' && row.matched) ? 'text-destructive' : 'text-muted-foreground'">{{ row.hint }}</span>
+ <Button v-if="row.manual" size="sm" variant="ghost" class="h-6 px-1.5 text-[11px]" :disabled="comparing" @click="clearTableKeyColumnsOverride(row.table)">
+ {{ t("dataCompare.keyColumnsResetAuto") }}
+ </Button>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
</div>
</div>
diff --git a/apps/desktop/src/components/diff/TableMultiSelect.vue b/apps/desktop/src/components/diff/TableMultiSelect.vue
index 92648930bb..beb216f85a 100644
--- a/apps/desktop/src/components/diff/TableMultiSelect.vue
+++ b/apps/desktop/src/components/diff/TableMultiSelect.vue
@@ -79,7 +79,7 @@ function toggleSelectAll() {
{{ emptyText || t("tableMultiSelect.noTables") }}
</div>
<div v-else class="max-h-40 overflow-auto rounded border">
- <button v-for="table in filteredTables" :key="table" type="button" :disabled="disabled" class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left text-xs hover:bg-muted/50 disabled:opacity-50" @click="toggle(table)">
+ <button v-for="table in filteredTables" :key="table" type="button" :data-table-name="table" :disabled="disabled" class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left text-xs hover:bg-muted/50 disabled:opacity-50" @click="toggle(table)">
<CheckSquare v-if="selectedSet.has(table)" class="h-3.5 w-3.5 shrink-0 text-primary" />
<Square v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground/40" />
<span class="truncate">{{ table }}</span>
diff --git a/apps/desktop/src/components/diff/__tests__/DataCompareDialog.keyColumns.spec.ts b/apps/desktop/src/components/diff/__tests__/DataCompareDialog.keyColumns.spec.ts
new file mode 100644
index 0000000000..a963c5d14e
--- /dev/null
+++ b/apps/desktop/src/components/diff/__tests__/DataCompareDialog.keyColumns.spec.ts
@@ -0,0 +1,399 @@
+// @vitest-environment happy-dom
+
+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 SOURCE_CONNECTION_ID = "oracle-11g";
+const TARGET_CONNECTION_ID = "oracle-jdbc-11g";
+
+interface MockColumn {
+ name: string;
+ data_type: string;
+ is_primary_key: boolean;
+}
+
+function column(name: string, isPrimaryKey = false): MockColumn {
+ return { name, data_type: "NUMBER", is_primary_key: isPrimaryKey };
+}
+
+const TABLES: Record<string, { source: MockColumn[]; target: MockColumn[] }> = {
+ USERS: {
+ source: [column("USER_ID", true), column("EMAIL"), column("NAME")],
+ target: [column("USER_ID", true), column("EMAIL"), column("NAME")],
+ },
+ ORDERS: {
+ source: [column("TENANT_ID", true), column("ORDER_ID", true), column("ORDER_NO"), column("AMOUNT")],
+ target: [column("TENANT_ID", true), column("ORDER_ID", true), column("ORDER_NO"), column("AMOUNT")],
+ },
+ PAYMENTS: {
+ source: [column("TENANT_ID"), column("PAYMENT_NO")],
+ target: [column("TENANT_ID"), column("PAYMENT_NO")],
+ },
+ CASES: {
+ source: [column("snid", true), column("username")],
+ target: [column("SNID", true), column("USERNAME")],
+ },
+};
+
+const TABLE_NAMES = Object.keys(TABLES);
+
+const mocks = vi.hoisted(() => ({
+ ensureConnected: vi.fn().mockResolvedValue(undefined),
+ listDatabases: vi.fn().mockResolvedValue([]),
+ listSchemas: vi.fn(),
+ listTables: vi.fn(),
+ getColumns: vi.fn(),
+ buildDataCompareSyncPlan: vi.fn(),
+ executeBatch: vi.fn(),
+ prepareDataCompareFromTables: vi.fn(),
+ prepareDataCompareMissingTarget: 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" },
+ {
+ id: "oracle-jdbc-11g",
+ name: "Oracle JDBC 11g",
+ db_type: "jdbc",
+ driver_profile: "oracle",
+ connection_string: "jdbc:oracle:thin:@//localhost:1521/XE",
+ jdbc_driver_class: "oracle.jdbc.OracleDriver",
+ },
+ ];
+ return {
+ useConnectionStore: () => ({
+ connections,
+ sidebarLayout: {
+ groups: [{ id: "oracle", name: "Oracle", collapsed: false }],
+ order: [{ type: "group", id: "oracle", children: connections.map((connection) => ({ type: "connection", id: connection.id })) }],
+ },
+ getConfig: (id: string) => connections.find((connection) => connection.id === id),
+ ensureConnected: mocks.ensureConnected,
+ }),
+ };
+});
+
+vi.mock("@/lib/backend/api", () => ({
+ listDatabases: mocks.listDatabases,
+ listSchemas: mocks.listSchemas,
+ listTables: mocks.listTables,
+ getColumns: mocks.getColumns,
+ buildDataCompareSyncPlan: mocks.buildDataCompareSyncPlan,
+ executeBatch: mocks.executeBatch,
+ prepareDataCompareFromTables: mocks.prepareDataCompareFromTables,
+ prepareDataCompareMissingTarget: mocks.prepareDataCompareMissingTarget,
+}));
+
+const mountedApps: App[] = [];
+
+async function flushAsyncSetup() {
+ for (let index = 0; index < 12; index += 1) {
+ await nextTick();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ }
+}
+
+afterEach(() => {
+ for (const app of mountedApps.splice(0)) app.unmount();
+ document.body.textContent = "";
+ sessionMocks.session = null;
+ vi.clearAllMocks();
+});
+
+function mountDialog(props: Record<string, unknown>): App {
+ const container = document.createElement("div");
+ document.body.append(container);
+ const app = createApp(
+ defineComponent({
+ setup: () => () => h(DataCompareDialog, { open: true, ...props }),
+ }),
+ );
+ mountedApps.push(app);
+ app.use(i18n);
+ app.mount(container);
+ return app;
+}
+
+/** The dialog prefills only the source side; the target must be selected for a task to match. */
+async function selectMatchedTarget(): Promise<void> {
+ const targetConnectionTrigger = document.querySelectorAll<HTMLButtonElement>("button.dbx-diff-connection-trigger")[1];
+ targetConnectionTrigger?.click();
+ await flushAsyncSetup();
+ document.querySelector<HTMLButtonElement>(`[data-picker-connection="${TARGET_CONNECTION_ID}"]`)?.click();
+ await flushAsyncSetup();
+
+ const targetDatabaseTrigger = document.querySelectorAll<HTMLButtonElement>("button.dbx-searchable-select-trigger")[2];
+ targetDatabaseTrigger?.click();
+ await flushAsyncSetup();
+ const reporting = [...document.querySelectorAll<HTMLButtonElement>(".dbx-searchable-select-list button")].find((button) => button.textContent?.trim() === "REPORTING");
+ reporting?.click();
+ await flushAsyncSetup();
+}
+
+async function openWithPrefilledSource(table: string, options: { matchedTarget?: boolean } = {}) {
+ mountDialog({ prefillConnectionId: SOURCE_CONNECTION_ID, prefillDatabase: "DBX_TEST", prefillSchema: "DBX_TEST", prefillTable: table });
+ await flushAsyncSetup();
+ if (options.matchedTarget !== false) await selectMatchedTarget();
+}
+
+function keyColumnTrigger(): HTMLButtonElement | undefined {
+ return document.querySelector<HTMLButtonElement>("button.dbx-compare-key-columns-trigger") ?? undefined;
+}
+
+function keyColumnHint(): string {
+ return document.querySelector<HTMLElement>("[data-key-column-hint]")?.textContent?.trim() ?? "";
+}
+
+function keyColumnRow(table: string): HTMLButtonElement | undefined {
+ return document.querySelector<HTMLButtonElement>(`button.dbx-compare-key-table-row[data-key-column-table="${table}"]`) ?? undefined;
+}
+
+function tableSelectionRow(table: string): HTMLButtonElement | undefined {
+ return document.querySelector<HTMLButtonElement>(`[data-table-name="${table}"]`) ?? undefined;
+}
+
+function buttonWithText(text: string): HTMLButtonElement | undefined {
+ return [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes(text)) ?? undefined;
+}
+
+function compareButton(): HTMLButtonElement | undefined {
+ return buttonWithText(i18n.global.t("dataCompare.compare"));
+}
+
+async function togglePickerColumn(columnName: string): Promise<void> {
+ // The popover stays open between toggles, so only open it when it is closed.
+ if (!document.querySelector(".dbx-compare-key-columns-list")) {
+ keyColumnTrigger()?.click();
+ await flushAsyncSetup();
+ }
+ const option = document.querySelector<HTMLButtonElement>(`.dbx-compare-key-columns-list button[data-column-name="${columnName}"]`);
+ expect(option).toBeDefined();
+ option?.click();
+ await flushAsyncSetup();
+}
+
+function comparedKeyColumns(): { table: string; keys: string[] }[] {
+ return mocks.prepareDataCompareFromTables.mock.calls.map((call) => ({
+ table: (call[0] as { targetTable: string }).targetTable,
+ keys: (call[0] as { keyColumns: string[] }).keyColumns,
+ }));
+}
+
+function preparationFor(table: string) {
+ return {
+ result: { added: [{ key: "1", keyValues: { USER_ID: 1 }, values: { USER_ID: 1, EMAIL: "[email protected]" } }], removed: [], modified: [] },
+ syncStatements: [`INSERT INTO ${table} (USER_ID) VALUES (1)`],
+ syncSql: `INSERT INTO ${table} (USER_ID) VALUES (1)`,
+ preSyncStatements: [],
+ sourceRowCount: 1,
+ targetRowCount: 0,
+ sourceTruncated: false,
+ targetTruncated: false,
+ };
+}
+
+function configuredSession(): DataCompareSession {
+ return {
+ id: "compare-session",
+ version: 1,
+ status: "completed",
+ config: {
+ sourceConnectionId: SOURCE_CONNECTION_ID,
+ sourceDatabase: "DBX_TEST",
+ sourceSchema: "DBX_TEST",
+ sourceDatabases: ["DBX_TEST"],
+ sourceSchemas: ["DBX_TEST"],
+ sourceTables: TABLE_NAMES,
+ selectedSourceTables: ["USERS", "ORDERS"],
+ targetConnectionId: TARGET_CONNECTION_ID,
+ targetDatabase: "REPORTING",
+ targetSchema: "DBX_TEST",
+ targetDatabases: ["REPORTING"],
+ targetSchemas: ["DBX_TEST"],
+ targetTables: TABLE_NAMES,
+ targetTable: "",
+ keyColumnsByTable: { ORDERS: ["ORDER_NO"] },
+ label: "Oracle source → Oracle target",
+ },
+ progress: null,
+ batchResults: [],
+ syncPlan: { insertCount: 0, updateCount: 0, deleteCount: 0, statementCount: 0, syncStatements: [], syncSql: "" },
+ error: null,
+ startedAt: 1,
+ finishedAt: 2,
+ };
+}
+
+function setupMocks() {
+ mocks.listSchemas.mockResolvedValue(["DBX_TEST", "REPORTING", "SYS"]);
+ mocks.listTables.mockResolvedValue(TABLE_NAMES.map((name) => ({ name, table_type: "TABLE" })));
+ mocks.getColumns.mockImplementation((connectionId: string, _database: string, _schema: string, table: string) => {
+ const entry = TABLES[table];
+ if (!entry) return Promise.resolve([]);
+ return Promise.resolve(connectionId === SOURCE_CONNECTION_ID ? entry.source : entry.target);
+ });
+ mocks.prepareDataCompareFromTables.mockImplementation((options: { targetTable: string }) => Promise.resolve(preparationFor(options.targetTable)));
+ mocks.prepareDataCompareMissingTarget.mockImplementation((options: { sourceTable: string }) => Promise.resolve(preparationFor(options.sourceTable)));
+ mocks.buildDataCompareSyncPlan.mockResolvedValue({ insertCount: 1, updateCount: 0, deleteCount: 0, statementCount: 1, syncStatements: ["INSERT"], syncSql: "INSERT" });
+}
+
+describe("DataCompareDialog match columns", () => {
+ it("auto-selects the single primary key of a single-table compare and labels it", async () => {
+ setupMocks();
+ await openWithPrefilledSource("USERS");
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("USER_ID");
+ expect(keyColumnHint()).toBe(i18n.global.t("dataCompare.keyColumnsAutoSummary", { columns: "USER_ID" }));
+ expect(document.body.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusAuto"));
+ expect(compareButton()?.disabled).toBe(false);
+ });
+
+ it("keeps the declared order of a composite primary key", async () => {
+ setupMocks();
+ await openWithPrefilledSource("ORDERS");
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("TENANT_ID, ORDER_ID");
+ expect(keyColumnHint()).toBe(i18n.global.t("dataCompare.keyColumnsAutoSummary", { columns: "TENANT_ID, ORDER_ID" }));
+ });
+
+ it("offers the real database columns with a primary-key badge", async () => {
+ setupMocks();
+ await openWithPrefilledSource("ORDERS");
+
+ keyColumnTrigger()?.click();
+ await flushAsyncSetup();
+
+ const options = [...document.querySelectorAll<HTMLButtonElement>(".dbx-compare-key-columns-list button")];
+ expect(options.map((option) => option.dataset.columnName)).toEqual(["TENANT_ID", "ORDER_ID", "ORDER_NO", "AMOUNT"]);
+ expect(options.map((option) => option.dataset.primaryKey)).toEqual(["true", "true", "false", "false"]);
+ expect(document.body.textContent).toContain(i18n.global.t("dataCompare.keyColumnsSelectedCount", { selected: 2, total: 4 }));
+ });
+
+ it("requires an explicit selection when the table has no primary key", async () => {
+ setupMocks();
+ await openWithPrefilledSource("PAYMENTS");
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe(i18n.global.t("dataCompare.keyColumnsSelectPlaceholder"));
+ expect(keyColumnHint()).toBe(i18n.global.t("dataCompare.keyColumnsNoPrimaryKey"));
+ expect(compareButton()?.disabled).toBe(true);
+
+ await togglePickerColumn("TENANT_ID");
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("TENANT_ID");
+ expect(compareButton()?.disabled).toBe(false);
+ expect(document.body.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusManual"));
+ });
+
+ it("lets the user override the inferred primary key and reset back to it", async () => {
+ setupMocks();
+ await openWithPrefilledSource("ORDERS");
+
+ await togglePickerColumn("TENANT_ID");
+ await togglePickerColumn("ORDER_ID");
+ await togglePickerColumn("ORDER_NO");
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("ORDER_NO");
+ expect(keyColumnHint()).toBe(i18n.global.t("dataCompare.keyColumnsManualHint", { columns: "ORDER_NO" }));
+
+ buttonWithText(i18n.global.t("dataCompare.keyColumnsResetAuto"))?.click();
+ await flushAsyncSetup();
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("TENANT_ID, ORDER_ID");
+ });
+
+ it("configures match columns per table in a batch compare", async () => {
+ setupMocks();
+ await openWithPrefilledSource("USERS");
+
+ tableSelectionRow("ORDERS")?.click();
+ await flushAsyncSetup();
+
+ expect(keyColumnRow("USERS")?.textContent).toContain("USER_ID");
+ expect(keyColumnRow("ORDERS")?.textContent).toContain("TENANT_ID, ORDER_ID");
+ expect(keyColumnRow("USERS")?.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusAuto"));
+ expect(keyColumnRow("ORDERS")?.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusAuto"));
+
+ keyColumnRow("ORDERS")?.click();
+ await flushAsyncSetup();
+ await togglePickerColumn("TENANT_ID");
+ await togglePickerColumn("ORDER_ID");
+ await togglePickerColumn("ORDER_NO");
+
+ expect(keyColumnRow("ORDERS")?.textContent).toContain("ORDER_NO");
+ expect(keyColumnRow("ORDERS")?.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusManual"));
+ // The other table must keep its own primary key.
+ expect(keyColumnRow("USERS")?.textContent).toContain("USER_ID");
+ expect(keyColumnRow("USERS")?.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusAuto"));
+
+ compareButton()?.click();
+ await flushAsyncSetup();
+
+ expect(comparedKeyColumns()).toEqual([
+ { table: "USERS", keys: ["USER_ID"] },
+ { table: "ORDERS", keys: ["ORDER_NO"] },
+ ]);
+ });
+
+ it("restores per-table match columns when a session is reopened", async () => {
+ setupMocks();
+ sessionMocks.session = configuredSession();
+ mountDialog({ sessionId: "compare-session" });
+ await flushAsyncSetup();
+
+ expect(keyColumnRow("USERS")?.textContent).toContain("USER_ID");
+ expect(keyColumnRow("USERS")?.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusAuto"));
+ expect(keyColumnRow("ORDERS")?.textContent).toContain("ORDER_NO");
+ expect(keyColumnRow("ORDERS")?.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusManual"));
+ });
+
+ it("drops a stale manual selection after switching to another source table", async () => {
+ setupMocks();
+ await openWithPrefilledSource("USERS");
+
+ await togglePickerColumn("EMAIL");
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("USER_ID, EMAIL");
+ expect(document.body.textContent).toContain(i18n.global.t("dataCompare.keyColumnsStatusManual"));
+
+ tableSelectionRow("USERS")?.click();
+ await flushAsyncSetup();
+ tableSelectionRow("ORDERS")?.click();
+ await flushAsyncSetup();
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("TENANT_ID, ORDER_ID");
+ expect(keyColumnHint()).toBe(i18n.global.t("dataCompare.keyColumnsAutoSummary", { columns: "TENANT_ID, ORDER_ID" }));
+ });
+
+ it("sends the source spelling of a match column whose target column differs in case", async () => {
+ setupMocks();
+ await openWithPrefilledSource("CASES");
+
+ expect(keyColumnTrigger()?.textContent?.trim()).toBe("snid");
+ expect(compareButton()?.disabled).toBe(false);
+
+ compareButton()?.click();
+ await flushAsyncSetup();
+
+ const options = mocks.prepareDataCompareFromTables.mock.calls[0]?.[0] as { keyColumns: string[]; columns: string[]; sourceColumns: string[]; sourceTable: string };
+ expect(options.sourceTable).toBe("CASES");
+ expect(options.keyColumns).toEqual(["SNID"]);
+ expect(options.columns).toEqual(["SNID", "USERNAME"]);
+ expect(options.sourceColumns).toEqual(["snid", "username"]);
+ expect(document.body.textContent).not.toContain(i18n.global.t("dataCompare.missingKeyColumns", { columns: "snid" }));
+ });
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts b/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
index f570ba82df..392924b13d 100644
--- a/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataCompareSession.spec.ts
@@ -1,5 +1,7 @@
import { strict as assert } from "node:assert";
import { beforeEach, test, vi } from "vitest";
+import type { ColumnInfo } from "@/types/database";
+import type { DataCompareSession, DataCompareSessionConfig } from "../useDataCompareSession.ts";
const apiMock = vi.hoisted(() => ({
buildDataCompareSyncPlan: vi.fn(),
@@ -18,27 +20,76 @@ vi.mock("@/lib/backend/api", () => apiMock);
vi.mock("@/composables/useDialogSources", () => ({ openDataCompareSession: openMock }));
vi.mock("@/composables/useExportTracker", () => ({ useExportTracker: () => trackerMock }));
-const { startDataCompareSession } = await import("../useDataCompareSession.ts");
+const { normalizeKeyColumnOverrides, 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')",
+function column(name: string, isPrimaryKey = false): ColumnInfo {
+ return { name, data_type: "TEXT", is_nullable: true, column_default: null, is_primary_key: isPrimaryKey, extra: null };
+}
+
+const TABLES: Record<string, ColumnInfo[]> = {
+ users: [column("user_id", true), column("email"), column("name")],
+ orders: [column("tenant_id", true), column("order_id", true), column("amount")],
+ payments: [column("payment_no", true), column("tenant_id"), column("amount")],
+ logs: [column("category"), column("created_at")],
+ legacy: [column("snid", true), column("username")],
+};
+
+function preparationFor(table: string) {
+ return {
+ result: { added: [{ key: "1", keyValues: { id: 1 }, values: { id: 1 } }], removed: [], modified: [] },
+ syncStatements: [`INSERT INTO ${table} (id) VALUES (1)`],
+ syncSql: `INSERT INTO ${table} (id) VALUES (1)`,
preSyncStatements: [],
sourceRowCount: 1,
targetRowCount: 0,
sourceTruncated: false,
targetTruncated: false,
- });
+ };
+}
+
+function baseConfig(overrides: Partial<DataCompareSessionConfig> = {}): DataCompareSessionConfig {
+ return {
+ sourceConnectionId: "source",
+ sourceDatabase: "app",
+ sourceSchema: "public",
+ sourceDatabases: ["app"],
+ sourceSchemas: ["public"],
+ sourceTables: Object.keys(TABLES),
+ selectedSourceTables: [],
+ targetConnectionId: "target",
+ targetDatabase: "warehouse",
+ targetSchema: "public",
+ targetDatabases: ["warehouse"],
+ targetSchemas: ["public"],
+ targetTables: Object.keys(TABLES),
+ targetTable: "",
+ keyColumnsByTable: {},
+ label: "app → warehouse",
+ ...overrides,
+ };
+}
+
+const dependencies = {
+ ensureConnected: () => Promise.resolve(undefined),
+ getConfig: () => ({ db_type: "mysql" as const }),
+};
+
+async function runSession(input: DataCompareSessionConfig, tasks: { sourceTable: string; targetTable: string }[]): Promise<DataCompareSession> {
+ const session = startDataCompareSession(input, tasks, dependencies);
+ for (let attempt = 0; attempt < 50 && session.status === "running"; attempt += 1) {
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ }
+ return session;
+}
+
+function keyColumnsOf(call: number): string[] {
+ return apiMock.prepareDataCompareFromTables.mock.calls[call]?.[0]?.keyColumns as string[];
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ apiMock.getColumns.mockImplementation((_connectionId: string, _database: string, _schema: string, table: string) => Promise.resolve(TABLES[table] ?? []));
+ apiMock.prepareDataCompareFromTables.mockImplementation((options: { targetTable: string }) => Promise.resolve(preparationFor(options.targetTable)));
apiMock.buildDataCompareSyncPlan.mockResolvedValue({
insertCount: 1,
updateCount: 0,
@@ -47,36 +98,10 @@ test("runs a data compare session independently of the dialog and retains its re
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));
- }
+test("runs a data compare session independently of the dialog and retains its result", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users"], targetTable: "users" }), [{ sourceTable: "users", targetTable: "users" }]);
assert.equal(session.status, "completed");
assert.equal(session.batchResults.length, 1);
@@ -91,6 +116,117 @@ test("runs a data compare session independently of the dialog and retains its re
assert.equal(openMock.mock.calls.at(-1)?.[0], session.id);
});
-beforeEach(() => {
- vi.clearAllMocks();
+test("infers the primary key of every table when no match columns are configured", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users", "orders", "payments"] }), [
+ { sourceTable: "users", targetTable: "users" },
+ { sourceTable: "orders", targetTable: "orders" },
+ { sourceTable: "payments", targetTable: "payments" },
+ ]);
+
+ assert.equal(session.status, "completed");
+ assert.deepEqual(
+ session.batchResults.map((result) => result.keyColumns),
+ [["user_id"], ["tenant_id", "order_id"], ["payment_no"]],
+ );
+ assert.deepEqual(
+ apiMock.prepareDataCompareFromTables.mock.calls.map((call) => call[0].keyColumns),
+ [["user_id"], ["tenant_id", "order_id"], ["payment_no"]],
+ );
+});
+
+test("gives one table its own match columns without changing the other tables", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users", "orders", "payments"], keyColumnsByTable: { payments: ["tenant_id", "payment_no"] } }), [
+ { sourceTable: "users", targetTable: "users" },
+ { sourceTable: "orders", targetTable: "orders" },
+ { sourceTable: "payments", targetTable: "payments" },
+ ]);
+
+ assert.equal(session.status, "completed");
+ assert.deepEqual(
+ session.batchResults.map((result) => ({ table: result.sourceTable, keys: result.keyColumns })),
+ [
+ { table: "users", keys: ["user_id"] },
+ { table: "orders", keys: ["tenant_id", "order_id"] },
+ { table: "payments", keys: ["tenant_id", "payment_no"] },
+ ],
+ );
+ assert.deepEqual(keyColumnsOf(2), ["tenant_id", "payment_no"]);
+});
+
+test("keeps a manual match-column selection on one table even when another table is overridden too", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users", "orders"], keyColumnsByTable: { users: ["email"], orders: ["amount"] } }), [
+ { sourceTable: "users", targetTable: "users" },
+ { sourceTable: "orders", targetTable: "orders" },
+ ]);
+
+ assert.equal(session.status, "completed");
+ assert.deepEqual(keyColumnsOf(0), ["email"]);
+ assert.deepEqual(keyColumnsOf(1), ["amount"]);
+});
+
+test("reports a missing key column only for the table that configures it", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users", "orders"], keyColumnsByTable: { users: ["does_not_exist"] } }), [
+ { sourceTable: "users", targetTable: "users" },
+ { sourceTable: "orders", targetTable: "orders" },
+ ]);
+
+ assert.equal(session.status, "completed");
+ assert.equal(session.batchResults[0]?.status, "error");
+ assert.match(session.batchResults[0]?.error ?? "", /does_not_exist/);
+ assert.equal(session.batchResults[1]?.status, "different");
+});
+
+test("never falls back to the first column when a table has no primary key", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["logs"], targetTable: "logs" }), [{ sourceTable: "logs", targetTable: "logs" }]);
+
+ assert.equal(session.batchResults.length, 1);
+ assert.equal(session.batchResults[0]?.status, "error");
+ assert.equal(apiMock.prepareDataCompareFromTables.mock.calls.length, 0);
+});
+
+test("treats an explicitly cleared selection as missing match columns instead of restoring the primary key", async () => {
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users"], targetTable: "users", keyColumnsByTable: { users: [] } }), [{ sourceTable: "users", targetTable: "users" }]);
+
+ assert.equal(session.batchResults[0]?.status, "error");
+ assert.equal(apiMock.prepareDataCompareFromTables.mock.calls.length, 0);
+});
+
+test("canonicalizes a manual match column against an upper-cased target column", async () => {
+ apiMock.getColumns.mockImplementation((connectionId: string, _database: string, _schema: string, table: string) => {
+ if (table !== "legacy") return Promise.resolve(TABLES[table] ?? []);
+ return Promise.resolve(connectionId === "source" ? [column("snid", true), column("username")] : [column("SNID", true), column("USERNAME")]);
+ });
+
+ const session = await runSession(baseConfig({ selectedSourceTables: ["legacy"], targetTable: "legacy", keyColumnsByTable: { legacy: ["snid", "Username"] } }), [{ sourceTable: "legacy", targetTable: "legacy" }]);
+
+ assert.equal(session.batchResults[0]?.status, "different");
+ assert.deepEqual(keyColumnsOf(0), ["SNID", "USERNAME"]);
+ assert.deepEqual(apiMock.prepareDataCompareFromTables.mock.calls[0]?.[0].sourceColumns, ["snid", "username"]);
+ assert.deepEqual(apiMock.prepareDataCompareFromTables.mock.calls[0]?.[0].columns, ["SNID", "USERNAME"]);
+});
+
+test("uses a per-table override for a source table whose target table is missing", async () => {
+ apiMock.prepareDataCompareMissingTarget.mockResolvedValue(preparationFor("users"));
+
+ const session = await runSession(baseConfig({ selectedSourceTables: ["users"], targetTable: "users", keyColumnsByTable: { users: ["email"] }, targetTables: ["orders"] }), [{ sourceTable: "users", targetTable: "users" }]);
+
+ assert.equal(session.batchResults[0]?.status, "different");
+ assert.deepEqual(session.batchResults[0]?.keyColumns, ["email"]);
+ assert.deepEqual(apiMock.prepareDataCompareMissingTarget.mock.calls[0]?.[0].keyColumns, ["email"]);
+});
+
+test("keeps the configured per-table match columns after cloning the session config", async () => {
+ const input = baseConfig({ selectedSourceTables: ["users"], targetTable: "users", keyColumnsByTable: { users: [" user_id ", "USER_ID", "email"] } });
+ const session = await runSession(input, [{ sourceTable: "users", targetTable: "users" }]);
+
+ assert.deepEqual(session.config.keyColumnsByTable, { users: ["user_id", "email"] });
+ assert.deepEqual(keyColumnsOf(0), ["user_id", "email"]);
+ // The session must not share the caller's arrays.
+ input.keyColumnsByTable.users?.push("name");
+ assert.deepEqual(session.config.keyColumnsByTable, { users: ["user_id", "email"] });
+});
+
+test("normalizes a per-table match-column map", () => {
+ assert.deepEqual(normalizeKeyColumnOverrides({ users: [" id ", ""], orders: [], "": ["x"] }), { users: ["id"], orders: [] });
+ assert.deepEqual(normalizeKeyColumnOverrides(undefined), {});
});
diff --git a/apps/desktop/src/composables/useDataCompareSession.ts b/apps/desktop/src/composables/useDataCompareSession.ts
index 39f48a5622..160e3e968e 100644
--- a/apps/desktop/src/composables/useDataCompareSession.ts
+++ b/apps/desktop/src/composables/useDataCompareSession.ts
@@ -3,11 +3,18 @@ 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 { inferCompareKeyColumns, intersectCompareColumns, matchColumnNameIgnoreCase, normalizeKeyColumns, 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;
+/**
+ * One source-table -> target-table compare task.
+ *
+ * Match columns are not part of the task itself: they are stored per source
+ * table in `DataCompareSessionConfig.keyColumnsByTable` so that every task of a
+ * batch compare can carry its own selection instead of sharing one global list.
+ */
export interface DataCompareTableTask {
sourceTable: string;
targetTable: string;
@@ -75,7 +82,15 @@ export interface DataCompareSessionConfig {
targetSchemas: string[];
targetTables: string[];
targetTable: string;
- keyColumns: string[];
+ /**
+ * Explicit match columns per source table (keyed by the source table name).
+ *
+ * An absent entry means "no override": the primary key of that source table is
+ * inferred automatically. A present entry is an explicit user choice, so an
+ * empty array means the user cleared the selection and must pick columns
+ * again — it must not silently fall back to the primary key.
+ */
+ keyColumnsByTable: Record<string, string[]>;
label: string;
}
@@ -130,16 +145,36 @@ function cloneConfig(config: DataCompareSessionConfig): DataCompareSessionConfig
targetDatabases: [...config.targetDatabases],
targetSchemas: [...config.targetSchemas],
targetTables: [...config.targetTables],
- keyColumns: [...config.keyColumns],
+ keyColumnsByTable: normalizeKeyColumnOverrides(config.keyColumnsByTable),
};
}
+/**
+ * Normalizes a per-table match-column map so a cloned session never shares
+ * arrays with the caller: every entry is trimmed and de-duplicated while an
+ * explicit empty selection stays an empty array (it must not become "auto").
+ */
+export function normalizeKeyColumnOverrides(overrides: Record<string, string[] | undefined> | null | undefined): Record<string, string[]> {
+ const normalized: Record<string, string[]> = {};
+ for (const [table, columns] of Object.entries(overrides ?? {})) {
+ if (!table) continue;
+ normalized[table] = normalizeKeyColumns(columns ?? []);
+ }
+ return normalized;
+}
+
function sessionError(error: unknown): string {
return error instanceof Error ? error.message : (error as { message?: string } | null)?.message || String(error);
}
+function fallbackCompareErrorMessage(kind: DataCompareSessionErrorKind, columns?: string): string {
+ if (kind === "missingKeyColumns") return `Missing key columns: ${columns ?? ""}`;
+ if (kind === "noCommonColumns") return "No common columns";
+ return "No key columns available";
+}
+
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");
+ return dependencies.formatError?.(kind, columns) ?? fallbackCompareErrorMessage(kind, columns);
}
function toSelectableDiff(diff: DataCompareResult): SelectableDataCompareResult {
@@ -284,6 +319,18 @@ function buildErrorResult(task: DataCompareTableTask, keyColumns: string[], data
};
}
+/**
+ * Resolves the configured match columns of one compare task.
+ *
+ * Returns the explicit per-source-table override when the user configured one
+ * (an empty array counts as "explicitly nothing selected") and `undefined`
+ * otherwise, which means the caller must infer the primary key for that table.
+ */
+function configuredTaskKeyColumns(input: DataCompareSessionConfig, task: DataCompareTableTask): string[] | undefined {
+ const override = input.keyColumnsByTable[task.sourceTable];
+ return override === undefined ? undefined : normalizeKeyColumns(override);
+}
+
async function runDataCompareSession(session: DataCompareSession, tasks: DataCompareTableTask[], dependencies: DataCompareSessionDependencies): Promise<void> {
const input = session.config;
const sourceColumnCache = new Map<string, CompareColumn[]>();
@@ -297,10 +344,11 @@ async function runDataCompareSession(session: DataCompareSession, tasks: DataCom
for (const [index, task] of tasks.entries()) {
publishProgress(session, { current: index + 1, total: tasks.length, table: task.sourceTable });
- let keyColumns = input.keyColumns;
+ const configuredKeys = configuredTaskKeyColumns(input, task);
+ let keyColumns = configuredKeys ?? [];
try {
if (input.targetTables.includes(task.targetTable)) {
- const resolvedKeys = input.keyColumns.length > 0 ? input.keyColumns : await inferKeyColumnsForTable(input, task.sourceTable, sourceColumnCache);
+ const resolvedKeys = configuredKeys ?? (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);
@@ -335,7 +383,7 @@ async function runDataCompareSession(session: DataCompareSession, tasks: DataCom
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 resolvedKeys = configuredTaskKeyColumns(input, task) ?? [];
const sourceColumnNames = sourceColumns.map((column) => column.name);
keyColumns = resolvedKeys.map((key) => matchColumnNameIgnoreCase(key, sourceColumnNames) ?? key);
const preparation = await api.prepareDataCompareMissingTarget({
diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.ts
index a18bc45471..79aa2a0d26 100644
--- a/apps/desktop/src/i18n/locales/az.ts
+++ b/apps/desktop/src/i18n/locales/az.ts
@@ -6715,8 +6715,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total} cədvəl uyğunlaşdırılıb",
missingTargetTables: "Eyni adlı hədəf cədvəllər çatışmır: {tables}",
keyColumns: "Açar sütunlar",
- keyColumnsPlaceholder: "Vergüllə ayrılmış əsas və ya unikal sütunlar",
- keyColumnsAutoHint: "Tək cədvəl müqayisəsində və ya toplu müqayisədə hər cədvəl üçün əsas açarları avtomatik aşkarlamaq üçün boş buraxın.",
+ keyColumnsAutoHint: "Standart olaraq əsas açarlar avtomatik istifadə olunur; digər sütunları əl ilə də seçə bilərsiniz.",
+ keyColumnsSelectPlaceholder: "Uyğunluq sütunlarını seçin",
+ keyColumnsSearch: "Sütun axtar...",
+ keyColumnsEmpty: "Mövcud sütun yoxdur",
+ keyColumnsLoading: "Sütunlar yüklənir...",
+ keyColumnsSelectedCount: "{selected}/{total} sütun seçildi",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "Avtomatik",
+ keyColumnsStatusManual: "Əl ilə",
+ keyColumnsAutoSummary: "Əsas açar avtomatik istifadə olunur: {columns}",
+ keyColumnsManualHint: "Əl ilə seçilmiş uyğunluq sütunları: {columns}",
+ keyColumnsNoneSelected: "Heç bir sütun seçilməyib",
+ keyColumnsNeedsSelection: "Sütun seçin",
+ keyColumnsNoPrimaryKey: "Bu cədvəlin əsas açarı yoxdur. Uyğunluq sütunlarını əl ilə seçin.",
+ keyColumnsResetAuto: "Əsas açarı istifadə et",
+ keyColumnsPerTableHint: "Hər cədvəl öz uyğunluq sütunlarını saxlayır; standart olaraq əsas açar istifadə olunur.",
+ keyColumnsSelectTableHint: "Əvvəlcə mənbə cədvəllərini seçin",
+ keyColumnsTargetMissingHint: "Eyni adlı hədəf cədvəli yoxdur, uyğunluq sütunu tələb olunmur",
rowCounts: "Mənbədə {source} sətir, hədəfdə {target} sətir; tam müqayisə tamamlandı",
previewLimitOption: "Önbaxış: {count}",
compare: "Verilənləri müqayisə et",
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index dc430dbbb9..317c7a1649 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -6943,8 +6943,24 @@ export default {
matchedTables: "{matched}/{total} tables matched",
missingTargetTables: "Missing same-name target tables: {tables}",
keyColumns: "Key Columns",
- keyColumnsPlaceholder: "Comma-separated primary or unique columns",
- keyColumnsAutoHint: "Leave blank to auto-detect primary keys for single-table compare, or per table in batch compare.",
+ keyColumnsAutoHint: "Primary keys are used by default; you can also pick other columns as match columns.",
+ keyColumnsSelectPlaceholder: "Select match columns",
+ keyColumnsSearch: "Search columns...",
+ keyColumnsEmpty: "No columns available",
+ keyColumnsLoading: "Loading columns...",
+ keyColumnsSelectedCount: "{selected}/{total} columns selected",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "Auto",
+ keyColumnsStatusManual: "Manual",
+ keyColumnsAutoSummary: "Using the primary key automatically: {columns}",
+ keyColumnsManualHint: "Manually selected match columns: {columns}",
+ keyColumnsNoneSelected: "No column selected",
+ keyColumnsNeedsSelection: "Select columns",
+ keyColumnsNoPrimaryKey: "This table has no primary key. Select the match columns manually.",
+ keyColumnsResetAuto: "Use primary key",
+ keyColumnsPerTableHint: "Each table keeps its own match columns; primary keys are used by default.",
+ keyColumnsSelectTableHint: "Select source tables first",
+ keyColumnsTargetMissingHint: "No same-name target table, so no match columns are needed",
rowCounts: "Source {source} rows, target {target} rows; full compare completed",
previewLimitOption: "Preview {count}",
compare: "Compare Data",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 9d2e57ac5a..0a46219749 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -6504,8 +6504,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total} tablas emparejadas",
missingTargetTables: "Faltan tablas de destino con el mismo nombre: {tables}",
keyColumns: "Columnas clave",
- keyColumnsPlaceholder: "Columnas primarias o únicas separadas por comas",
- keyColumnsAutoHint: "Déjalo vacío para detectar claves primarias automáticamente en comparación simple o por tabla en lote.",
+ keyColumnsAutoHint: "Las claves primarias se usan de forma predeterminada; también puede seleccionar otras columnas manualmente.",
+ keyColumnsSelectPlaceholder: "Seleccionar columnas de coincidencia",
+ keyColumnsSearch: "Buscar columnas...",
+ keyColumnsEmpty: "No hay columnas disponibles",
+ keyColumnsLoading: "Cargando columnas...",
+ keyColumnsSelectedCount: "{selected}/{total} columnas seleccionadas",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "Automático",
+ keyColumnsStatusManual: "Manual",
+ keyColumnsAutoSummary: "Usando la clave primaria automáticamente: {columns}",
+ keyColumnsManualHint: "Columnas de coincidencia seleccionadas manualmente: {columns}",
+ keyColumnsNoneSelected: "Ninguna columna seleccionada",
+ keyColumnsNeedsSelection: "Seleccione columnas",
+ keyColumnsNoPrimaryKey: "Esta tabla no tiene clave primaria. Seleccione las columnas de coincidencia manualmente.",
+ keyColumnsResetAuto: "Usar clave primaria",
+ keyColumnsPerTableHint: "Cada tabla mantiene sus propias columnas de coincidencia; las claves primarias se usan de forma predeterminada.",
+ keyColumnsSelectTableHint: "Seleccione primero las tablas de origen",
+ keyColumnsTargetMissingHint: "No hay tabla de destino con el mismo nombre, no se necesitan columnas de coincidencia",
rowCounts: "Origen {source} filas, destino {target} filas; comparación completa terminada",
previewLimitOption: "Vista previa {count}",
compare: "Comparar datos",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index bc8585f810..65ee382d87 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -6504,8 +6504,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total} tabelle associate",
missingTargetTables: "Tabelle di destinazione con lo stesso nome mancanti: {tables}",
keyColumns: "Colonne Chiave",
- keyColumnsPlaceholder: "Colonne primarie o uniche separate da virgola",
- keyColumnsAutoHint: "Lascia vuoto per rilevare automaticamente le chiavi primarie per il confronto a tabella singola, o per tabella nel confronto batch.",
+ keyColumnsAutoHint: "Le chiavi primarie vengono usate per impostazione predefinita; puoi anche selezionare altre colonne manualmente.",
+ keyColumnsSelectPlaceholder: "Seleziona colonne di confronto",
+ keyColumnsSearch: "Cerca colonne...",
+ keyColumnsEmpty: "Nessuna colonna disponibile",
+ keyColumnsLoading: "Caricamento colonne...",
+ keyColumnsSelectedCount: "{selected}/{total} colonne selezionate",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "Automatico",
+ keyColumnsStatusManual: "Manuale",
+ keyColumnsAutoSummary: "Chiave primaria usata automaticamente: {columns}",
+ keyColumnsManualHint: "Colonne di confronto selezionate manualmente: {columns}",
+ keyColumnsNoneSelected: "Nessuna colonna selezionata",
+ keyColumnsNeedsSelection: "Seleziona colonne",
+ keyColumnsNoPrimaryKey: "Questa tabella non ha una chiave primaria. Seleziona manualmente le colonne di confronto.",
+ keyColumnsResetAuto: "Usa chiave primaria",
+ keyColumnsPerTableHint: "Ogni tabella mantiene le proprie colonne di confronto; per impostazione predefinita si usa la chiave primaria.",
+ keyColumnsSelectTableHint: "Seleziona prima le tabelle di origine",
+ keyColumnsTargetMissingHint: "Nessuna tabella di destinazione con lo stesso nome: non servono colonne di confronto",
rowCounts: "Sorgente {source} righe, destinazione {target} righe; confronto completo completato",
previewLimitOption: "Anteprima {count}",
compare: "Confronta Dati",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 1a62792d72..760e4fe0a6 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -6542,8 +6542,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total}テーブルがマッチしました",
missingTargetTables: "同名のターゲットテーブルが見つかりません: {tables}",
keyColumns: "キー列",
- keyColumnsPlaceholder: "カンマ区切りの主キーまたは一意列",
- keyColumnsAutoHint: "単一テーブル比較では空白で主キーを自動検出、バッチ比較ではテーブルごとに指定します。",
+ keyColumnsAutoHint: "既定では主キーを自動使用します。他の列を手動で選択することもできます。",
+ keyColumnsSelectPlaceholder: "照合列を選択",
+ keyColumnsSearch: "列を検索...",
+ keyColumnsEmpty: "選択できる列がありません",
+ keyColumnsLoading: "列を読み込み中...",
+ keyColumnsSelectedCount: "{selected}/{total} 列を選択",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "自動",
+ keyColumnsStatusManual: "手動",
+ keyColumnsAutoSummary: "主キーを自動使用: {columns}",
+ keyColumnsManualHint: "手動で選択した照合列: {columns}",
+ keyColumnsNoneSelected: "列が選択されていません",
+ keyColumnsNeedsSelection: "選択してください",
+ keyColumnsNoPrimaryKey: "このテーブルには主キーがありません。照合列を手動で選択してください。",
+ keyColumnsResetAuto: "主キーに戻す",
+ keyColumnsPerTableHint: "テーブルごとに照合列を保持します。既定では主キーを使用します。",
+ keyColumnsSelectTableHint: "先にソーステーブルを選択してください",
+ keyColumnsTargetMissingHint: "同名のターゲットテーブルがないため照合列は不要です",
rowCounts: "ソース {source}行、ターゲット {target}行、完全比較が完了しました",
previewLimitOption: "{count}件プレビュー",
compare: "データを比較",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index 862ef32f93..604bc9846b 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -6254,8 +6254,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total}개 테이블 매칭됨",
missingTargetTables: "같은 이름의 대상 테이블 누락: {tables}",
keyColumns: "키 컬럼",
- keyColumnsPlaceholder: "쉼표로 구분된 기본 또는 고유 컬럼",
- keyColumnsAutoHint: "단일 테이블 비교 시 기본 키를 자동 감지하거나, 일괄 비교 시 테이블별로 자동 감지하려면 비워 두세요.",
+ keyColumnsAutoHint: "기본적으로 기본 키를 자동 사용합니다. 다른 컬럼을 직접 선택할 수도 있습니다.",
+ keyColumnsSelectPlaceholder: "매칭 컬럼 선택",
+ keyColumnsSearch: "컬럼 검색...",
+ keyColumnsEmpty: "선택할 수 있는 컬럼이 없습니다",
+ keyColumnsLoading: "컬럼을 불러오는 중...",
+ keyColumnsSelectedCount: "{selected}/{total}개 컬럼 선택됨",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "자동",
+ keyColumnsStatusManual: "수동",
+ keyColumnsAutoSummary: "기본 키를 자동 사용: {columns}",
+ keyColumnsManualHint: "직접 선택한 매칭 컬럼: {columns}",
+ keyColumnsNoneSelected: "선택된 컬럼이 없습니다",
+ keyColumnsNeedsSelection: "선택 필요",
+ keyColumnsNoPrimaryKey: "이 테이블에는 기본 키가 없습니다. 매칭 컬럼을 직접 선택하세요.",
+ keyColumnsResetAuto: "기본 키로 되돌리기",
+ keyColumnsPerTableHint: "각 테이블이 자체 매칭 컬럼을 사용하며 기본값은 기본 키입니다.",
+ keyColumnsSelectTableHint: "먼저 소스 테이블을 선택하세요",
+ keyColumnsTargetMissingHint: "대상에 동일한 이름의 테이블이 없어 매칭 컬럼이 필요하지 않습니다",
rowCounts: "소스 {source}행, 대상 {target}행; 전체 비교 완료",
previewLimitOption: "미리보기 {count}",
compare: "데이터 비교",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 3125482a92..b71b59d779 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -6506,8 +6506,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total} tabelas correspondidas",
missingTargetTables: "Tabelas de destino de mesmo nome ausentes: {tables}",
keyColumns: "Colunas-Chave",
- keyColumnsPlaceholder: "Colunas primárias ou únicas separadas por vírgula",
- keyColumnsAutoHint: "Deixe em branco para detectar automaticamente as chaves primárias na comparação de tabela única, ou por tabela na comparação em lote.",
+ keyColumnsAutoHint: "As chaves primárias são usadas por padrão; você também pode selecionar outras colunas manualmente.",
+ keyColumnsSelectPlaceholder: "Selecionar colunas de comparação",
+ keyColumnsSearch: "Pesquisar colunas...",
+ keyColumnsEmpty: "Nenhuma coluna disponível",
+ keyColumnsLoading: "Carregando colunas...",
+ keyColumnsSelectedCount: "{selected}/{total} colunas selecionadas",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "Automático",
+ keyColumnsStatusManual: "Manual",
+ keyColumnsAutoSummary: "Usando a chave primária automaticamente: {columns}",
+ keyColumnsManualHint: "Colunas de comparação selecionadas manualmente: {columns}",
+ keyColumnsNoneSelected: "Nenhuma coluna selecionada",
+ keyColumnsNeedsSelection: "Selecione colunas",
+ keyColumnsNoPrimaryKey: "Esta tabela não tem chave primária. Selecione as colunas de comparação manualmente.",
+ keyColumnsResetAuto: "Usar chave primária",
+ keyColumnsPerTableHint: "Cada tabela mantém suas próprias colunas de comparação; as chaves primárias são usadas por padrão.",
+ keyColumnsSelectTableHint: "Selecione primeiro as tabelas de origem",
+ keyColumnsTargetMissingHint: "Não há tabela de destino com o mesmo nome, então não são necessárias colunas de comparação",
rowCounts: "Origem com {source} linhas, destino com {target} linhas; comparação completa concluída",
previewLimitOption: "Pré-visualizar {count}",
compare: "Comparar Dados",
diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.ts
index bb9b616b88..caacc2cf0e 100644
--- a/apps/desktop/src/i18n/locales/tr.ts
+++ b/apps/desktop/src/i18n/locales/tr.ts
@@ -6597,8 +6597,24 @@ export default withEnglishFallback({
matchedTables: "{matched}/{total} tablo eşleşti",
missingTargetTables: "Aynı adlı hedef tablolar eksik: {tables}",
keyColumns: "Anahtar Sütunlar",
- keyColumnsPlaceholder: "Virgülle ayrılmış birincil veya benzersiz sütunlar",
- keyColumnsAutoHint: "Tek tablo karşılaştırmasında birincil anahtarları otomatik algılamak için boş bırakın; toplu karşılaştırmada her tablo için ayrı ayrı algılanır.",
+ keyColumnsAutoHint: "Birincil anahtarlar varsayılan olarak kullanılır; diğer sütunları elle de seçebilirsiniz.",
+ keyColumnsSelectPlaceholder: "Eşleşme sütunlarını seç",
+ keyColumnsSearch: "Sütun ara...",
+ keyColumnsEmpty: "Kullanılabilir sütun yok",
+ keyColumnsLoading: "Sütunlar yükleniyor...",
+ keyColumnsSelectedCount: "{selected}/{total} sütun seçildi",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "Otomatik",
+ keyColumnsStatusManual: "Manuel",
+ keyColumnsAutoSummary: "Birincil anahtar otomatik kullanılıyor: {columns}",
+ keyColumnsManualHint: "Elle seçilen eşleşme sütunları: {columns}",
+ keyColumnsNoneSelected: "Sütun seçilmedi",
+ keyColumnsNeedsSelection: "Sütun seçin",
+ keyColumnsNoPrimaryKey: "Bu tabloda birincil anahtar yok. Eşleşme sütunlarını elle seçin.",
+ keyColumnsResetAuto: "Birincil anahtarı kullan",
+ keyColumnsPerTableHint: "Her tablo kendi eşleşme sütunlarını kullanır; varsayılan olarak birincil anahtar kullanılır.",
+ keyColumnsSelectTableHint: "Önce kaynak tabloları seçin",
+ keyColumnsTargetMissingHint: "Aynı adlı hedef tablo yok, eşleşme sütunu gerekmez",
rowCounts: "Kaynak {source} satır, hedef {target} satır; tam karşılaştırma tamamlandı",
previewLimitOption: "Önizleme {count}",
compare: "Verileri Karşılaştır",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 98d238bc88..181034f20c 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -6917,8 +6917,24 @@ export default withEnglishFallback({
matchedTables: "已匹配 {matched}/{total} 张表",
missingTargetTables: "目标端缺少同名表:{tables}",
keyColumns: "匹配字段",
- keyColumnsPlaceholder: "用逗号分隔主键或唯一键字段",
- keyColumnsAutoHint: "留空时,单表会自动推断主键;多表会对每张表分别自动推断。",
+ keyColumnsAutoHint: "默认自动使用主键;也可手动选择其他字段作为匹配字段。",
+ keyColumnsSelectPlaceholder: "选择匹配字段",
+ keyColumnsSearch: "搜索字段...",
+ keyColumnsEmpty: "没有可选的字段",
+ keyColumnsLoading: "正在加载字段...",
+ keyColumnsSelectedCount: "已选 {selected}/{total} 个字段",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "自动",
+ keyColumnsStatusManual: "手动",
+ keyColumnsAutoSummary: "已自动使用主键:{columns}",
+ keyColumnsManualHint: "手动选择匹配字段:{columns}",
+ keyColumnsNoneSelected: "未选择任何字段",
+ keyColumnsNeedsSelection: "需选择",
+ keyColumnsNoPrimaryKey: "该表没有主键,请手动选择匹配字段",
+ keyColumnsResetAuto: "恢复自动(主键)",
+ keyColumnsPerTableHint: "每张表使用各自的匹配字段,默认自动使用主键。",
+ keyColumnsSelectTableHint: "请先选择源表",
+ keyColumnsTargetMissingHint: "目标端缺少同名表,无需匹配字段",
rowCounts: "源表 {source} 行,目标表 {target} 行;已完成全量比较",
previewLimitOption: "预览 {count}",
compare: "开始比较数据",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 999849fdb4..5c6c1be443 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -5836,8 +5836,24 @@ export default withEnglishFallback({
matchedTables: "已比對 {matched}/{total} 張資料表",
missingTargetTables: "目標端缺少同名資料表:{tables}",
keyColumns: "鍵欄位",
- keyColumnsPlaceholder: "以逗號分隔主鍵或唯一欄位",
- keyColumnsAutoHint: "留空時,單一資料表會自動偵測主鍵;批次比較則會逐表偵測。",
+ keyColumnsAutoHint: "預設自動使用主鍵;也可手動選擇其他欄位作為匹配欄位。",
+ keyColumnsSelectPlaceholder: "選擇匹配欄位",
+ keyColumnsSearch: "搜尋欄位...",
+ keyColumnsEmpty: "沒有可選的欄位",
+ keyColumnsLoading: "正在載入欄位...",
+ keyColumnsSelectedCount: "已選 {selected}/{total} 個欄位",
+ keyColumnsPrimaryKeyBadge: "PK",
+ keyColumnsStatusAuto: "自動",
+ keyColumnsStatusManual: "手動",
+ keyColumnsAutoSummary: "已自動使用主鍵:{columns}",
+ keyColumnsManualHint: "手動選擇匹配欄位:{columns}",
+ keyColumnsNoneSelected: "未選擇任何欄位",
+ keyColumnsNeedsSelection: "需選擇",
+ keyColumnsNoPrimaryKey: "此資料表沒有主鍵,請手動選擇匹配欄位",
+ keyColumnsResetAuto: "恢復自動(主鍵)",
+ keyColumnsPerTableHint: "每張資料表使用各自的匹配欄位,預設自動使用主鍵。",
+ keyColumnsSelectTableHint: "請先選擇來源資料表",
+ keyColumnsTargetMissingHint: "目標端缺少同名資料表,無需匹配欄位",
rowCounts: "來源 {source} 列,目標 {target} 列;已完成完整比較",
previewLimitOption: "預覽 {count}",
compare: "開始比較資料",
diff --git a/apps/desktop/src/lib/dataGrid/__tests__/dataCompareKeyInference.spec.ts b/apps/desktop/src/lib/dataGrid/__tests__/dataCompareKeyInference.spec.ts
index 35d61a9c96..1d049254ee 100644
--- a/apps/desktop/src/lib/dataGrid/__tests__/dataCompareKeyInference.spec.ts
+++ b/apps/desktop/src/lib/dataGrid/__tests__/dataCompareKeyInference.spec.ts
@@ -1,5 +1,5 @@
import { describe, expect, it } from "vitest";
-import { inferCompareKeyColumns, intersectCompareColumns, matchColumnNameIgnoreCase } from "../dataCompare";
+import { inferCompareKeyColumns, intersectCompareColumns, matchColumnNameIgnoreCase, normalizeKeyColumns, sameKeyColumns } from "../dataCompare";
describe("inferCompareKeyColumns", () => {
it("returns all primary-key columns when a primary key exists", () => {
@@ -71,3 +71,36 @@ describe("matchColumnNameIgnoreCase", () => {
expect(matchColumnNameIgnoreCase("missing", ["snid"])).toBeUndefined();
});
});
+
+describe("normalizeKeyColumns", () => {
+ it("keeps the given order so a composite key stays stable", () => {
+ expect(normalizeKeyColumns(["tenant_id", "order_id"])).toEqual(["tenant_id", "order_id"]);
+ });
+
+ it("trims names and drops blanks", () => {
+ expect(normalizeKeyColumns([" id ", "", " ", "name"])).toEqual(["id", "name"]);
+ });
+
+ it("drops case-insensitive duplicates but keeps the first spelling", () => {
+ expect(normalizeKeyColumns(["ID", "id", "Id"])).toEqual(["ID"]);
+ });
+
+ it("returns an empty array for an empty selection", () => {
+ expect(normalizeKeyColumns([])).toEqual([]);
+ });
+});
+
+describe("sameKeyColumns", () => {
+ it("ignores order and identifier case", () => {
+ expect(sameKeyColumns(["tenant_id", "order_id"], ["ORDER_ID", "TENANT_ID"])).toBe(true);
+ });
+
+ it("detects different selections and different lengths", () => {
+ expect(sameKeyColumns(["id"], ["ID", "name"])).toBe(false);
+ expect(sameKeyColumns(["id"], ["name"])).toBe(false);
+ });
+
+ it("treats two empty selections as equal", () => {
+ expect(sameKeyColumns([], [])).toBe(true);
+ });
+});
diff --git a/apps/desktop/src/lib/dataGrid/dataCompare.ts b/apps/desktop/src/lib/dataGrid/dataCompare.ts
index 10f4b5a10d..235b4dcf30 100644
--- a/apps/desktop/src/lib/dataGrid/dataCompare.ts
+++ b/apps/desktop/src/lib/dataGrid/dataCompare.ts
@@ -121,6 +121,9 @@ export interface DataCompareSyncPlan {
syncSql: string;
}
+/** Minimal column shape a match-column picker needs, so it can be fed straight from `getColumns`. */
+export type CompareKeyColumnOption = Pick<ColumnInfo, "name" | "is_primary_key">;
+
/**
* Safely infers the columns to use as comparison keys for a table.
*
@@ -134,7 +137,7 @@ export interface DataCompareSyncPlan {
* (category, status, date, ...) and make the whole table comparison fail with
* an unhelpful duplicate-key error.
*/
-export function inferCompareKeyColumns(columns: Pick<ColumnInfo, "name" | "is_primary_key">[]): string[] {
+export function inferCompareKeyColumns(columns: CompareKeyColumnOption[]): string[] {
const primaryKeys: string[] = [];
for (const column of columns) {
if (column.is_primary_key) primaryKeys.push(column.name);
@@ -142,6 +145,41 @@ export function inferCompareKeyColumns(columns: Pick<ColumnInfo, "name" | "is_pr
return primaryKeys;
}
+/**
+ * Normalizes a match-column selection: trims entries, drops blanks and removes
+ * case-insensitive duplicates while keeping the caller's order.
+ *
+ * Order is preserved because the backend builds each row key from `keyColumns`
+ * in order; a stable order keeps diff keys identical between runs, and it lets a
+ * composite primary key keep the column order the table declares.
+ */
+export function normalizeKeyColumns(columns: readonly string[]): string[] {
+ const seen = new Set<string>();
+ const normalized: string[] = [];
+ for (const column of columns) {
+ const name = column.trim();
+ if (!name) continue;
+ const lowerName = name.toLowerCase();
+ if (seen.has(lowerName)) continue;
+ seen.add(lowerName);
+ normalized.push(name);
+ }
+ return normalized;
+}
+
+/**
+ * Compares two match-column selections ignoring order and identifier case.
+ * Used to decide whether a manual selection still equals the inferred primary
+ * key, in which case it carries no override.
+ */
+export function sameKeyColumns(a: readonly string[], b: readonly string[]): boolean {
+ const normalizedA = normalizeKeyColumns(a);
+ const normalizedB = normalizeKeyColumns(b);
+ if (normalizedA.length !== normalizedB.length) return false;
+ const lowerB = new Set(normalizedB.map((column) => column.toLowerCase()));
+ return normalizedA.every((column) => lowerB.has(column.toLowerCase()));
+}
+
export interface CompareColumnIntersection {
/** Target-side column names, kept in source order. */
columns: string[];