Skip to content

armgit / dbx

Public Imported from GitHub
0

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

fix(doris,import): allow update-existing imports on unique-key tables

lxk955f04ceabac685
diff --git a/apps/desktop/src/components/import/TableImportDialog.vue b/apps/desktop/src/components/import/TableImportDialog.vue
index 4418497351..08b5f398e5 100644
--- a/apps/desktop/src/components/import/TableImportDialog.vue
+++ b/apps/desktop/src/components/import/TableImportDialog.vue
@@ -223,11 +223,17 @@ const mappedColumns = computed<api.TableImportColumnMapping[]>(() => {
});
const mappedCount = computed(() => mappedColumns.value.length);
const mappingValidation = computed(() => validateImportMappings(mappedColumns.value));
-const primaryKeyColumns = computed(() => targetColumns.value.filter((column) => column.is_primary_key));
-const updateExistingUnavailableReason = computed(() => {
+const isUniqueKeyModelDatabase = computed(() => structureDatabaseType.value === "doris" || structureDatabaseType.value === "starrocks");
+const primaryKeyColumns = computed(() => targetColumns.value.filter((column) => column.is_primary_key || (isUniqueKeyModelDatabase.value && column.is_unique)));
+const updateExistingDisabledReason = computed(() => {
if (targetMode.value !== "existing") return t("tableImport.updateExistingRequiresExistingTable");
if (!supportsImportConflictPolicy.value) return t("tableImport.updateExistingUnsupportedDialect");
if (!existingTargetMetadataReady.value || primaryKeyColumns.value.length === 0) return t("tableImport.updateExistingRequiresPrimaryKey");
+ return "";
+});
+const canSelectUpdateExisting = computed(() => updateExistingDisabledReason.value === "");
+const updateExistingMappingError = computed(() => {
+ if (targetMode.value !== "existing" || conflictPolicy.value !== "updateExisting") return "";
const mappedTargets = mappedColumns.value.map((mapping) => mapping.targetColumn.toLowerCase());
const missingKeys = primaryKeyColumns.value.filter((column) => !mappedTargets.includes(column.name.toLowerCase()));
if (missingKeys.length > 0) return t("tableImport.updateExistingRequiresMappedPrimaryKey", { columns: missingKeys.map((column) => column.name).join(", ") });
@@ -235,8 +241,7 @@ const updateExistingUnavailableReason = computed(() => {
if (!mappedTargets.some((column) => !primaryKeyNames.includes(column))) return t("tableImport.updateExistingRequiresMappedValue");
return "";
});
-const canUpdateExistingRows = computed(() => updateExistingUnavailableReason.value === "");
-const conflictPolicyError = computed(() => (conflictPolicy.value === "updateExisting" ? updateExistingUnavailableReason.value : ""));
+const conflictPolicyError = computed(() => (conflictPolicy.value === "updateExisting" ? updateExistingDisabledReason.value || updateExistingMappingError.value : ""));
const requiredUnmappedColumns = computed(() =>
requiredImportTargetColumns(
targetColumns.value,
@@ -1712,12 +1717,12 @@ watch(rawProgressPercent, (percent) => {
<select id="table-import-conflict-policy" v-model="conflictPolicy" data-testid="table-import-conflict-policy" class="flex h-8 w-full rounded-md border border-input bg-background text-foreground px-2 text-xs [color-scheme:light] dark:[color-scheme:dark]">
<option value="error" class="bg-popover text-popover-foreground">{{ t("tableImport.conflictError") }}</option>
<option value="skip" class="bg-popover text-popover-foreground">{{ t("tableImport.skipDuplicateRows") }}</option>
- <option v-if="targetMode === 'existing'" value="updateExisting" :disabled="!canUpdateExistingRows" class="bg-popover text-popover-foreground">
+ <option v-if="targetMode === 'existing'" value="updateExisting" :disabled="!canSelectUpdateExisting" class="bg-popover text-popover-foreground">
{{ t("tableImport.updateExistingRows") }}
</option>
</select>
- <p v-if="targetMode === 'existing' && !canUpdateExistingRows" class="text-[11px] text-muted-foreground">
- {{ updateExistingUnavailableReason }}
+ <p v-if="targetMode === 'existing' && !canSelectUpdateExisting" class="text-[11px] text-muted-foreground">
+ {{ updateExistingDisabledReason }}
</p>
</div>
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 047a35fa0c..7c45da71ac 100644
--- a/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
+++ b/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
@@ -38,6 +38,7 @@ vi.mock("@/stores/connectionStore", () => ({
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" };
+ if (id === "doris-1") return { id, name: "Doris", db_type: "doris" };
return undefined;
},
ensureConnected: mocks.ensureConnected,
@@ -469,6 +470,110 @@ describe("TableImportDialog existing targets", () => {
expect(document.body.textContent).toContain("requires primary-key metadata");
});
+ it("recognizes Doris unique-key columns as primary keys for update-existing", async () => {
+ mocks.getColumns.mockResolvedValueOnce([
+ { name: "id", data_type: "BIGINT", nullable: false, is_primary_key: false, is_unique: true },
+ { name: "name", data_type: "VARCHAR", nullable: true, is_primary_key: false, is_unique: false },
+ ]);
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "doris-1", database: "analytics" });
+ await selectWorkbook();
+ buttonContaining("Existing table")?.click();
+ await flushAsyncUpdates();
+ await selectExistingTarget("existing_target");
+ await vi.waitFor(() => expect(buttonContaining("Next")?.disabled).toBe(false));
+
+ const policySelect = document.body.querySelector<HTMLSelectElement>('[data-testid="table-import-conflict-policy"]');
+ expect(policySelect).toBeTruthy();
+ const updateOption = policySelect?.querySelector<HTMLOptionElement>('option[value="updateExisting"]');
+ await vi.waitFor(() => expect(updateOption?.disabled, document.body.textContent || "").toBe(false));
+ if (policySelect) {
+ policySelect.value = "updateExisting";
+ policySelect.dispatchEvent(new Event("change", { 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: "doris-1",
+ conflictPolicy: "updateExisting",
+ skipDuplicateRows: false,
+ }),
+ expect.any(Function),
+ );
+ });
+
+ it("allows selecting update-existing on options step when target has keys even if preview columns are initially unmapped, and guards mapping step", async () => {
+ mocks.previewTableImportFile.mockResolvedValueOnce({
+ fileName: "unmapped.xlsx",
+ filePath: "/tmp/unmapped.xlsx",
+ fileType: "excel",
+ sizeBytes: 24,
+ columns: ["other_code", "name"],
+ rows: [[1, "Alice"]],
+ totalRows: 1,
+ sourceFingerprint: "unmapped-xlsx",
+ sheets: ["Data"],
+ });
+ i18n.global.locale.value = "en";
+ await mountDialog({ connectionId: "doris-1", database: "analytics" });
+ await selectWorkbook();
+ buttonContaining("Existing table")?.click();
+ await flushAsyncUpdates();
+ await selectExistingTarget("existing_target");
+ await vi.waitFor(() => expect(buttonContaining("Next")?.disabled).toBe(false));
+
+ const policySelect = document.body.querySelector<HTMLSelectElement>('[data-testid="table-import-conflict-policy"]');
+ expect(policySelect).toBeTruthy();
+ const updateOption = policySelect?.querySelector<HTMLOptionElement>('option[value="updateExisting"]');
+ // On options step, the option is enabled because target table has unique/primary key
+ expect(updateOption?.disabled).toBe(false);
+ if (policySelect) {
+ policySelect.value = "updateExisting";
+ policySelect.dispatchEvent(new Event("change", { bubbles: true }));
+ }
+ await flushAsyncUpdates();
+
+ buttonContaining("Next")?.click();
+ await flushAsyncUpdates();
+
+ // Now in mapping step: column mapping hasn't mapped the primary key yet,
+ // so error is displayed and proceeding is guarded
+ expect(document.body.textContent).toContain("Map every primary-key column to update conflicts. Missing: id");
+ expect(buttonContaining("Next")?.disabled).toBe(true);
+
+ // Map other_code -> id
+ const mappings = Array.from(document.body.querySelectorAll<HTMLSelectElement>("select"));
+ if (mappings[0]) {
+ mappings[0].value = "id";
+ mappings[0].dispatchEvent(new Event("change", { bubbles: true }));
+ }
+ await flushAsyncUpdates();
+
+ // Now mapping is valid, so Next becomes enabled
+ expect(buttonContaining("Next")?.disabled).toBe(false);
+ buttonContaining("Next")?.click();
+ await flushAsyncUpdates();
+ buttonContaining("Start Import")?.click();
+ await flushAsyncUpdates();
+
+ expect(mocks.importTableFile).toHaveBeenCalledWith(
+ expect.objectContaining({
+ connectionId: "doris-1",
+ conflictPolicy: "updateExisting",
+ skipDuplicateRows: false,
+ }),
+ expect.any(Function),
+ );
+ });
+
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" });
diff --git a/crates/dbx-core/src/data/table_import.rs b/crates/dbx-core/src/data/table_import.rs
index ae1893ece2..416954d074 100644
--- a/crates/dbx-core/src/data/table_import.rs
+++ b/crates/dbx-core/src/data/table_import.rs
@@ -346,12 +346,17 @@ fn update_existing_primary_key_columns(
conflict_policy: TableImportConflictPolicy,
mappings: &[TableImportColumnMapping],
target_columns: &[crate::db::ColumnInfo],
+ db_type: &DatabaseType,
) -> Result<Vec<String>, String> {
if conflict_policy != TableImportConflictPolicy::UpdateExisting {
return Ok(Vec::new());
}
- let primary_key_columns = target_columns.iter().filter(|column| column.is_primary_key).collect::<Vec<_>>();
+ let uses_unique_key_model = matches!(db_type, DatabaseType::Doris | DatabaseType::StarRocks);
+ let primary_key_columns = target_columns
+ .iter()
+ .filter(|column| column.is_primary_key || (uses_unique_key_model && column.is_unique))
+ .collect::<Vec<_>>();
if primary_key_columns.is_empty() {
return Err("Update-existing import requires target primary-key metadata".to_string());
}
@@ -7345,7 +7350,7 @@ where
Err(_) => Vec::new(),
};
let primary_key_columns =
- match update_existing_primary_key_columns(conflict_policy, &request.mappings, &target_columns) {
+ match update_existing_primary_key_columns(conflict_policy, &request.mappings, &target_columns, db_type) {
Ok(columns) => columns,
Err(error) => {
return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
@@ -8601,19 +8606,59 @@ mod tests {
crate::db::ColumnInfo { name: "name".to_string(), ..Default::default() },
];
- let missing_key =
- update_existing_primary_key_columns(TableImportConflictPolicy::UpdateExisting, &mappings, &target_columns)
- .unwrap_err();
+ let missing_key = update_existing_primary_key_columns(
+ TableImportConflictPolicy::UpdateExisting,
+ &mappings,
+ &target_columns,
+ &DatabaseType::Postgres,
+ )
+ .unwrap_err();
assert!(missing_key.contains("id"));
let missing_metadata = update_existing_primary_key_columns(
TableImportConflictPolicy::UpdateExisting,
&mappings,
&[crate::db::ColumnInfo { name: "name".to_string(), ..Default::default() }],
+ &DatabaseType::Postgres,
)
.unwrap_err();
assert!(missing_metadata.contains("primary-key metadata"));
+ let doris_unique_columns = vec![
+ crate::db::ColumnInfo {
+ name: "id".to_string(),
+ is_unique: true,
+ is_primary_key: false,
+ ..Default::default()
+ },
+ crate::db::ColumnInfo { name: "name".to_string(), ..Default::default() },
+ ];
+ // The Doris unique-key column still has to be mapped, like any key column —
+ // only the key discovery itself differs (is_unique instead of is_primary_key).
+ let mut doris_mappings = mappings.clone();
+ doris_mappings.push(TableImportColumnMapping {
+ source_column: "uid".to_string(),
+ target_column: "id".to_string(),
+ target_data_type: None,
+ });
+ let doris_keys = update_existing_primary_key_columns(
+ TableImportConflictPolicy::UpdateExisting,
+ &doris_mappings,
+ &doris_unique_columns,
+ &DatabaseType::Doris,
+ )
+ .expect("Doris unique key column should qualify as an update-existing key");
+ assert_eq!(doris_keys, vec!["id"]);
+
+ let mysql_without_pk = update_existing_primary_key_columns(
+ TableImportConflictPolicy::UpdateExisting,
+ &mappings,
+ &doris_unique_columns,
+ &DatabaseType::Mysql,
+ )
+ .unwrap_err();
+ assert!(mysql_without_pk.contains("primary-key metadata"));
+
let unsupported =
validate_update_existing_target(TableImportConflictPolicy::UpdateExisting, &DatabaseType::Oracle, false)
.unwrap_err();