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(import): allow schema selection for target table

lxk95574960d9fc8bf
diff --git a/apps/desktop/src/components/import/TableImportDialog.vue b/apps/desktop/src/components/import/TableImportDialog.vue
index 3715ce3202..a7fee97c32 100644
--- a/apps/desktop/src/components/import/TableImportDialog.vue
+++ b/apps/desktop/src/components/import/TableImportDialog.vue
@@ -32,6 +32,8 @@ import {
import { importPreviewInput, importSourceDisplayName, uploadedImportSourceFromPreview } from "@/lib/import/importSource";
import { getDataTypeOptions } from "@/lib/table/tableStructureEditorState";
import { metadataSchemaForConnection, tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { isSchemaAware } from "@/lib/database/databaseFeatureSupport";
+import { schemaOptionsForConnection } from "@/composables/useSchemaOptions";
import type { ColumnInfo, DatabaseType } from "@/types/database";
import * as api from "@/lib/backend/api";
@@ -185,7 +187,21 @@ const importFileExtensions = computed(() => ["csv", "tsv", "txt", "json", "xlsx"
// ordinary INSERT/error behavior instead of approximating an upsert.
const IMPORT_CONFLICT_DATABASE_TYPES = new Set<DatabaseType>(["postgres", "kingbase", "opengauss", "sqlite", "cloudflare-d1", "duckdb", "mysql", "doris", "starrocks"]);
const supportsImportConflictPolicy = computed(() => structureDatabaseType.value !== undefined && IMPORT_CONFLICT_DATABASE_TYPES.has(structureDatabaseType.value));
-const targetSchema = computed(() => metadataSchemaForConnection(selectedConnection.value, props.prefillDatabase || "", props.prefillSchema));
+function defaultInitialSchema() {
+ if (props.prefillSchema !== undefined) return props.prefillSchema;
+ return metadataSchemaForConnection(selectedConnection.value, props.prefillDatabase || "", props.prefillSchema) || "";
+}
+
+const isSchemaCapable = computed(() => isSchemaAware(structureDatabaseType.value));
+const showSchemaSelector = computed(() => isSchemaCapable.value && !!props.prefillConnectionId);
+const selectedSchema = ref(defaultInitialSchema());
+const schemaOptions = ref<string[]>([]);
+const loadingSchemas = ref(false);
+let schemaOptionsRequestId = 0;
+const targetSchema = computed(() => {
+ if (selectedSchema.value) return selectedSchema.value;
+ return metadataSchemaForConnection(selectedConnection.value, props.prefillDatabase || "", props.prefillSchema) || "";
+});
const dataTypeOptions = computed(() => mergeDataTypeOptions(dynamicDataTypeOptions.value, getDataTypeOptions(structureDatabaseType.value), Object.values(columnDataTypes.value)));
const hasExistingTarget = computed(() => !!props.prefillTable || loadingExistingTables.value || existingTableNames.value.length > 0);
const targetTableName = computed(() => (targetMode.value === "create" ? newTableName.value.trim() : selectedExistingTable.value));
@@ -258,7 +274,10 @@ const progressPercentFloor = ref(0);
const progressPercent = computed(() => Math.max(rawProgressPercent.value, progressPercentFloor.value));
const currentStepIndex = computed(() => wizardSteps.findIndex((step) => step.value === wizardStep.value));
const targetLabel = computed(() => {
- const pieces = [selectedConnection.value?.name, props.prefillDatabase, props.prefillSchema, targetTableName.value].filter(Boolean);
+ // Database-as-schema engines (MySQL/SQLite family) resolve targetSchema to
+ // the database name; keep it out of the label so it does not render twice.
+ const schemaPiece = targetSchema.value && targetSchema.value !== props.prefillDatabase ? targetSchema.value : "";
+ const pieces = [selectedConnection.value?.name, props.prefillDatabase, schemaPiece, targetTableName.value].filter(Boolean);
return pieces.join(" / ");
});
const selectedSourceName = computed(() => {
@@ -383,6 +402,10 @@ function resetState() {
batchEncodingRequestId++;
existingTablesRequestId++;
targetColumnsRequestId++;
+ schemaOptionsRequestId++;
+ schemaOptions.value = [];
+ loadingSchemas.value = false;
+ selectedSchema.value = defaultInitialSchema();
if (previewReloadTimer) {
clearTimeout(previewReloadTimer);
previewReloadTimer = null;
@@ -622,8 +645,60 @@ async function loadDataTypeOptions() {
}
}
-async function loadExistingTables() {
- if (props.prefillTable || loadingExistingTables.value || existingTableNames.value.length || !props.prefillConnectionId || !props.prefillDatabase) return;
+async function loadSchemaOptions() {
+ const connectionId = props.prefillConnectionId;
+ const database = props.prefillDatabase || "";
+ if (!connectionId || !isSchemaCapable.value) {
+ schemaOptions.value = [];
+ loadingSchemas.value = false;
+ return;
+ }
+ const requestId = ++schemaOptionsRequestId;
+ loadingSchemas.value = true;
+ try {
+ await store.ensureConnected(connectionId);
+ const rawSchemas = await api.listSchemas(connectionId, database);
+ if (requestId !== schemaOptionsRequestId) return;
+ const filtered = schemaOptionsForConnection(rawSchemas, selectedConnection.value, database);
+ const active = selectedSchema.value || targetSchema.value;
+ if (active && !filtered.includes(active)) {
+ schemaOptions.value = [active, ...filtered];
+ } else {
+ schemaOptions.value = filtered;
+ }
+ } catch {
+ if (requestId === schemaOptionsRequestId) {
+ const active = selectedSchema.value || targetSchema.value;
+ schemaOptions.value = active ? [active] : [];
+ }
+ } finally {
+ if (requestId === schemaOptionsRequestId) {
+ loadingSchemas.value = false;
+ }
+ }
+}
+
+function handleSchemaChange(newSchema: string) {
+ const trimmed = newSchema.trim();
+ if (selectedSchema.value === trimmed) return;
+ selectedSchema.value = trimmed;
+ if (trimmed && !schemaOptions.value.includes(trimmed)) {
+ schemaOptions.value = [trimmed, ...schemaOptions.value];
+ }
+ existingTableNames.value = [];
+ selectedExistingTable.value = "";
+ targetColumns.value = [];
+ loadedTargetTableName.value = "";
+ if (targetMode.value === "existing") {
+ columnMapping.value = {};
+ }
+ if (targetMode.value === "existing" || wizardStep.value === "options") {
+ void loadExistingTables(true);
+ }
+}
+
+async function loadExistingTables(force = false) {
+ if (props.prefillTable || (!force && (loadingExistingTables.value || existingTableNames.value.length > 0)) || !props.prefillConnectionId || !props.prefillDatabase) return;
const requestId = ++existingTablesRequestId;
loadingExistingTables.value = true;
errorMessage.value = "";
@@ -994,9 +1069,9 @@ async function startImport() {
);
progress.value = { importId: summary.importId, status: "done", rowsImported: summary.rowsImported, totalRows: summary.totalRows, elapsedMs: summary.elapsedMs };
toast(t("tableImport.success", { count: summary.rowsImported }), 2500);
- store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined, tableName);
+ store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", targetSchema.value || undefined, tableName);
if (targetMode.value === "create") {
- store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined).catch((error) => {
+ store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", targetSchema.value || undefined).catch((error) => {
console.warn("[DBX][table-import:refresh-created-table-failed]", error);
});
}
@@ -1102,12 +1177,12 @@ async function startBatchImport() {
task.rowsImported = summary.rowsImported;
completedRows += summary.rowsImported;
completedBytes += task.preview.sizeBytes;
- store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined, task.tableName);
+ store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", targetSchema.value || undefined, task.tableName);
}
refreshImportElapsedClock();
progress.value = { importId: importId.value, status: "done", phase: "done", rowsImported: completedRows, totalRows: completedRows, totalRowsExact: true, bytesRead: totalBytes, totalBytes, elapsedMs: liveElapsedMs.value };
toast(t("tableImport.success", { count: completedRows }), 2500);
- store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined).catch((error) => {
+ store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", targetSchema.value || undefined).catch((error) => {
console.warn("[DBX][table-import:refresh-created-table-failed]", error);
});
} catch (e: any) {
@@ -1212,6 +1287,7 @@ watch(
(value) => {
if (value) {
resetState();
+ if (showSchemaSelector.value) void loadSchemaOptions();
void loadTargetColumns();
void loadDataTypeOptions();
} else {
@@ -1231,12 +1307,16 @@ watch([textEncoding, decimalSeparator], schedulePreviewReloadAfterEncodingChange
watch([newTableName, columnMapping, columnDataTypes], saveActiveBatchTask, { deep: true });
watch(wizardStep, (step) => {
if (step !== "mapping") closeDataTypePicker();
- if (step === "options") void loadExistingTables();
+ if (step === "options") {
+ if (showSchemaSelector.value) void loadSchemaOptions();
+ void loadExistingTables();
+ }
});
watch(targetMode, (mode) => {
if (mode === "existing") {
columnDataTypes.value = {};
dynamicDataTypeOptions.value = [];
+ if (!existingTableNames.value.length) void loadExistingTables();
void loadTargetColumns();
} else {
targetColumnsRequestId++;
@@ -1402,7 +1482,7 @@ watch(rawProgressPercent, (percent) => {
</div>
</div>
- <div class="grid grid-cols-[minmax(0,1fr)_minmax(220px,320px)] gap-3 rounded-md border p-3">
+ <div class="grid gap-3 rounded-md border p-3" :class="showSchemaSelector ? 'grid-cols-1 md:grid-cols-[minmax(0,1.2fr)_minmax(140px,1fr)_minmax(180px,1.2fr)]' : 'grid-cols-[minmax(0,1fr)_minmax(220px,320px)]'">
<div class="space-y-1.5">
<Label class="text-xs">{{ t("tableImport.targetMode") }}</Label>
<div class="grid grid-cols-2 gap-2">
@@ -1416,6 +1496,31 @@ watch(rawProgressPercent, (percent) => {
</button>
</div>
</div>
+ <div v-if="showSchemaSelector" class="space-y-1.5">
+ <Label class="text-xs">{{ t("transfer.targetSchema") }}</Label>
+ <div v-if="props.prefillTable" class="flex h-8 items-center rounded-md border px-2 text-xs font-mono">
+ <span class="truncate">{{ targetSchema || props.prefillSchema || "-" }}</span>
+ </div>
+ <SearchableSelect
+ v-else
+ data-testid="target-schema-select"
+ :model-value="selectedSchema"
+ :options="schemaOptions.length ? schemaOptions : selectedSchema ? [selectedSchema] : []"
+ :placeholder="t('transfer.selectSchema')"
+ :search-placeholder="t('transfer.searchSchema')"
+ :empty-text="t('common.noResults')"
+ :loading-text="t('common.loading')"
+ :loading="loadingSchemas"
+ :allow-custom="true"
+ trigger-class="h-8 font-mono text-xs"
+ @update:model-value="handleSchemaChange"
+ @update:open="
+ (isOpen) => {
+ if (isOpen) void loadSchemaOptions();
+ }
+ "
+ />
+ </div>
<div class="space-y-1.5">
<Label class="text-xs">{{ t("tableImport.targetTableName") }}</Label>
<Input v-if="targetMode === 'create'" v-model="newTableName" class="h-8 text-xs font-mono" />
@@ -1424,6 +1529,7 @@ watch(rawProgressPercent, (percent) => {
</div>
<SearchableSelect
v-else
+ data-testid="target-table-select"
:model-value="selectedExistingTable"
:options="existingTableNames"
:placeholder="t('tableImport.noExistingTarget')"
diff --git a/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts b/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
index cb2b7776ed..7186fa018c 100644
--- a/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
+++ b/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
@@ -7,6 +7,7 @@ import type { TableImportProgress, TableImportRequest, TableImportSummary } from
const mocks = vi.hoisted(() => ({
ensureConnected: vi.fn().mockResolvedValue(undefined),
+ listSchemas: vi.fn().mockResolvedValue(["dbo", "sales", "analytics"]),
listTables: vi.fn().mockResolvedValue([
{ name: "existing_target", table_type: "TABLE" },
{ name: "archived_target", table_type: "TABLE" },
@@ -36,6 +37,7 @@ vi.mock("@/stores/connectionStore", () => ({
getConfig: (id: string) => {
if (id === "connection-1") return { id, name: "SQLite", db_type: "sqlite" };
if (id === "postgres-1") return { id, name: "PostgreSQL", db_type: "postgres" };
+ if (id === "sqlserver-1") return { id, name: "SQL Server", db_type: "sqlserver" };
return undefined;
},
ensureConnected: mocks.ensureConnected,
@@ -49,6 +51,7 @@ vi.mock("@/stores/settingsStore", () => ({
}));
vi.mock("@/lib/backend/api", () => ({
+ listSchemas: mocks.listSchemas,
listTables: mocks.listTables,
getColumns: mocks.getColumns,
listDataTypes: mocks.listDataTypes,
@@ -146,12 +149,13 @@ vi.mock("@/components/ui/searchable-select", async () => {
disabled: Boolean,
},
emits: ["update:modelValue"],
- setup(props, { emit }) {
+ setup(props, { attrs, emit }) {
return () =>
h(
"select",
{
- class: "existing-table-select-stub",
+ ...attrs,
+ class: attrs["data-testid"] === "target-schema-select" ? "existing-schema-select-stub" : "existing-table-select-stub",
value: props.modelValue,
disabled: props.disabled,
onChange: (event: Event) => emit("update:modelValue", (event.target as HTMLSelectElement).value),
@@ -228,12 +232,24 @@ async function selectExistingTarget(tableName: string) {
await nextTick();
}
+async function selectSchemaTarget(schemaName: string) {
+ const schemaSelect = document.body.querySelector<HTMLSelectElement>("select.existing-schema-select-stub");
+ expect(schemaSelect).toBeTruthy();
+ if (schemaSelect) {
+ schemaSelect.value = schemaName;
+ schemaSelect.dispatchEvent(new Event("change", { bubbles: true }));
+ }
+ await nextTick();
+ await flushAsyncUpdates();
+}
+
function buttonContaining(text: string) {
return [...document.body.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes(text));
}
beforeEach(() => {
mocks.ensureConnected.mockReset().mockResolvedValue(undefined);
+ mocks.listSchemas.mockReset().mockResolvedValue(["dbo", "sales", "analytics"]);
mocks.listTables.mockReset().mockResolvedValue([
{ name: "existing_target", table_type: "TABLE" },
{ name: "archived_target", table_type: "TABLE" },
@@ -452,4 +468,114 @@ describe("TableImportDialog existing targets", () => {
expect(updateOption?.disabled).toBe(true);
expect(document.body.textContent).toContain("requires primary-key metadata");
});
+
+ it("allows selecting target schema on schema-aware databases and reloads tables", async () => {
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "sqlserver-1", database: "mydb" });
+ await selectWorkbook();
+
+ await vi.waitFor(() => {
+ expect(mocks.listSchemas).toHaveBeenCalledWith("sqlserver-1", "mydb");
+ expect(mocks.listTables).toHaveBeenCalledWith("sqlserver-1", "mydb", "dbo", undefined, undefined, undefined, ["TABLE"]);
+ });
+
+ const schemaSelect = document.body.querySelector<HTMLSelectElement>("select.existing-schema-select-stub");
+ expect(schemaSelect).toBeTruthy();
+ expect(schemaSelect?.value).toBe("dbo");
+
+ mocks.listTables.mockClear();
+ mocks.listTables.mockResolvedValueOnce([{ name: "sales_orders", table_type: "TABLE" }]);
+
+ await selectSchemaTarget("sales");
+
+ await vi.waitFor(() => {
+ expect(mocks.listTables).toHaveBeenCalledWith("sqlserver-1", "mydb", "sales", undefined, undefined, undefined, ["TABLE"]);
+ });
+
+ buttonContaining("Existing table")?.click();
+ await flushAsyncUpdates();
+ await selectExistingTarget("sales_orders");
+
+ await vi.waitFor(() => {
+ expect(mocks.getColumns).toHaveBeenCalledWith("sqlserver-1", "mydb", "sales", "sales_orders");
+ expect(buttonContaining("Next")?.disabled).toBe(false);
+ });
+
+ buttonContaining("Next")?.click();
+ await flushAsyncUpdates();
+ buttonContaining("Next")?.click();
+ await flushAsyncUpdates();
+ buttonContaining("Start Import")?.click();
+ await flushAsyncUpdates();
+
+ expect(mocks.importTableFile).toHaveBeenCalledWith(
+ expect.objectContaining({
+ connectionId: "sqlserver-1",
+ database: "mydb",
+ schema: "sales",
+ table: "sales_orders",
+ }),
+ expect.any(Function),
+ );
+ });
+
+ it("uses the selected schema when creating a new table on a schema-aware database", async () => {
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "sqlserver-1", database: "mydb" });
+ await selectWorkbook();
+
+ await vi.waitFor(() => expect(mocks.listSchemas).toHaveBeenCalledWith("sqlserver-1", "mydb"));
+
+ await selectSchemaTarget("analytics");
+
+ const tableNameInput = document.body.querySelector<HTMLInputElement>("input.font-mono");
+ expect(tableNameInput).toBeTruthy();
+ tableNameInput!.value = "analytics_summary";
+ tableNameInput!.dispatchEvent(new Event("input", { bubbles: true }));
+ await flushAsyncUpdates();
+
+ buttonContaining("Next")?.click();
+ await flushAsyncUpdates();
+ buttonContaining("Next")?.click();
+ await flushAsyncUpdates();
+ buttonContaining("Start Import")?.click();
+ await flushAsyncUpdates();
+
+ expect(mocks.importTableFile).toHaveBeenCalledWith(
+ expect.objectContaining({
+ connectionId: "sqlserver-1",
+ database: "mydb",
+ schema: "analytics",
+ table: "analytics_summary",
+ createTable: true,
+ }),
+ expect.any(Function),
+ );
+ });
+
+ it("renders read-only schema when prefillTable is provided on schema-aware connection", async () => {
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "sqlserver-1", database: "mydb", schema: "sales", prefillTable: "existing_target" });
+ await selectWorkbook();
+
+ expect(document.body.querySelector("select.existing-schema-select-stub")).toBeNull();
+ expect(document.body.textContent).toContain("sales");
+ });
+
+ it("does not render schema selector for non-schema-aware connections", async () => {
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "connection-1", database: "main" });
+ await selectWorkbook();
+
+ expect(document.body.querySelector("select.existing-schema-select-stub")).toBeNull();
+ });
+
+ it("does not repeat the database as schema in the target label", async () => {
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "connection-1", database: "main", prefillTable: "existing_target" });
+ await selectWorkbook();
+
+ expect(document.body.textContent).toContain("SQLite / main / existing_target");
+ expect(document.body.textContent).not.toContain("main / main");
+ });
});