@@ -757,17 +800,7 @@ async function fetchDbVersion(connectionId: string, database: string, schema: st
- $emit('update:targetConnectionId', v)"
- :connections="sqlConnections"
- :layout="store.sidebarLayout"
- :placeholder="t('diff.selectConnection')"
- :search-placeholder="t('diff.searchConnection')"
- :empty-text="t('common.noResults')"
- trigger-class="dbx-diff-connection-trigger h-8 w-full max-w-none justify-between gap-1.5 rounded-md border border-input bg-transparent px-2.5 text-xs 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"
- list-class="w-[var(--reka-popover-trigger-width)]"
- />
+ $emit('update:targetConnectionId', v)" :connections="compareConnections" :layout="store.sidebarLayout" :disabled="loading" />
diff --git a/apps/desktop/src/components/diff/SchemaDiffDialog.vue b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
index 0ef81e662e..dfa91a7fbe 100644
--- a/apps/desktop/src/components/diff/SchemaDiffDialog.vue
+++ b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
@@ -9,6 +9,7 @@ import { GitCompareArrows, ArrowLeft, Play, Loader2, Maximize2, Minimize2, Alert
import * as api from "@/lib/backend/api";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import { supportsDatabaseCompare } from "@/lib/database/databaseCompareCapabilities";
import { useSchemaDiffConfig } from "@/composables/useSchemaDiffConfig";
import SchemaDiffConfigStep from "@/components/diff/SchemaDiffConfigStep.vue";
import SchemaDiffConfigSelector from "@/components/diff/SchemaDiffConfigSelector.vue";
@@ -587,6 +588,14 @@ function runWithoutTargetIdentityReset(action: () => void): void {
}
}
+function handleSourceConnectionChange(connectionId: string): void {
+ if (connectionId === sourceConnectionId.value) return;
+ sourceConnectionId.value = connectionId;
+ sourceDatabase.value = "";
+ sourceSchema.value = "";
+ clearCompareObjectSelection();
+}
+
function clearCompareObjectSelection(): void {
if (!activeConfig.value) return;
updateActiveConfigOptions(
@@ -729,6 +738,7 @@ function handleFieldMappingsUpdate(mappings: FieldMappingEntry[]) {
function handleCompare(): void {
const sourceConfig = store.getConfig(sourceConnectionId.value);
const targetConfig = store.getConfig(targetConnectionId.value);
+ if (!supportsDatabaseCompare(sourceConfig, "schema") || !supportsDatabaseCompare(targetConfig, "schema")) return;
const targetDbType = (targetConfig?.db_type || "mysql") as DatabaseType;
const sourceDbType = sourceConfig?.db_type || targetDbType;
const options = normalizeSchemaDiffCompareOptions(activeConfig.value?.options, targetDbType);
@@ -1193,6 +1203,7 @@ function handleDeleteHistoryConfig(configId: string) {
}
async function fetchDbVersion(connectionId: string, database: string, schema: string) {
+ if (!supportsDatabaseCompare(store.getConfig(connectionId), "schema")) return;
try {
await store.ensureConnected(connectionId);
const config = store.getConfig(connectionId);
@@ -1307,7 +1318,8 @@ const targetConnectionInfo = computed(() => {
({
+ session: null as DataCompareSession | null,
+ ensureConnected: vi.fn(),
+ listDatabases: vi.fn(),
+ listSchemas: vi.fn(),
+ listTables: vi.fn(),
+ getColumns: vi.fn(),
+ toast: vi.fn(),
+}));
+
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
+vi.mock("@/composables/useDataCompareSession", async (importOriginal) => ({
+ ...(await importOriginal()),
+ getDataCompareSession: (id: string | null | undefined) => (id === mocks.session?.id ? mocks.session : undefined),
+}));
+vi.mock("@/stores/connectionStore", () => {
+ const connections = [1, 2, 3].map((index) => ({ id: `pg-${index}`, name: `PostgreSQL ${index}`, db_type: "postgres" }));
+ return {
+ useConnectionStore: () => ({
+ connections,
+ sidebarLayout: { groups: [], order: connections.map(({ id }) => ({ type: "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,
+}));
+
+const mountedApps: App[] = [];
+const tables = [
+ { name: "orders", table_type: "TABLE" },
+ { name: "invoices", table_type: "TABLE" },
+];
+
+beforeEach(() => {
+ mocks.ensureConnected.mockReset().mockResolvedValue(undefined);
+ mocks.listDatabases.mockReset().mockResolvedValue([{ name: "app" }]);
+ mocks.listSchemas.mockReset().mockResolvedValue(["public", "analytics"]);
+ mocks.listTables.mockReset().mockResolvedValue(tables);
+ mocks.getColumns.mockReset().mockResolvedValue([{ name: "id", data_type: "integer", is_primary_key: true }]);
+ mocks.toast.mockReset();
+});
+
+afterEach(() => {
+ for (const app of mountedApps.splice(0)) app.unmount();
+ document.body.textContent = "";
+ mocks.session = null;
+});
+
+async function flushAsyncSetup() {
+ for (let index = 0; index < 8; index += 1) {
+ await nextTick();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ }
+}
+
+async function mountLoadedDialog() {
+ mocks.session = {
+ id: "loaded-compare",
+ version: 1,
+ status: "completed",
+ config: {
+ sourceConnectionId: "pg-1",
+ sourceDatabase: "app",
+ sourceSchema: "public",
+ sourceDatabases: ["app", "reporting"],
+ sourceSchemas: ["public", "analytics"],
+ sourceTables: ["orders", "invoices"],
+ selectedSourceTables: ["orders"],
+ targetConnectionId: "pg-2",
+ targetDatabase: "reporting",
+ targetSchema: "analytics",
+ targetDatabases: ["app", "reporting"],
+ targetSchemas: ["public", "analytics"],
+ targetTables: ["orders", "invoices"],
+ targetTable: "invoices",
+ keyColumnsByTable: {},
+ label: "Loaded comparison",
+ },
+ progress: null,
+ batchResults: [],
+ syncPlan: { insertCount: 0, updateCount: 0, deleteCount: 0, statementCount: 0, syncStatements: [], syncSql: "" },
+ error: null,
+ startedAt: 1,
+ finishedAt: 2,
+ };
+ const container = document.createElement("div");
+ document.body.append(container);
+ const app = createApp(defineComponent({ setup: () => () => h(DataCompareDialog, { open: true, sessionId: "loaded-compare" }) }));
+ mountedApps.push(app);
+ app.use(i18n);
+ app.mount(container);
+ await flushAsyncSetup();
+}
+
+function panel(side: "source" | "target"): HTMLDivElement {
+ const color = side === "source" ? "blue" : "emerald";
+ return [...document.querySelectorAll("div")].find((element) => element.classList.contains(`border-${color}-500/35`))!;
+}
+
+function namespaceTriggers(side: "source" | "target") {
+ return [...panel(side).querySelectorAll("button.dbx-searchable-select-trigger")];
+}
+
+function swapButton() {
+ return [...document.querySelectorAll("button")].find((button) => button.title === i18n.global.t("diff.swap"))!;
+}
+
+async function chooseConnection(side: "source" | "target", id: string) {
+ panel(side).querySelector("button.dbx-diff-connection-trigger")!.click();
+ await flushAsyncSetup();
+ document.querySelector(`[data-picker-connection="${id}"]`)!.click();
+ await flushAsyncSetup();
+}
+
+async function chooseOption(trigger: HTMLButtonElement, value: string) {
+ trigger.click();
+ await flushAsyncSetup();
+ [...document.querySelectorAll(".dbx-searchable-select-list button")].find((button) => button.textContent?.trim() === value)!.click();
+ await flushAsyncSetup();
+}
+
+const stages = ["databases", "schemas", "tables"] as const;
+type Stage = (typeof stages)[number];
+
+async function beginMetadataLoad(side: "source" | "target", stage: Stage) {
+ if (stage === "databases") await chooseConnection(side, "pg-3");
+ else if (stage === "schemas") await chooseOption(namespaceTriggers(side)[0], side === "source" ? "reporting" : "app");
+ else await chooseOption(namespaceTriggers(side)[1], side === "source" ? "analytics" : "public");
+}
+
+function deferredMetadata(stage: Stage) {
+ const request = stage === "databases" ? mocks.listDatabases : stage === "schemas" ? mocks.listSchemas : mocks.listTables;
+ let resolve!: (value: unknown) => void;
+ let reject!: (error: Error) => void;
+ request.mockReturnValueOnce(
+ new Promise((onResolve, onReject) => {
+ resolve = onResolve;
+ reject = onReject;
+ }),
+ );
+ return {
+ resolve: () => resolve(stage === "databases" ? [{ name: "app" }] : stage === "schemas" ? ["public", "analytics"] : tables),
+ reject,
+ };
+}
+
+it.each(["source", "target"].flatMap((side) => stages.map((stage) => [side as "source" | "target", stage] as const)))("waits for pending %s %s before allowing swap", async (side, stage) => {
+ await mountLoadedDialog();
+ const pending = deferredMetadata(stage);
+ await beginMetadataLoad(side, stage);
+ expect(swapButton().disabled).toBe(true);
+ swapButton().click();
+ expect(panel(side).querySelector("button.dbx-diff-connection-trigger")!.title).toBe(stage === "databases" ? "PostgreSQL 3" : side === "source" ? "PostgreSQL 1" : "PostgreSQL 2");
+
+ pending.resolve();
+ await flushAsyncSetup();
+ expect(swapButton().disabled).toBe(false);
+ const previousDatabase = namespaceTriggers(side)[0].title;
+ expect(namespaceTriggers(side)[0].disabled).toBe(false);
+ swapButton().click();
+ await flushAsyncSetup();
+ const destination = side === "source" ? "target" : "source";
+ expect(namespaceTriggers(destination)[0].title).toBe(previousDatabase);
+ expect(namespaceTriggers(destination)[0].disabled).toBe(false);
+});
+
+it.each(stages)("releases the swap lock after a %s request fails", async (stage) => {
+ await mountLoadedDialog();
+ const pending = deferredMetadata(stage);
+ await beginMetadataLoad("source", stage);
+ expect(swapButton().disabled).toBe(true);
+ pending.reject(new Error("metadata unavailable"));
+ await flushAsyncSetup();
+ expect(swapButton().disabled).toBe(false);
+ expect(mocks.toast).toHaveBeenCalledWith("Error: metadata unavailable", 5000);
+});
+
+it("waits for both endpoints when their requests overlap", async () => {
+ await mountLoadedDialog();
+ const source = deferredMetadata("databases");
+ const target = deferredMetadata("databases");
+ await chooseConnection("source", "pg-3");
+ await chooseConnection("target", "pg-1");
+ source.resolve();
+ await flushAsyncSetup();
+ expect(swapButton().disabled).toBe(true);
+ target.resolve();
+ await flushAsyncSetup();
+ expect(swapButton().disabled).toBe(false);
+});
+
+it("preserves loaded databases, schemas and table selections after swap", async () => {
+ await mountLoadedDialog();
+ expect(swapButton().disabled).toBe(false);
+ swapButton().click();
+ await flushAsyncSetup();
+ expect(panel("source").querySelector("button.dbx-diff-connection-trigger")!.title).toBe("PostgreSQL 2");
+ expect(panel("target").querySelector("button.dbx-diff-connection-trigger")!.title).toBe("PostgreSQL 1");
+ expect(namespaceTriggers("source").map((button) => button.title)).toEqual(["reporting", "analytics"]);
+ expect(namespaceTriggers("target").map((button) => button.title)).toEqual(["app", "public", "orders"]);
+ expect(panel("source").querySelector('[data-table-name="invoices"] svg')?.classList.contains("text-primary")).toBe(true);
+ expect(panel("source").querySelector('[data-table-name="orders"] svg')?.classList.contains("text-primary")).toBe(false);
+ expect(mocks.listDatabases).not.toHaveBeenCalled();
+ expect(mocks.listSchemas).not.toHaveBeenCalled();
+ expect(mocks.listTables).not.toHaveBeenCalled();
+});
diff --git a/apps/desktop/src/components/diff/__tests__/SchemaDiffConfigStep.namespace.spec.ts b/apps/desktop/src/components/diff/__tests__/SchemaDiffConfigStep.namespace.spec.ts
index 5649de8b3e..be35de13a1 100644
--- a/apps/desktop/src/components/diff/__tests__/SchemaDiffConfigStep.namespace.spec.ts
+++ b/apps/desktop/src/components/diff/__tests__/SchemaDiffConfigStep.namespace.spec.ts
@@ -1,7 +1,7 @@
// @vitest-environment happy-dom
-import { createApp, defineComponent, h, nextTick, type App } from "vue";
-import { afterEach, expect, it, vi } from "vitest";
+import { createApp, defineComponent, h, nextTick, reactive, type App } from "vue";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
import i18n from "@/i18n";
import { getDefaultOptionsForDbType } from "@/types/schemaDiff";
import SchemaDiffConfigStep from "@/components/diff/SchemaDiffConfigStep.vue";
@@ -10,15 +10,17 @@ const mocks = vi.hoisted(() => ({
ensureConnected: vi.fn().mockResolvedValue(undefined),
listDatabases: vi.fn().mockResolvedValue([]),
listSchemas: vi.fn().mockResolvedValue(["APP", "REPORTING"]),
+ executeQuery: vi.fn().mockResolvedValue({ rows: [] }),
}));
vi.mock("@/stores/connectionStore", () => {
const connection = { id: "oracle-11g", name: "Oracle 11g", db_type: "oracle", driver_profile: "oracle", database: "XE" };
+ const connections = [connection, { id: "pg-1", name: "PostgreSQL 1", db_type: "postgres" }, { id: "pg-2", name: "PostgreSQL 2", db_type: "postgres" }];
return {
useConnectionStore: () => ({
- connections: [connection],
- sidebarLayout: { groups: [], order: [{ type: "connection", id: connection.id }] },
- getConfig: (id: string) => (id === connection.id ? connection : undefined),
+ connections,
+ sidebarLayout: { groups: [], order: connections.map(({ id }) => ({ type: "connection", id })) },
+ getConfig: (id: string) => connections.find((item) => item.id === id),
ensureConnected: mocks.ensureConnected,
}),
};
@@ -27,10 +29,63 @@ vi.mock("@/stores/connectionStore", () => {
vi.mock("@/lib/backend/api", () => ({
listDatabases: mocks.listDatabases,
listSchemas: mocks.listSchemas,
+ executeQuery: mocks.executeQuery,
}));
const mountedApps: App[] = [];
+beforeEach(() => {
+ mocks.ensureConnected.mockReset().mockResolvedValue(undefined);
+ mocks.listDatabases.mockReset().mockResolvedValue([]);
+ mocks.listSchemas.mockReset().mockResolvedValue(["APP", "REPORTING"]);
+ mocks.executeQuery.mockReset().mockResolvedValue({ rows: [] });
+});
+
+function mountPostgresEndpoint(side: "source" | "target") {
+ const endpoints = reactive({
+ sourceConnectionId: "",
+ sourceDatabase: "",
+ sourceSchema: "",
+ targetConnectionId: "",
+ targetDatabase: "",
+ targetSchema: "",
+ });
+ endpoints[`${side}ConnectionId`] = "pg-1";
+ endpoints[`${side}Database`] = "app";
+ endpoints[`${side}Schema`] = "public";
+ const container = document.createElement("div");
+ document.body.append(container);
+ const app = createApp(
+ defineComponent({
+ setup: () => () =>
+ h(SchemaDiffConfigStep, {
+ ...endpoints,
+ configs: [],
+ activeConfigId: "",
+ ignoreComments: false,
+ options: { ...getDefaultOptionsForDbType("postgres"), functions: false },
+ tableListLoader: { load: vi.fn().mockResolvedValue([]) },
+ loading: false,
+ recentConfigs: [],
+ "onUpdate:sourceSchema": (value: string) => {
+ endpoints.sourceSchema = value;
+ },
+ "onUpdate:targetSchema": (value: string) => {
+ endpoints.targetSchema = value;
+ },
+ }),
+ }),
+ );
+ mountedApps.push(app);
+ app.use(i18n);
+ app.mount(container);
+ return { endpoints, container };
+}
+
+function selectOptions() {
+ return [...document.querySelectorAll(".dbx-searchable-select-list button")];
+}
+
async function flushAsyncSetup() {
for (let index = 0; index < 8; index += 1) {
await nextTick();
@@ -82,3 +137,62 @@ it("offers Oracle schemas as schema-diff database choices", async () => {
expect(mocks.listDatabases).not.toHaveBeenCalled();
expect(mocks.listSchemas).toHaveBeenCalledWith("oracle-11g", "XE", true);
});
+
+it.each(["source", "target"] as const)("keeps pending %s database choices when the user selects another schema", async (side) => {
+ let resolveDatabases!: (value: Array<{ name: string }>) => void;
+ mocks.listDatabases.mockReturnValueOnce(
+ new Promise((resolve) => {
+ resolveDatabases = resolve;
+ }),
+ );
+ mocks.listSchemas.mockResolvedValue(["public", "analytics"]);
+ const { endpoints, container } = mountPostgresEndpoint(side);
+ await flushAsyncSetup();
+
+ const triggers = [...container.querySelectorAll("button.dbx-searchable-select-trigger")];
+ const database = triggers.find((button) => button.textContent?.trim() === "app")!;
+ const schema = triggers.find((button) => button.textContent?.trim() === "public")!;
+ expect(database.disabled).toBe(true);
+ expect(schema.disabled).toBe(false);
+ schema.click();
+ await flushAsyncSetup();
+ selectOptions()
+ .find((button) => button.textContent?.trim() === "analytics")!
+ .click();
+ await flushAsyncSetup();
+ expect(endpoints[`${side}Schema`]).toBe("analytics");
+
+ resolveDatabases([{ name: "app" }, { name: "reporting" }]);
+ await flushAsyncSetup();
+ expect(database.disabled).toBe(false);
+ database.click();
+ await flushAsyncSetup();
+ expect(selectOptions().map((button) => button.textContent?.trim())).toEqual(expect.arrayContaining(["app", "reporting"]));
+});
+
+it.each(["source", "target"] as const)("rejects stale %s database choices after switching away and back", async (side) => {
+ let resolveOldDatabases!: (value: Array<{ name: string }>) => void;
+ mocks.listDatabases
+ .mockReturnValueOnce(
+ new Promise((resolve) => {
+ resolveOldDatabases = resolve;
+ }),
+ )
+ .mockResolvedValue([{ name: "app" }]);
+ mocks.listSchemas.mockResolvedValue(["public", "analytics"]);
+ const { endpoints, container } = mountPostgresEndpoint(side);
+ await flushAsyncSetup();
+ endpoints[`${side}ConnectionId`] = "pg-2";
+ await flushAsyncSetup();
+ endpoints[`${side}ConnectionId`] = "pg-1";
+ await flushAsyncSetup();
+
+ resolveOldDatabases([{ name: "obsolete" }]);
+ await flushAsyncSetup();
+ const database = [...container.querySelectorAll("button.dbx-searchable-select-trigger")].find((button) => button.textContent?.trim() === "app")!;
+ expect(database.disabled).toBe(false);
+ database.click();
+ await flushAsyncSetup();
+ expect(selectOptions().map((button) => button.textContent?.trim())).toEqual(["app"]);
+ expect(mocks.listDatabases.mock.calls.map(([id]) => id)).toEqual(["pg-1", "pg-2", "pg-1"]);
+});
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 56fe6be645..eeb5e92376 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -7685,6 +7685,8 @@ export default {
serverVersion: "Server Version",
info: "Info",
connType: "Connection type",
+ allConnectionTypes: "All types",
+ unsupportedCompareConnection: "This connection is unavailable or does not support comparison. Please select another connection.",
connName: "Connection name",
host: "Host",
addHost: "Add Host",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index c0f694a151..f734942d16 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -6978,6 +6978,8 @@ export default withEnglishFallback({
serverVersion: "Versión del servidor",
info: "Información",
connType: "Tipo de conexión",
+ allConnectionTypes: "Todos los tipos",
+ unsupportedCompareConnection: "Esta conexión no está disponible o no admite comparaciones. Selecciona otra conexión.",
connName: "Nombre de conexión",
host: "Host",
addHost: "Añadir Host",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 21d2a216b9..0ca0da565c 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -6761,6 +6761,8 @@ export default withEnglishFallback({
serverVersion: "Versione Server",
info: "Info",
connType: "Tipo connessione",
+ allConnectionTypes: "Tutti i tipi",
+ unsupportedCompareConnection: "Questa connessione non è disponibile o non supporta il confronto. Seleziona un'altra connessione.",
connName: "Nome connessione",
host: "Host",
port: "Porta",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 61bd2acb58..2aee310871 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -6792,6 +6792,8 @@ export default withEnglishFallback({
restore: "復元",
info: "情報",
connType: "接続タイプ",
+ allConnectionTypes: "すべてのタイプ",
+ unsupportedCompareConnection: "この接続は利用できないか、比較に対応していません。別の接続を選択してください。",
connName: "接続名",
host: "ホスト",
port: "ポート",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index bb1bac8e94..4104a29430 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -6572,6 +6572,8 @@ export default withEnglishFallback({
serverVersion: "서버 버전",
info: "정보",
connType: "연결 유형",
+ allConnectionTypes: "모든 유형",
+ unsupportedCompareConnection: "이 연결은 사용할 수 없거나 비교를 지원하지 않습니다. 다른 연결을 선택하세요.",
connName: "연결 이름",
host: "호스트",
port: "포트",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 73b718f948..19a95e1453 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -6762,6 +6762,8 @@ export default withEnglishFallback({
serverVersion: "Versão do Servidor",
info: "Informações",
connType: "Tipo de conexão",
+ allConnectionTypes: "Todos os tipos",
+ unsupportedCompareConnection: "Esta conexão não está disponível ou não oferece suporte à comparação. Selecione outra conexão.",
connName: "Nome da conexão",
host: "Host",
port: "Porta",
diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts
index ac5ffed04c..5e3aa61df8 100644
--- a/apps/desktop/src/i18n/locales/ru.ts
+++ b/apps/desktop/src/i18n/locales/ru.ts
@@ -8008,6 +8008,8 @@ export default withEnglishFallback({
serverVersion: "Версия сервера",
info: "Информация",
connType: "Тип подключения",
+ allConnectionTypes: "Все типы",
+ unsupportedCompareConnection: "Это подключение недоступно или не поддерживает сравнение. Выберите другое подключение.",
connName: "Имя подключения",
host: "Хост",
addHost: "Добавить хост",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index c9c6bb1f12..59608d7f65 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -7598,6 +7598,8 @@ export default withEnglishFallback({
close: "关闭",
info: "信息",
connType: "连接类型",
+ allConnectionTypes: "全部类型",
+ unsupportedCompareConnection: "该连接不可用或不支持比较,请重新选择连接。",
connName: "连接名称",
host: "主机",
addHost: "添加主机",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index d9df6f7015..5e74bad07b 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -6096,6 +6096,8 @@ export default withEnglishFallback({
serverVersion: "伺服器版本",
info: "資訊",
connType: "連線類型",
+ allConnectionTypes: "全部類型",
+ unsupportedCompareConnection: "此連線無法使用或不支援比較,請重新選擇連線。",
connName: "連線名稱",
port: "連接埠",
saveConfigPrompt: "請輸入配置名稱:",
diff --git a/apps/desktop/src/lib/database/databaseCompareCapabilities.ts b/apps/desktop/src/lib/database/databaseCompareCapabilities.ts
new file mode 100644
index 0000000000..8e5ed12a40
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseCompareCapabilities.ts
@@ -0,0 +1,101 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { CONNECTION_PROFILES, type ConnectionProfileDefinition } from "@/types/generated/connectionProfiles";
+import { databaseManifestEntry } from "@/lib/database/databaseDriverManifest";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+
+export type DatabaseCompareMode = "schema" | "data";
+
+// Comparison loads relational metadata and, for data, generates COUNT/SELECT
+// statements. Unknown providers must opt in here rather than pass a blacklist.
+const SQL_COMPARE_TYPES = new Set([
+ "mysql",
+ "postgres",
+ "sqlite",
+ "rqlite",
+ "turso",
+ "cloudflare-d1",
+ "duckdb",
+ "clickhouse",
+ "sqlserver",
+ "oracle",
+ "doris",
+ "starrocks",
+ "manticoresearch",
+ "redshift",
+ "dameng",
+ "kingbase",
+ "highgo",
+ "uxdb",
+ "vastbase",
+ "goldendb",
+ "databend",
+ "gaussdb",
+ "kwdb",
+ "yashandb",
+ "databricks",
+ "saphana",
+ "teradata",
+ "vertica",
+ "firebird",
+ "exasol",
+ "opengauss",
+ "questdb",
+ "oceanbase-oracle",
+ "gbase",
+ "access",
+ "h2",
+ "snowflake",
+ "trino",
+ "prestosql",
+ "hive",
+ "argo",
+ "transwarp",
+ "kyuubi",
+ "impala",
+ "db2",
+ "informix",
+ "bigquery",
+ "spanner",
+ "kylin",
+ "ignite",
+ "ignite3",
+ "sundb",
+ "oscar",
+ "tdengine",
+ "xugu",
+ "iotdb",
+ "iris",
+ "influxdb3",
+ "spark",
+]);
+
+export function supportsDatabaseCompare(connection: ConnectionConfig | undefined, mode: DatabaseCompareMode): boolean {
+ if (!connection) return false;
+ const type = effectiveDatabaseTypeForConnection(connection);
+ // Keep the two paths explicit: a future driver may support metadata compare
+ // without supporting the generated data comparison SQL (or vice versa).
+ switch (mode) {
+ case "schema":
+ case "data":
+ return !!type && SQL_COMPARE_TYPES.has(type);
+ }
+}
+
+const profiles: Readonly> = CONNECTION_PROFILES;
+
+export function compareConnectionType(connection: ConnectionConfig): { value: string; label: string } {
+ const profile = connection.driver_profile;
+ const definition = profile ? profiles[profile] : undefined;
+ if (profile && definition && definition.type === connection.db_type) {
+ return { value: profile, label: definition.label };
+ }
+ // JDBC remains a distinct connection type, with a product-specific profile
+ // when present. Native legacy configs without a profile fall back to db_type.
+ if (connection.db_type === "jdbc" && profile) {
+ return {
+ value: `jdbc:${profile}`,
+ label: connection.driver_label || `${databaseManifestEntry(effectiveDatabaseTypeForConnection(connection))?.label || profile} (JDBC)`,
+ };
+ }
+ return { value: connection.db_type, label: databaseManifestEntry(connection.db_type)?.label || connection.driver_label || connection.db_type };
+}