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): recognize composite unique keys as table row identifiers

lxk955b8ebd65ddf1e
diff --git a/apps/desktop/src/components/import/TableImportDialog.vue b/apps/desktop/src/components/import/TableImportDialog.vue
index 8f2117235e..d6084253c2 100644
--- a/apps/desktop/src/components/import/TableImportDialog.vue
+++ b/apps/desktop/src/components/import/TableImportDialog.vue
@@ -32,6 +32,7 @@ import {
} from "@/lib/table/tableImport";
import { importPreviewInput, importSourceDisplayName, uploadedImportSourceFromPreview } from "@/lib/import/importSource";
import { getDataTypeOptions } from "@/lib/table/tableStructureEditorState";
+import { editableRowIdentifierColumns } from "@/lib/table/tableEditing";
import { metadataSchemaForConnection, tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
import { isSchemaAware } from "@/lib/database/databaseFeatureSupport";
import { schemaOptionsForConnection } from "@/composables/useSchemaOptions";
@@ -759,8 +760,28 @@ async function loadTargetColumns() {
errorMessage.value = "";
try {
await store.ensureConnected(props.prefillConnectionId);
- const columns = await withTimeout(api.getColumns(props.prefillConnectionId, props.prefillDatabase, targetSchema.value, tableName), TARGET_COLUMNS_TIMEOUT_MS);
+ const columnsPromise = withTimeout(api.getColumns(props.prefillConnectionId, props.prefillDatabase, targetSchema.value, tableName), TARGET_COLUMNS_TIMEOUT_MS);
+ const indexesPromise =
+ isUniqueKeyModelDatabase.value && typeof api.listIndexes === "function"
+ ? withTimeout(
+ api.listIndexes(props.prefillConnectionId, props.prefillDatabase, targetSchema.value || "", tableName).catch(() => []),
+ TARGET_COLUMNS_TIMEOUT_MS,
+ )
+ : Promise.resolve([]);
+ const [columns, indexes] = await Promise.all([columnsPromise, indexesPromise]);
if (requestId !== targetColumnsRequestId) return;
+ if (isUniqueKeyModelDatabase.value && indexes.length > 0) {
+ const keyCols = editableRowIdentifierColumns(structureDatabaseType.value, columns, indexes);
+ if (keyCols.length > 0) {
+ const keySet = new Set(keyCols.map((c) => c.toLowerCase()));
+ for (const col of columns) {
+ if (keySet.has(col.name.toLowerCase())) {
+ col.is_unique = true;
+ col.is_primary_key = true;
+ }
+ }
+ }
+ }
targetColumns.value = columns;
loadedTargetTableName.value = tableName;
applyAutoMapping();
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 274b9afa3a..1a5cfdee48 100644
--- a/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
+++ b/apps/desktop/src/components/import/__tests__/TableImportDialog.existingTarget.spec.ts
@@ -16,6 +16,7 @@ const mocks = vi.hoisted(() => ({
{ name: "id", data_type: "INTEGER", nullable: false, is_primary_key: true },
{ name: "name", data_type: "TEXT", nullable: true, is_primary_key: false },
]),
+ listIndexes: vi.fn().mockResolvedValue([]),
listDataTypes: vi.fn().mockResolvedValue(["INTEGER", "TEXT"]),
previewTableImportFile: vi.fn().mockResolvedValue({
fileName: "rows.xlsx",
@@ -55,6 +56,7 @@ vi.mock("@/lib/backend/api", () => ({
listSchemas: mocks.listSchemas,
listTables: mocks.listTables,
getColumns: mocks.getColumns,
+ listIndexes: mocks.listIndexes,
listDataTypes: mocks.listDataTypes,
previewTableImportFile: mocks.previewTableImportFile,
releaseTableImportSource: mocks.releaseTableImportSource,
@@ -520,6 +522,67 @@ describe("TableImportDialog existing targets", () => {
);
});
+ it("recognizes Doris multi-column composite unique keys from indexes for update-existing", async () => {
+ mocks.getColumns.mockResolvedValueOnce([
+ { name: "id", data_type: "BIGINT", nullable: true, is_primary_key: false, is_unique: false },
+ { name: "data_type", data_type: "VARCHAR", nullable: true, is_primary_key: false, is_unique: false },
+ { name: "name", data_type: "VARCHAR", nullable: true, is_primary_key: false, is_unique: false },
+ ]);
+ mocks.listIndexes.mockResolvedValueOnce([
+ {
+ name: "UNIQUE KEY",
+ columns: ["id", "data_type"],
+ is_unique: true,
+ is_primary: false,
+ index_type: "UNIQUE KEY",
+ },
+ ]);
+ mocks.previewTableImportFile.mockResolvedValueOnce({
+ fileName: "multi.xlsx",
+ filePath: "/tmp/multi.xlsx",
+ fileType: "excel",
+ sizeBytes: 24,
+ columns: ["id", "data_type", "name"],
+ rows: [[1, "user", "Alice"]],
+ totalRows: 1,
+ sourceFingerprint: "multi-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"]');
+ 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.mockResolvedValue({
fileName: "unmapped.xlsx",
diff --git a/apps/desktop/src/composables/useNavigationTargets.ts b/apps/desktop/src/composables/useNavigationTargets.ts
index b4fc17a595..78b582554e 100644
--- a/apps/desktop/src/composables/useNavigationTargets.ts
+++ b/apps/desktop/src/composables/useNavigationTargets.ts
@@ -217,7 +217,7 @@ async function openTableTarget(target: NavigationTarget, options: NavigationOpen
}
const eagerColumns = eagerMetadata?.metadata.columns ?? [];
const eagerPrimaryKeys = eagerMetadata?.metadata.primaryKeys ?? [];
- const defaultSort = resolveTableDefaultSort(settingsStore.editorSettings, effectiveDbType, physicalTablePrimaryKeys(eagerColumns, eagerMetadata?.metadata.indexes), identifierQuote);
+ const defaultSort = resolveTableDefaultSort(settingsStore.editorSettings, effectiveDbType, physicalTablePrimaryKeys(eagerColumns, eagerMetadata?.metadata.indexes, effectiveDbType), identifierQuote);
const sql = await buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: config.driver_profile,
diff --git a/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts b/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts
index 5aed4dc2ef..e76dc94241 100644
--- a/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts
+++ b/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts
@@ -415,7 +415,7 @@ export function useSidebarDataOpenRuntime() {
const loadedTableMeta = cachedTableMeta ?? queryStore.tabs.find((item) => item.id === tabId)?.tableMeta;
const columns = loadedTableMeta?.columns ?? [];
const primaryKeys = loadedTableMeta?.primaryKeys ?? [];
- const defaultSort = resolveTableDefaultSort(settingsStore.editorSettings, effectiveDbType, loadedTableMeta?.physicalPrimaryKeys ?? physicalTablePrimaryKeys(columns), connectionStore.connectionIdentifierQuote?.(node.connectionId));
+ const defaultSort = resolveTableDefaultSort(settingsStore.editorSettings, effectiveDbType, loadedTableMeta?.physicalPrimaryKeys ?? physicalTablePrimaryKeys(columns, undefined, effectiveDbType), connectionStore.connectionIdentifierQuote?.(node.connectionId));
const defaultOrderBy = defaultSort.orderBy;
// #12647:首开路径同样尊重"该连接的行定位器已被引擎拒绝"的记忆,否则
// 被降级过的连接每次重新单击表都会再发一次注定失败的定位器查询。
diff --git a/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts b/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts
index ecee65d242..9a1fbeb39f 100644
--- a/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts
@@ -18,6 +18,7 @@ import {
isTdengineExistingRowReadonlyColumn,
isTableDataEditable,
parseSalesforceColumnExtra,
+ physicalTablePrimaryKeys,
supportsDataGridTransaction,
shouldIncludeSyntheticRowId,
showsKeylessEditWarning,
@@ -162,6 +163,32 @@ describe("tableEditing", () => {
expect(editableRowIdentifierColumns("postgres", columns, [index(["missing"])])).toEqual([]);
});
+ it("recognizes Doris/StarRocks composite unique keys with nullable columns as row identifier", () => {
+ // In Doris/StarRocks, UNIQUE KEY columns default to nullable in DDL
+ const columns = [column("id"), column("data_type")];
+ const dorisUniqueIndex: IndexInfo = {
+ name: "UNIQUE KEY",
+ columns: ["id", "data_type"],
+ is_unique: true,
+ is_primary: false,
+ index_type: "UNIQUE KEY",
+ };
+
+ expect(editableRowIdentifierColumns("doris", columns, [dorisUniqueIndex])).toEqual(["id", "data_type"]);
+ expect(editableRowIdentifierColumns("starrocks", columns, [dorisUniqueIndex])).toEqual(["id", "data_type"]);
+ // Standard engines like MySQL reject nullable unique index columns
+ expect(editableRowIdentifierColumns("mysql", columns, [dorisUniqueIndex])).toEqual([]);
+
+ // Shows keyless edit warning is false when primaryKeys are resolved
+ expect(showsKeylessEditWarning("doris", ["id", "data_type"], "TABLE")).toBe(false);
+ expect(showsKeylessEditWarning("doris", [], "TABLE")).toBe(true);
+
+ // physicalTablePrimaryKeys resolves the unique key model index for Doris/StarRocks
+ expect(physicalTablePrimaryKeys(columns, [dorisUniqueIndex], "doris")).toEqual(["id", "data_type"]);
+ expect(physicalTablePrimaryKeys(columns, [dorisUniqueIndex], "starrocks")).toEqual(["id", "data_type"]);
+ expect(physicalTablePrimaryKeys(columns, [dorisUniqueIndex], "mysql")).toEqual([]);
+ });
+
it.each(["oracle", "oceanbase-oracle"] as const)("prefers physical %s indexes over the ROWID fallback", (databaseType) => {
const columns = [column("OFFER_RELA_ID"), column("ORI_OFFER_ID")].map((value) => ({ ...value, is_nullable: false }));
const primaryIndex = { ...index(["OFFER_RELA_ID"], false), is_primary: true };
diff --git a/apps/desktop/src/lib/metadata/tableMetadataCache.ts b/apps/desktop/src/lib/metadata/tableMetadataCache.ts
index 3743dccb81..949847b89e 100644
--- a/apps/desktop/src/lib/metadata/tableMetadataCache.ts
+++ b/apps/desktop/src/lib/metadata/tableMetadataCache.ts
@@ -15,6 +15,7 @@ export interface TableMetadata {
tableType?: string;
catalog?: string;
database?: string;
+ databaseType?: DatabaseType;
columns: ColumnInfo[];
indexes: IndexInfo[];
primaryKeys: string[];
@@ -294,7 +295,7 @@ export function tableMetadataToDataTabMeta(metadata: TableMetadata, overrides?:
columns: metadata.columns,
primaryKeys: metadata.primaryKeys,
...(metadata.virtualPrimaryKeys?.length ? { virtualPrimaryKeys: metadata.virtualPrimaryKeys } : {}),
- physicalPrimaryKeys: physicalTablePrimaryKeys(metadata.columns, metadata.indexes),
+ physicalPrimaryKeys: physicalTablePrimaryKeys(metadata.columns, metadata.indexes, metadata.databaseType),
};
}
@@ -368,12 +369,22 @@ export async function loadTableMetadata(request: TableMetadataRequest): Promise<
const loadedIndexes = columns.length > 0 ? await ((!resolvedTarget && indexesPromise) || loadTableIndexes(indexRequest).catch(() => undefined)) : [];
const indexes = loadedIndexes ?? indexFailure();
const primaryKeys = editableRowIdentifierColumns(request.databaseType as DatabaseType, columns, indexes, columnsResult.tableType);
+ if ((request.databaseType === "doris" || request.databaseType === "starrocks") && primaryKeys.length > 0) {
+ const keySet = new Set(primaryKeys.map((name) => name.toLowerCase()));
+ for (const column of columns) {
+ if (keySet.has(column.name.toLowerCase())) {
+ column.is_primary_key = true;
+ column.is_unique = true;
+ }
+ }
+ }
return {
schema: resolvedSchema || undefined,
tableName: request.tableName,
tableType: columnsResult.tableType,
catalog: request.catalog,
database: request.database,
+ databaseType: request.databaseType as DatabaseType,
columns,
indexes,
primaryKeys,
diff --git a/apps/desktop/src/lib/table/tableEditing.ts b/apps/desktop/src/lib/table/tableEditing.ts
index f2d2394b27..46faa8b8d1 100644
--- a/apps/desktop/src/lib/table/tableEditing.ts
+++ b/apps/desktop/src/lib/table/tableEditing.ts
@@ -38,10 +38,16 @@ export function editablePrimaryKeys(databaseType: DatabaseType | undefined, colu
}
/** Physical primary keys only; unlike editable row identifiers, never fall back to unique indexes or synthetic keys. */
-export function physicalTablePrimaryKeys(columns: readonly Pick<ColumnInfo, "name" | "is_primary_key">[], indexes: readonly Pick<IndexInfo, "columns" | "is_primary">[] = []): string[] {
+export function physicalTablePrimaryKeys(columns: readonly Pick<ColumnInfo, "name" | "is_primary_key">[], indexes: readonly Pick<IndexInfo, "columns" | "is_primary" | "is_unique" | "index_type" | "name">[] = [], databaseType?: DatabaseType): string[] {
const columnPrimaryKeys = columns.filter((column) => column.is_primary_key).map((column) => column.name);
if (columnPrimaryKeys.length > 0) return columnPrimaryKeys;
- return indexes.find((index) => index.is_primary && index.columns.length > 0)?.columns ?? [];
+ const primaryIndex = indexes.find((index) => index.is_primary && index.columns.length > 0);
+ if (primaryIndex) return primaryIndex.columns;
+ if (databaseType === "doris" || databaseType === "starrocks") {
+ const uniqueKeyModelIndex = indexes.find((index) => (index.is_primary || index.is_unique || index.index_type?.toUpperCase() === "UNIQUE KEY" || index.name?.toUpperCase() === "UNIQUE KEY") && index.columns.length > 0);
+ if (uniqueKeyModelIndex) return uniqueKeyModelIndex.columns;
+ }
+ return [];
}
export function editableRowIdentifierColumns(databaseType: DatabaseType | undefined, columns: ColumnInfo[], indexes?: IndexInfo[], tableType?: string): string[] {
@@ -49,13 +55,21 @@ export function editableRowIdentifierColumns(databaseType: DatabaseType | undefi
const oracleRowIdFallback = getDatabaseCapability(databaseType).syntheticKey === "oracle-rowid" && primaryKeys.length === 1 && primaryKeys[0]?.toUpperCase() === DBX_ROWID_COLUMN;
if (primaryKeys.length > 0 && !oracleRowIdFallback) return primaryKeys;
const columnByName = new Map(columns.map((column) => [column.name.toLowerCase(), column]));
+ const isUniqueKeyModel = databaseType === "doris" || databaseType === "starrocks";
const uniqueIndex = indexes
?.filter((index) => {
if (index.filter?.trim() || index.columns.length === 0 || (!index.is_primary && !index.is_unique) || index.key_is_expression?.some(Boolean)) return false;
- return index.columns.every((name) => columnByName.get(name.toLowerCase())?.is_nullable === false);
+ return index.columns.every((name) => columnByName.has(name.toLowerCase()) && (isUniqueKeyModel || columnByName.get(name.toLowerCase())?.is_nullable === false));
})
- .sort((left, right) => Number(right.is_primary) - Number(left.is_primary) || left.columns.length - right.columns.length)[0];
- return uniqueIndex?.columns.map((name) => columnByName.get(name.toLowerCase())!.name) ?? primaryKeys;
+ .sort((left, right) => {
+ if (isUniqueKeyModel) {
+ const leftIsUniqueKey = left.index_type?.toUpperCase() === "UNIQUE KEY" || left.name?.toUpperCase() === "UNIQUE KEY" || left.is_primary;
+ const rightIsUniqueKey = right.index_type?.toUpperCase() === "UNIQUE KEY" || right.name?.toUpperCase() === "UNIQUE KEY" || right.is_primary;
+ if (leftIsUniqueKey !== rightIsUniqueKey) return Number(rightIsUniqueKey) - Number(leftIsUniqueKey);
+ }
+ return Number(right.is_primary) - Number(left.is_primary) || left.columns.length - right.columns.length;
+ })[0];
+ return uniqueIndex?.columns.map((name) => columnByName.get(name.toLowerCase())?.name ?? name) ?? primaryKeys;
}
export function isTableDataEditable(databaseType: DatabaseType | undefined, primaryKeys: string[], tableType?: string): boolean {
diff --git a/crates/dbx-driver-mysql/src/mysql_compatible.rs b/crates/dbx-driver-mysql/src/mysql_compatible.rs
index fe4e55cf58..d4e70aad6c 100644
--- a/crates/dbx-driver-mysql/src/mysql_compatible.rs
+++ b/crates/dbx-driver-mysql/src/mysql_compatible.rs
@@ -282,23 +282,37 @@ fn merge_index_infos(target: &mut Vec<IndexInfo>, parsed: Vec<IndexInfo>) {
fn indexes_from_create_table_ddl(ddl: &str) -> Vec<IndexInfo> {
let mut indexes = Vec::new();
- for raw_line in ddl.lines() {
- let line = trim_ddl_definition_line(raw_line);
+ let lines: Vec<&str> = ddl.lines().collect();
+ let mut idx = 0;
+ while idx < lines.len() {
+ let raw_line = lines[idx];
+ let line = raw_line.trim();
+ idx += 1;
if line.is_empty() {
continue;
}
let upper = line.to_ascii_uppercase();
- if upper.starts_with("PRIMARY KEY") {
- if let Some(index) = table_key_index("PRIMARY", line, true, true, "PRIMARY KEY") {
- indexes.push(index);
+ if upper.starts_with("PRIMARY KEY") || upper.starts_with("UNIQUE KEY") || upper.starts_with("INDEX ") {
+ let mut combined = line.to_string();
+ while first_parenthesized_content(&combined).is_none() && idx < lines.len() {
+ combined.push(' ');
+ combined.push_str(lines[idx].trim());
+ idx += 1;
}
- } else if upper.starts_with("UNIQUE KEY") {
- if let Some(index) = table_key_index("UNIQUE KEY", line, true, false, "UNIQUE KEY") {
- indexes.push(index);
- }
- } else if upper.starts_with("INDEX ") {
- if let Some(index) = secondary_index(line) {
- indexes.push(index);
+ let trimmed = trim_ddl_definition_line(&combined);
+ let upper_combined = trimmed.to_ascii_uppercase();
+ if upper_combined.starts_with("PRIMARY KEY") {
+ if let Some(index) = table_key_index("PRIMARY", trimmed, true, true, "PRIMARY KEY") {
+ indexes.push(index);
+ }
+ } else if upper_combined.starts_with("UNIQUE KEY") {
+ if let Some(index) = table_key_index("UNIQUE KEY", trimmed, true, false, "UNIQUE KEY") {
+ indexes.push(index);
+ }
+ } else if upper_combined.starts_with("INDEX ") {
+ if let Some(index) = secondary_index(trimmed) {
+ indexes.push(index);
+ }
}
}
}
@@ -574,6 +588,30 @@ UNIQUE KEY(`tenant_id`, `name``part`)
assert!(indexes[1].is_unique);
}
+ #[test]
+ fn doris_create_table_ddl_handles_multiline_unique_key() {
+ let ddl = r#"
+CREATE TABLE `test_multi` (
+ `id` bigint NULL,
+ `data_type` varchar(255) NULL
+) ENGINE=OLAP
+UNIQUE KEY(
+ `id`,
+ `data_type`
+)
+DISTRIBUTED BY HASH(`id`) BUCKETS 3
+"#;
+
+ let indexes = indexes_from_create_table_ddl(ddl);
+
+ assert_eq!(indexes.len(), 1);
+ assert_eq!(indexes[0].name, "UNIQUE KEY");
+ assert_eq!(indexes[0].columns, vec!["id", "data_type"]);
+ assert!(indexes[0].is_unique);
+ assert!(!indexes[0].is_primary);
+ assert_eq!(indexes[0].index_type.as_deref(), Some("UNIQUE KEY"));
+ }
+
fn catalog_info(name: &str, catalog_type: &str, is_current: bool) -> crate::db::CatalogInfo {
crate::db::CatalogInfo {
name: name.to_string(),