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(grid): preserve mysql row identity across refresh

t8y23859a516b2f6
diff --git a/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
index d3db2a8e9a..c961046080 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
@@ -198,6 +198,54 @@ describe("useDataGridActions", () => {
releaseIndexes([]);
});
+ it("keeps a MySQL table editable while manual refresh index discovery is still running (#13503)", async () => {
+ mocks.getConfig.mockReturnValue({ id: "mysql-1", db_type: "mysql" });
+ const tab = tableDataTab({ connectionId: "mysql-1" });
+ mocks.tabs.push(tab);
+ let releaseIndexes!: (indexes: IndexInfo[]) => void;
+ mocks.listIndexes.mockReturnValueOnce(
+ new Promise((resolve) => {
+ releaseIndexes = resolve;
+ }),
+ );
+ const actions = useDataGridActions(computed(() => tab));
+
+ await actions.onReloadData(tab.id, tab.sql, "", "", "", 100, 0, "refresh");
+
+ // 刷新等待段只拉列;后台索引发现不得重新挂起行标识,否则
+ // ContentArea 的 editable 变 false,增删/提交/回滚控件全部消失。
+ await vi.waitFor(() => expect(mocks.listIndexes).toHaveBeenCalledTimes(1));
+ expect(tab.tableMetaPending).toBe(false);
+ expect(tab.tableMeta?.primaryKeys).toEqual(["id"]);
+ releaseIndexes([]);
+ await vi.waitFor(() => expect(mocks.listIndexes).toHaveBeenCalledTimes(1));
+ expect(tab.tableMetaPending).toBe(false);
+ expect(tab.tableMeta?.primaryKeys).toEqual(["id"]);
+ });
+
+ it("preserves MySQL primary keys across a manual refresh when fresh columns do not declare them (#13503)", async () => {
+ mocks.getConfig.mockReturnValue({ id: "mysql-1", db_type: "mysql" });
+ const tab = tableDataTab({ connectionId: "mysql-1" });
+ mocks.tabs.push(tab);
+ mocks.getColumns.mockResolvedValue([{ ...tab.tableMeta!.columns[0]!, is_primary_key: false }]);
+ let releaseIndexes!: (indexes: IndexInfo[]) => void;
+ mocks.listIndexes.mockReturnValueOnce(
+ new Promise((resolve) => {
+ releaseIndexes = resolve;
+ }),
+ );
+ const actions = useDataGridActions(computed(() => tab));
+
+ await actions.onReloadData(tab.id, tab.sql, "", "", "", 100, 0, "refresh");
+
+ await vi.waitFor(() => expect(mocks.listIndexes).toHaveBeenCalledTimes(1));
+ expect(tab.tableMetaPending).toBe(false);
+ expect(tab.tableMeta?.primaryKeys).toEqual(["id"]);
+ releaseIndexes([{ name: "PRIMARY", columns: ["id"], is_unique: true, is_primary: true }]);
+ await vi.waitFor(() => expect(tab.tableMeta?.primaryKeys).toEqual(["id"]));
+ expect(tab.tableMetaPending).toBe(false);
+ });
+
it("manual refresh derives primary keys from fresh columns", async () => {
const tab = tableDataTab();
mocks.tabs.push(tab);
@@ -252,6 +300,35 @@ describe("useDataGridActions", () => {
expect(tab.tableMetaPending).toBe(false);
});
+ it("keeps a keyless MySQL table editable after manual refresh while index discovery is still running (#13503)", async () => {
+ mocks.getConfig.mockReturnValue({ id: "mysql-1", db_type: "mysql" });
+ const keylessColumn = { name: "id", data_type: "int", is_nullable: true, column_default: null, is_primary_key: false, extra: null };
+ const tab = tableDataTab({
+ connectionId: "mysql-1",
+ tableMeta: { schema: undefined, tableName: "events", tableType: "TABLE", columns: [keylessColumn], primaryKeys: [] },
+ });
+ mocks.tabs.push(tab);
+ mocks.getColumns.mockResolvedValue([keylessColumn]);
+ let resolveIndexes!: (indexes: IndexInfo[]) => void;
+ mocks.listIndexes.mockReturnValueOnce(
+ new Promise<IndexInfo[]>((resolve) => {
+ resolveIndexes = resolve;
+ }),
+ );
+ const actions = useDataGridActions(computed(() => tab));
+
+ await actions.onReloadData(tab.id, tab.sql, "", "", "", 100, 0, "refresh");
+
+ // MySQL edits keyless rows through the keyless predicate, so an empty key
+ // set is already a resolved identity and must not block the edit controls.
+ expect(tab.tableMetaPending).toBe(false);
+ expect(tab.tableMeta?.primaryKeys).toEqual([]);
+ expect(mocks.listIndexes).toHaveBeenCalledTimes(1);
+
+ resolveIndexes([]);
+ await vi.waitFor(() => expect(tab.tableMetaPending).toBe(false));
+ });
+
it.each([true, false])("keeps a surviving old key read-only until index discovery settles (success=%s)", async (success) => {
const tab = reactive(tableDataTab());
mocks.tabs.push(tab);
diff --git a/apps/desktop/src/composables/useDataGridActions.ts b/apps/desktop/src/composables/useDataGridActions.ts
index bc49b499c7..34358d2b68 100644
--- a/apps/desktop/src/composables/useDataGridActions.ts
+++ b/apps/desktop/src/composables/useDataGridActions.ts
@@ -190,7 +190,6 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
// still receive its result. Only the latest request may update this tab.
const requestToken = {};
metadataRequests.set(tab, requestToken);
- tab.tableMetaPending = true;
const metadataGenerationAtStart = connectionStore.metadataGenerationFor(target.connectionId, target.database);
const trace = options.trace;
@@ -202,7 +201,18 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
return false;
}
const config = connectionStore.getConfig(target.connectionId);
+ const effectiveDbType = effectiveDatabaseTypeForConnection(config);
const querySchema = metadataSchemaForConnection(config, target.database, target.schema);
+ // MySQL owns its row identity across a refresh (see below). Every other
+ // database keeps the existing behavior: the edit gate is closed while the
+ // fresh metadata load runs.
+ if (effectiveDbType !== "mysql") tab.tableMetaPending = true;
+ // MySQL columns do not always report the key that the table loader found
+ // through index discovery (for example unique-key identities). A manual
+ // refresh must not replace that known row identity with an empty set while
+ // the background index load is still running, otherwise `tableMetaPending`
+ // turns the data grid read-only and hides all edit controls (#13503).
+ const preserveMysqlRowIdentity = effectiveDbType === "mysql" && tableMeta.columns.length > 0;
console.info("[DBX][reloadData:metadata:get-columns:start]", { traceId: trace?.traceId, elapsed: trace?.elapsed(), schema: querySchema, table: target.tableName, columnsOnly: options.columnsOnly === true });
// 复用共享表元数据缓存(30s TTL + in-flight 去重),多个入口对同一张表
// 不再各自往返 getColumns/listIndexes。跨连接生命周期的强制重建走 force,
@@ -220,13 +230,14 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
catalog: target.catalog,
force: options.force === true,
});
- const primaryKeys = editablePrimaryKeys(effectiveDatabaseTypeForConnection(config), columns, target.tableType);
- const virtualPrimaryKeys = primaryKeys.length > 0 ? [] : loadVirtualRowIdentifier({ connectionId: target.connectionId, database: target.database, catalog: target.catalog, schema: querySchema, tableName: target.tableName }, columns);
+ const declaredPrimaryKeys = editablePrimaryKeys(effectiveDatabaseTypeForConnection(config), columns, target.tableType);
+ const virtualPrimaryKeys = declaredPrimaryKeys.length > 0 ? [] : loadVirtualRowIdentifier({ connectionId: target.connectionId, database: target.database, catalog: target.catalog, schema: querySchema, tableName: target.tableName }, columns);
+ const primaryKeys = declaredPrimaryKeys.length > 0 ? declaredPrimaryKeys : virtualPrimaryKeys.length > 0 ? virtualPrimaryKeys : preserveMysqlRowIdentity ? tableMeta.primaryKeys : [];
return {
columns,
- primaryKeys: primaryKeys.length > 0 ? primaryKeys : virtualPrimaryKeys,
+ primaryKeys,
...(virtualPrimaryKeys.length ? { virtualPrimaryKeys } : {}),
- rowIdentityResolved: primaryKeys.length > 0 || virtualPrimaryKeys.length > 0,
+ rowIdentityResolved: primaryKeys.length > 0 || virtualPrimaryKeys.length > 0 || (preserveMysqlRowIdentity && columns.length > 0),
};
})()
: await (async () => {
@@ -241,14 +252,20 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
catalog: target.catalog,
force: options.force === true,
});
+ // If index discovery failed, columns alone cannot recover a MySQL
+ // key that was already known; keep the previous identity instead of
+ // leaving the tab read-only (#13473, #13503). A successful discovery
+ // that reports no keys still clears it.
+ const preservedMysqlPrimaryKeys = preserveMysqlRowIdentity && metadata.rowIdentityResolved === false && metadata.primaryKeys.length === 0 ? tableMeta.primaryKeys : [];
+ const primaryKeys = metadata.primaryKeys.length > 0 ? metadata.primaryKeys : preservedMysqlPrimaryKeys;
return {
columns: metadata.columns,
- primaryKeys: metadata.primaryKeys,
+ primaryKeys,
...(metadata.virtualPrimaryKeys?.length ? { virtualPrimaryKeys: metadata.virtualPrimaryKeys } : {}),
// A failed index load leaves rowIdentityResolved false (and uncached), but keys the
- // columns already declare still identify rows; only a keyless table needs the
- // unique-index fallback. Otherwise the tab stays read-only after Refresh (#13473).
- rowIdentityResolved: metadata.rowIdentityResolved !== false || metadata.primaryKeys.length > 0,
+ // columns already declare still identify rows. Preserved MySQL keys or a table that
+ // was already resolved as keyless need no unique-index fallback to keep editing.
+ rowIdentityResolved: metadata.rowIdentityResolved !== false || primaryKeys.length > 0 || (preserveMysqlRowIdentity && metadata.columns.length > 0),
};
})();
const columns = loaded.columns;