feat(sidebar): refresh data tables on double click

This commit is contained in:
二丫讲梵 authored and GitHub committed 2026-07-15 20:11:49 +08:00
1 parent 020d9869ac
commit f9bf039aef
7 files changed
+342 -23

No files matched your search

@@ -124,4 +124,147 @@ describe("queryStore table data refresh", () => {
expect(store.tabs.find((tab) => tab.id === publicTabId)?.result?.rows).toEqual([]);
expect(store.tabs.find((tab) => tab.id === archiveTabId)?.result).toBeUndefined();
});
it("refreshes one targeted tab while preserving its query context", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const firstTabId = store.createTab("pg-1", "app", "users", "data", "public");
const secondTabId = store.createTab("pg-1", "app", "users-copy", "data", "public");
for (const tabId of [firstTabId, secondTabId]) {
store.setTableMeta(tabId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
primaryKeys: ["id"],
});
}
const firstTab = store.tabs.find((tab) => tab.id === firstTabId)!;
firstTab.whereInput = "status = 'ACTIVE'";
firstTab.resultSortColumn = "created_at";
firstTab.resultSortDirection = "desc";
firstTab.resultPageLimit = 25;
firstTab.resultPageOffset = 50;
const refreshed = await store.refreshDataTab(firstTabId);
expect(refreshed).toBe(true);
expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(
expect.objectContaining({
whereInput: "status = 'ACTIVE'",
orderBy: '"created_at" DESC',
limit: 25,
offset: 50,
}),
);
expect(mocks.executeMulti).toHaveBeenCalledTimes(1);
expect(store.tabs.find((tab) => tab.id === firstTabId)?.result?.rows).toEqual([]);
expect(store.tabs.find((tab) => tab.id === secondTabId)?.result).toBeUndefined();
});
it("rejects a repeated refresh while SQL construction is in progress", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("pg-1", "app", "users", "data", "public");
store.setTableMeta(tabId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
primaryKeys: ["id"],
});
let resolveSql!: (sql: string) => void;
mocks.buildTableSelectSql.mockReturnValueOnce(new Promise((resolve) => (resolveSql = resolve)));
const firstRefresh = store.refreshDataTab(tabId);
expect(store.tabs.find((tab) => tab.id === tabId)?.isExecuting).toBe(true);
await expect(store.refreshDataTab(tabId)).resolves.toBe(false);
expect(mocks.buildTableSelectSql).toHaveBeenCalledTimes(1);
expect(mocks.executeMulti).not.toHaveBeenCalled();
resolveSql("SELECT id FROM public.users LIMIT 100 OFFSET 0");
await expect(firstRefresh).resolves.toBe(true);
expect(mocks.executeMulti).toHaveBeenCalledTimes(1);
});
it("returns false for SQL build failures, stores an error result, and clears the busy state", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("pg-1", "app", "users", "data", "public");
store.setTableMeta(tabId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [],
primaryKeys: [],
});
mocks.buildTableSelectSql.mockRejectedValueOnce(new Error("failed to build refresh SQL"));
await expect(store.refreshDataTab(tabId)).resolves.toBe(false);
const tab = store.tabs.find((candidate) => candidate.id === tabId)!;
expect(tab.isExecuting).toBe(false);
expect(tab.executionId).toBeUndefined();
expect(tab.result?.execution_error).toBe(true);
expect(tab.result?.rows).toEqual([["failed to build refresh SQL"]]);
expect(mocks.executeMulti).not.toHaveBeenCalled();
});
it("keeps the bulk refresh supersede and count behavior for busy matching tabs", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("pg-1", "app", "users", "data", "public");
store.setTableMeta(tabId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
primaryKeys: ["id"],
});
const tab = store.tabs.find((candidate) => candidate.id === tabId)!;
tab.isExecuting = true;
tab.executionId = "previous-execution";
await expect(
store.refreshDataTabsForTable({
connectionId: "pg-1",
database: "app",
schema: "public",
name: "users",
}),
).resolves.toBe(1);
expect(mocks.buildTableSelectSql).toHaveBeenCalledTimes(1);
expect(mocks.executeMulti).toHaveBeenCalledTimes(1);
expect(tab.isExecuting).toBe(false);
expect(tab.executionId).toBeUndefined();
});
it("keeps bulk SQL build failures observable to callers", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("pg-1", "app", "users", "data", "public");
store.setTableMeta(tabId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [],
primaryKeys: [],
});
mocks.buildTableSelectSql.mockRejectedValueOnce(new Error("bulk refresh SQL failed"));
await expect(
store.refreshDataTabsForTable({
connectionId: "pg-1",
database: "app",
schema: "public",
name: "users",
}),
).rejects.toThrow("bulk refresh SQL failed");
const tab = store.tabs.find((candidate) => candidate.id === tabId)!;
expect(tab.isExecuting).toBe(false);
expect(tab.result?.execution_error).toBe(true);
expect(mocks.executeMulti).not.toHaveBeenCalled();
});
});
+43 -17
View File
@@ -1754,25 +1754,28 @@ export const useQueryStore = defineStore("query", () => {
closeTabsWhere((tab) => tabMatchesDroppedTableObject(tab, target));
}
async function refreshDataTabsForTable(target: TableDataRefreshTarget): Promise<number> {
const matchingTabs = tabs.value.filter((tab) => tabMatchesTableDataRefreshTarget(tab, target));
if (matchingTabs.length === 0) return 0;
async function refreshDataTabInternal(id: string, options?: { supersedeBusy?: boolean; propagateBuildError?: boolean }): Promise<boolean> {
const tab = tabs.value.find((candidate) => candidate.id === id);
if (!tab || tab.mode !== "data" || (tab.isExecuting && !options?.supersedeBusy)) return false;
const tableMeta = tableMetaForDataTab(tab);
if (!tableMeta?.tableName) return false;
const settingsStore = useSettingsStore();
let refreshed = 0;
const connStore = useConnectionStore();
const conn = connStore.getConfig(tab.connectionId);
const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
const identifierQuote = connStore.connectionIdentifierQuote?.(tab.connectionId);
const primaryKeys = tab.tableMeta ? tab.tableMeta.primaryKeys : tableMeta.primaryKeys;
const sortOrder = tab.resultSortColumn && tab.resultSortDirection ? `${quoteTableDataIdentifier(effectiveDbType, tab.resultSortColumn, identifierQuote)} ${tab.resultSortDirection.toUpperCase()}` : undefined;
const orderBy = tab.orderByInput?.trim() || sortOrder;
const limit = tab.resultPageLimit ?? settingsStore.editorSettings.pageSize ?? tableOpenPageLimit();
const offset = tab.resultPageOffset ?? 0;
const refreshPreparationId = uuid();
for (const tab of matchingTabs) {
const tableMeta = tableMetaForDataTab(tab);
if (!tableMeta?.tableName) continue;
const connStore = useConnectionStore();
const conn = connStore.getConfig(tab.connectionId);
const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
const identifierQuote = connStore.connectionIdentifierQuote?.(tab.connectionId);
const primaryKeys = tab.tableMeta ? tab.tableMeta.primaryKeys : tableMeta.primaryKeys;
const sortOrder = tab.resultSortColumn && tab.resultSortDirection ? `${quoteTableDataIdentifier(effectiveDbType, tab.resultSortColumn, identifierQuote)} ${tab.resultSortDirection.toUpperCase()}` : undefined;
const orderBy = tab.orderByInput?.trim() || sortOrder;
const limit = tab.resultPageLimit ?? settingsStore.editorSettings.pageSize ?? tableOpenPageLimit();
const offset = tab.resultPageOffset ?? 0;
// Reserve the tab synchronously before SQL construction yields so repeated
// refresh requests cannot build and execute duplicate queries.
setExecutingWithId(tab.id, refreshPreparationId);
try {
const sql = await buildTableSelectSql({
databaseType: effectiveDbType,
identifierQuote,
@@ -1789,12 +1792,34 @@ export const useQueryStore = defineStore("query", () => {
limit,
offset,
});
if (!sql.trim()) throw new Error("Failed to build table refresh SQL");
const current = tabs.value.find((candidate) => candidate.id === id);
if (!current || current.executionId !== refreshPreparationId) return false;
updateSql(tab.id, sql);
await executeTabSql(tab.id, sql, {
pagination: { limit, offset },
preserveResultDuringExecution: true,
});
refreshed += 1;
return true;
} catch (error) {
const current = tabs.value.find((candidate) => candidate.id === id);
if (current?.executionId === refreshPreparationId) setErrorResult(id, error);
if (options?.propagateBuildError) throw error;
return false;
}
}
function refreshDataTab(id: string): Promise<boolean> {
return refreshDataTabInternal(id);
}
async function refreshDataTabsForTable(target: TableDataRefreshTarget): Promise<number> {
const matchingTabs = tabs.value.filter((tab) => tabMatchesTableDataRefreshTarget(tab, target));
if (matchingTabs.length === 0) return 0;
let refreshed = 0;
for (const tab of matchingTabs) {
if (await refreshDataTabInternal(tab.id, { supersedeBusy: true, propagateBuildError: true })) refreshed += 1;
}
return refreshed;
@@ -4036,6 +4061,7 @@ export const useQueryStore = defineStore("query", () => {
closeConnectionTabs,
closeDatabaseTabs,
closeDroppedTableObjectTabs,
refreshDataTab,
refreshDataTabsForTable,
releaseConnectionTabs,
releaseDatabaseTabs,