fix(connection): invalidate data-tab metadata on disconnect/reconnect

This commit is contained in:
jearhe authored and GitHub committed 2026-08-20 09:25:14 +08:00
1 parent b537c4b891
commit 78aab1e5ed
15 files changed
+804 -31

No files matched your search

@@ -0,0 +1,190 @@
import { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ConnectionConfig } from "@/types/database";
function installLocalStorage() {
const data = new Map<string, string>();
vi.stubGlobal("localStorage", {
getItem: vi.fn((key: string) => data.get(key) ?? null),
setItem: vi.fn((key: string, value: string) => data.set(key, value)),
removeItem: vi.fn((key: string) => data.delete(key)),
});
}
function pgConnection(id: string): ConnectionConfig {
return {
id,
name: id,
db_type: "postgres",
host: "127.0.0.1",
port: 5432,
username: "postgres",
password: "",
database: "app",
read_only: false,
} as ConnectionConfig;
}
describe("connectionStore disconnect data-tab metadata freshness", () => {
beforeEach(() => {
vi.resetModules();
vi.unstubAllGlobals();
installLocalStorage();
setActivePinia(createPinia());
});
it("clears data-tab metadata freshness for the disconnected connection only", async () => {
const checkConnectionHealth = vi.fn().mockResolvedValue(undefined);
const disconnectDb = vi.fn().mockResolvedValue(undefined);
vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
vi.doMock("@/lib/backend/api", () => ({
checkConnectionHealth,
disconnectDb,
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
saveConnections: vi.fn().mockResolvedValue(undefined),
saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
}));
const { useConnectionStore } = await import("@/stores/connectionStore");
const { useQueryStore } = await import("@/stores/queryStore");
const { useSettingsStore } = await import("@/stores/settingsStore");
const store = useConnectionStore();
// keep-tabs:数据标签页在断开后继续存在,是 tab-local 元数据跨 reconnect
// 存活的场景(default close-tabs 会直接关掉标签页,不存在该问题)
useSettingsStore().editorSettings.disconnectTabHandlingMode = "keep-tabs-clear-results";
const connectionA = pgConnection("conn-a");
const connectionB = pgConnection("conn-b");
store.connections = [connectionA, connectionB];
const queryStore = useQueryStore();
const tabA = queryStore.createTab("conn-a", "app", "users", "data", "public", undefined, undefined, { forceNew: true });
const tabB = queryStore.createTab("conn-b", "app", "orders", "data", "public", undefined, undefined, { forceNew: true });
queryStore.setTableMeta(tabA, { schema: "public", database: "app", tableName: "users", tableType: "TABLE", columns: [], primaryKeys: [] });
queryStore.setTableMeta(tabB, { schema: "public", database: "app", tableName: "orders", tableType: "TABLE", columns: [], primaryKeys: [] });
expect(queryStore.tabs.find((tab) => tab.id === tabA)?.tableMetaUpdatedAt).toBeDefined();
expect(queryStore.tabs.find((tab) => tab.id === tabB)?.tableMetaUpdatedAt).toBeDefined();
store.connectedIds.add("conn-a");
await store.disconnect("conn-a");
// conn-a 的 data tab:freshness 戳被清除(重连后重开必须重新拉取结构)
expect(queryStore.tabs.find((tab) => tab.id === tabA)?.tableMetaUpdatedAt).toBeUndefined();
// conn-b 不受影响:缓存保持 warm
expect(queryStore.tabs.find((tab) => tab.id === tabB)?.tableMetaUpdatedAt).toBeDefined();
expect(disconnectDb).toHaveBeenCalledWith("conn-a", undefined);
}, 10_000);
it("clears data-tab metadata freshness for a closed database only", async () => {
const checkConnectionHealth = vi.fn().mockResolvedValue(undefined);
const closeDatabaseConnection = vi.fn().mockResolvedValue(undefined);
vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
vi.doMock("@/lib/backend/api", () => ({
checkConnectionHealth,
closeDatabaseConnection,
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
saveConnections: vi.fn().mockResolvedValue(undefined),
saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
}));
const { useConnectionStore } = await import("@/stores/connectionStore");
const { useQueryStore } = await import("@/stores/queryStore");
const { useSettingsStore } = await import("@/stores/settingsStore");
const store = useConnectionStore();
useSettingsStore().editorSettings.disconnectTabHandlingMode = "keep-tabs-clear-results";
const connection = pgConnection("conn-a");
store.connections = [connection];
const queryStore = useQueryStore();
const tabApp = queryStore.createTab("conn-a", "app", "users", "data", "public", undefined, undefined, { forceNew: true });
const tabOther = queryStore.createTab("conn-a", "other", "orders", "data", "public", undefined, undefined, { forceNew: true });
queryStore.setTableMeta(tabApp, { schema: "public", database: "app", tableName: "users", tableType: "TABLE", columns: [], primaryKeys: [] });
queryStore.setTableMeta(tabOther, { schema: "public", database: "other", tableName: "orders", tableType: "TABLE", columns: [], primaryKeys: [] });
expect(queryStore.tabs.find((tab) => tab.id === tabApp)?.tableMetaUpdatedAt).toBeDefined();
expect(queryStore.tabs.find((tab) => tab.id === tabOther)?.tableMetaUpdatedAt).toBeDefined();
store.connectedIds.add("conn-a");
await store.closeDatabaseConnection("conn-a", "app");
expect(queryStore.tabs.find((tab) => tab.id === tabApp)?.tableMetaUpdatedAt).toBeUndefined();
expect(queryStore.tabs.find((tab) => tab.id === tabOther)?.tableMetaUpdatedAt).toBeDefined();
expect(closeDatabaseConnection).toHaveBeenCalledWith("conn-a", "app");
}, 10_000);
it("treats markConnectionLost as a metadata lifecycle boundary for one connection only", async () => {
vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
vi.doMock("@/lib/backend/api", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/lib/backend/api")>();
return {
...actual,
checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
getColumns: vi.fn().mockResolvedValue([{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }]),
listIndexes: vi.fn().mockResolvedValue([]),
listInstalledAgents: vi.fn().mockResolvedValue([]),
listInstalledAgentsLocal: vi.fn().mockResolvedValue([]),
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
saveConnections: vi.fn().mockResolvedValue(undefined),
saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
};
});
const { useConnectionStore } = await import("@/stores/connectionStore");
const { useQueryStore } = await import("@/stores/queryStore");
const { useSettingsStore } = await import("@/stores/settingsStore");
const { loadTableMetadata, getCachedTableMetadata, clearTableMetadataCache } = await import("@/lib/metadata/tableMetadataCache");
clearTableMetadataCache();
const store = useConnectionStore();
useSettingsStore().editorSettings.disconnectTabHandlingMode = "keep-tabs-clear-results";
store.connections = [pgConnection("conn-a"), pgConnection("conn-b")];
const queryStore = useQueryStore();
const tabA = queryStore.createTab("conn-a", "app", "users", "data", "public", undefined, undefined, { forceNew: true });
const tabB = queryStore.createTab("conn-b", "app", "orders", "data", "public", undefined, undefined, { forceNew: true });
queryStore.setTableMeta(tabA, { schema: "public", database: "app", tableName: "users", tableType: "TABLE", columns: [], primaryKeys: [] });
queryStore.setTableMeta(tabB, { schema: "public", database: "app", tableName: "orders", tableType: "TABLE", columns: [], primaryKeys: [] });
const generationBeforeA = store.metadataGenerationFor("conn-a", "app");
const generationBeforeB = store.metadataGenerationFor("conn-b", "app");
await loadTableMetadata({
connectionId: "conn-a",
database: "app",
schema: "public",
tableName: "users",
tableType: "TABLE",
databaseType: "postgres",
});
expect(
getCachedTableMetadata({
connectionId: "conn-a",
database: "app",
schema: "public",
tableName: "users",
tableType: "TABLE",
databaseType: "postgres",
}),
).toBeDefined();
store.connectedIds.add("conn-a");
store.markConnectionLost("conn-a", new Error("connection lost"));
await vi.waitFor(() => {
expect(queryStore.tabs.find((tab) => tab.id === tabA)?.tableMetaUpdatedAt).toBeUndefined();
});
expect(store.metadataGenerationFor("conn-a", "app")).toBeGreaterThan(generationBeforeA);
expect(store.metadataGenerationFor("conn-b", "app")).toBe(generationBeforeB);
expect(queryStore.tabs.find((tab) => tab.id === tabB)?.tableMetaUpdatedAt).toBeDefined();
expect(
getCachedTableMetadata({
connectionId: "conn-a",
database: "app",
schema: "public",
tableName: "users",
tableType: "TABLE",
databaseType: "postgres",
}),
).toBeUndefined();
}, 10_000);
});
@@ -53,6 +53,8 @@ vi.mock("@/stores/connectionStore", () => ({
getConfig: getConnectionConfig,
lookupLocalCompletionTables,
recordConnectionLostError: vi.fn(),
// 与真实 store 一致:setTableMeta 写入 tableMeta 时记录连接元数据代次
metadataGenerationFor: () => 0,
}),
}));
@@ -8,6 +8,8 @@ const mocks = vi.hoisted(() => ({
executeMulti: vi.fn(),
getConnectionConfig: vi.fn(),
saveOpenTabsState: vi.fn(),
loadTableMetadata: vi.fn(),
metadataGeneration: 0,
}));
vi.mock("@/lib/backend/api", () => ({
@@ -23,9 +25,18 @@ vi.mock("@/stores/connectionStore", () => ({
ensureConnected: vi.fn().mockResolvedValue(undefined),
getConfig: mocks.getConnectionConfig,
recordConnectionLostError: vi.fn(),
metadataGenerationFor: () => mocks.metadataGeneration,
}),
}));
vi.mock("@/lib/metadata/tableMetadataCache", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/lib/metadata/tableMetadataCache")>();
return {
...actual,
loadTableMetadata: mocks.loadTableMetadata,
};
});
vi.mock("@/stores/settingsStore", () => ({
useSettingsStore: () => ({
editorSettings: { pageSize: 1000 },
@@ -47,6 +58,7 @@ describe("queryStore table data refresh", () => {
vi.unstubAllGlobals();
installLocalStorage();
setActivePinia(createPinia());
mocks.metadataGeneration = 0;
mocks.getConnectionConfig.mockReturnValue({
id: "pg-1",
name: "Postgres",
@@ -595,4 +607,128 @@ describe("queryStore table data refresh", () => {
expect(tab.result?.execution_error).toBe(true);
expect(mocks.executeMulti).not.toHaveBeenCalled();
});
it("rebuilds table metadata from the new connection before the first reload after a reconnect boundary", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("pg-1", "app", "users", "data", "public");
// 断链前的旧结构:只有 [id]
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)!;
// 外部 ALTER TABLE ... ADD age:DBX 断开→重连。disconnect 会 bump 连接代次
// 并清 freshness 戳(staleConnectionDataTabMetadata),此处等价模拟:
// 旧代次(0)的 tableMeta 已与新代次(1)失配,reload 必须重建结构
mocks.metadataGeneration = 1;
tab.tableMetaUpdatedAt = undefined;
mocks.loadTableMetadata.mockResolvedValue({
metadata: {
schema: "public",
tableName: "users",
tableType: "TABLE",
database: "app",
columns: [
{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
{ name: "age", data_type: "integer", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
],
indexes: [],
primaryKeys: ["id"],
cachedAt: Date.now(),
},
cacheStatus: "miss",
ageMs: 0,
});
await store.refreshDataTab(tabId);
// 重建从新连接源头强制拉取(force),不再使用旧显式列列表
expect(mocks.loadTableMetadata).toHaveBeenCalledTimes(1);
expect(mocks.loadTableMetadata).toHaveBeenCalledWith(
expect.objectContaining({
connectionId: "pg-1",
database: "app",
schema: "public",
tableName: "users",
force: true,
}),
);
// 重建后的新列 [id, age] 进入 SQL 构建并写回 tab
expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id", "age"] }));
expect(tab.tableMeta?.columns.map((column) => column.name)).toEqual(["id", "age"]);
expect(tab.tableMetaUpdatedAt).toBeDefined();
expect(tab.tableMetaGeneration).toBe(1);
});
it("does not rebuild metadata on a warm reload in the same connection generation", 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"],
});
await store.refreshDataTab(tabId);
// 同代次(0)内正常刷新:直接复用 tab 元数据,不重新拉取结构
expect(mocks.loadTableMetadata).not.toHaveBeenCalled();
expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id"] }));
});
it("abandons a forced metadata rebuild when generation changes mid-flight", 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)!;
mocks.metadataGeneration = 1;
tab.tableMetaUpdatedAt = undefined;
let resolveMetadata!: (value: Awaited<ReturnType<typeof mocks.loadTableMetadata>>) => void;
mocks.loadTableMetadata.mockReturnValueOnce(
new Promise((resolve) => {
resolveMetadata = resolve;
}),
);
const refresh = store.refreshDataTab(tabId);
await vi.waitFor(() => expect(mocks.loadTableMetadata).toHaveBeenCalledTimes(1));
mocks.metadataGeneration = 2;
resolveMetadata({
metadata: {
schema: "public",
tableName: "users",
tableType: "TABLE",
database: "app",
columns: [
{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
{ name: "age", data_type: "integer", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
],
indexes: [],
primaryKeys: ["id"],
cachedAt: Date.now(),
},
cacheStatus: "miss",
ageMs: 0,
});
await expect(refresh).resolves.toBe(false);
expect(tab.tableMeta?.columns.map((column) => column.name)).toEqual(["id"]);
expect(tab.tableMetaUpdatedAt).toBeUndefined();
expect(mocks.buildTableSelectSql).not.toHaveBeenCalled();
expect(mocks.executeMulti).not.toHaveBeenCalled();
});
});
+61 -3
View File
@@ -1038,6 +1038,9 @@ export const useConnectionStore = defineStore("connection", () => {
clearConnectionHealthCheck(connectionId);
if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
recordConnectionError(connectionId, error);
// 被动断链同样是元数据生命周期边界:查询/健康检查发现连接已失效后,
// 不得继续把旧 tableMeta 当作当前代次的 warm cache(PR #6640 blocker 3)。
invalidateConnectionMetadataLifetime(connectionId);
}
function recordConnectionLostError(connectionId: string, error: unknown): boolean {
@@ -1750,6 +1753,47 @@ export const useConnectionStore = defineStore("connection", () => {
};
}
// 连接元数据代次(connection generation):disconnect / 关闭数据库 / 后端死池
// 重连等生命周期边界会递增代次。数据标签页记录其 tableMeta 写入时的代次
// (QueryTab.tableMetaGeneration),代次失配视同冷缓存——即使位于 30s TTL
// 窗口内也必须重新拉取结构,且失效前启动的 in-flight 元数据请求不得把旧
// 结果写回 tab(issue #6623 / PR #6640 review blocker 1)。
// 语义:连接级代次影响该连接全部数据库;数据库级代次只影响单个数据库。
// 查询代次时取两者较新者,disconnect 只 bump 连接级、closeDatabaseConnection
// 只 bump 数据库级,因此作用域天然隔离。
let metadataGenerationCounter = 0;
const metadataGenerationByConnection = new Map<string, number>();
const metadataGenerationByDatabase = new Map<string, number>();
function metadataGenerationFor(connectionId: string, database?: string): number {
const connectionGeneration = metadataGenerationByConnection.get(connectionId) ?? 0;
if (database == null) return connectionGeneration;
return Math.max(connectionGeneration, metadataGenerationByDatabase.get(`${connectionId}\x00${database}`) ?? 0);
}
function bumpMetadataGeneration(connectionId: string, database?: string) {
metadataGenerationCounter += 1;
if (database == null) {
metadataGenerationByConnection.set(connectionId, metadataGenerationCounter);
} else {
metadataGenerationByDatabase.set(`${connectionId}\x00${database}`, metadataGenerationCounter);
}
}
/**
* 连接/数据库生命周期失效:shared metadata cache + 单调代次必须同步完成,
* 这样紧随其后的 toolbar reload 立刻看到 generation mismatch,不会把旧
* tableMeta 当成 warm。data-tab freshness 清戳经动态 import,避免与
* queryStore 循环依赖;generation 已变时 freshness 稍晚清除也安全。
*/
function invalidateConnectionMetadataLifetime(connectionId: string, database?: string) {
invalidateMetadataCaches({ connectionId, database });
bumpMetadataGeneration(connectionId, database);
void import("@/stores/queryStore").then(({ useQueryStore }) => {
useQueryStore().staleConnectionDataTabMetadata(connectionId, database);
});
}
function invalidateMetadataCaches(match: MetadataCacheInvalidation): number {
return metadataListPageCache.invalidate(match) + invalidateTableMetadataCache(match) + invalidateObjectBrowserRowsCache(match);
}
@@ -1852,7 +1896,7 @@ export const useConnectionStore = defineStore("connection", () => {
function mergeLocatedTreeChildren(parent: TreeNode, currentChildren: TreeNode[], pageChildren: TreeNode[], connectionId: string, database: string): TreeNode[] {
const tableChildren = pageChildren.filter((child) => child.type === "table");
const nonTableChildren = pageChildren.filter((child) => child.type !== "table");
let merged = tableChildren.length ? mergeTableTreePageChildren(currentChildren, tableChildren, connectionId, database) : [...currentChildren];
const merged = tableChildren.length ? mergeTableTreePageChildren(currentChildren, tableChildren, connectionId, database) : [...currentChildren];
const existing = new Map(merged.map((node) => [treeNodeObjectIdentity(node), node]));
for (const child of nonTableChildren) {
const key = treeNodeObjectIdentity(child);
@@ -3410,6 +3454,11 @@ export const useConnectionStore = defineStore("connection", () => {
invalidateObjectBrowserRowsCache({ connectionId });
const { useQueryStore } = await import("@/stores/queryStore");
const queryStore = useQueryStore();
// 断开连接是明确的元数据新鲜度边界:数据标签页保留展示/编辑状态,但
// 其 tableMeta 不得再被视为 warm cache(issue #6623——reconnect 后重开
// 同表必须重新拉取结构)。completion/object-browser 缓存上面已清;
// 这里再走统一 helper,bump 连接代次并清 data-tab freshness。
invalidateConnectionMetadataLifetime(connectionId);
switch (settingsStore.editorSettings.disconnectTabHandlingMode) {
case "close-tabs":
queryStore.closeConnectionTabs(connectionId);
@@ -3467,6 +3516,10 @@ export const useConnectionStore = defineStore("connection", () => {
}
invalidateCompletionCache(connectionId, database);
invalidateObjectBrowserRowsCache({ connectionId, database });
// 数据库级生命周期边界:与连接级断开一致,数据标签页的元数据 freshness
// 戳必须作废,重开/刷新时重新拉取结构(issue #6623)。bump 数据库级代次
// 只影响该库的在途回写与 reload 判定,不影响本连接其它库。
invalidateConnectionMetadataLifetime(connectionId, database);
}
async function ensureConnected(connectionId: string, options: { activate?: boolean; verifyHealth?: boolean } = {}) {
@@ -3482,7 +3535,10 @@ export const useConnectionStore = defineStore("connection", () => {
markConnectionHealthChecked(connectionId);
return;
} catch {
// Backend pool is dead — remove from connectedIds and reconnect
// Backend pool is dead — remove from connectedIds and reconnect.
// 死池重连同样跨越了连接生命周期:shared 表元数据缓存与数据标签页的
// 元数据 freshness 都必须作废,否则自动重连后仍可能复用断链前的旧
// 字段结构(issue #6623)。
cancelObjectDdlLoadsForConnection(connectionId);
cancelObjectMetadataLoadsForConnection(connectionId);
clearMetadataRuntimeCacheForConnection(connectionId);
@@ -3490,6 +3546,7 @@ export const useConnectionStore = defineStore("connection", () => {
clearPrimaryVisibleObjectNames(connectionId);
clearConnectionHealthCheck(connectionId);
if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
invalidateConnectionMetadataLifetime(connectionId);
}
}
let config = getConfig(connectionId);
@@ -6657,7 +6714,7 @@ export const useConnectionStore = defineStore("connection", () => {
const text = table.name.toLowerCase();
const schema = table.schema?.toLowerCase();
const normalized = filter.trim().toLowerCase();
let score = schema && preferredSchema && schema === preferredSchema.toLowerCase() ? 10_000 : 0;
const score = schema && preferredSchema && schema === preferredSchema.toLowerCase() ? 10_000 : 0;
if (!normalized) return score;
if (text === normalized) return score + 9_000 - text.length;
if (text.startsWith(normalized)) return score + 7_500 - text.length;
@@ -8199,6 +8256,7 @@ export const useConnectionStore = defineStore("connection", () => {
connect,
cancelConnecting,
disconnect,
metadataGenerationFor,
disconnectAndForgetConnectionPassword,
hasSessionCredential,
closeDatabaseConnection,
+60 -10
View File
@@ -39,9 +39,10 @@ import { supportsClearableQuerySchema } from "@/lib/database/databaseFeatureSupp
import { canInsertTableRows, canUseKeylessRowPredicate, DBX_ROWID_COLUMN, editablePrimaryKeys, usesSyntheticRowIdKey } from "@/lib/table/tableEditing";
import { TABLE_DATA_EXPORT_PAGE_SIZE } from "@/lib/table/tableDataExport";
import { tableMetaForDataTab } from "@/lib/table/tableDataTabMeta";
import { isDataTabMetadataLifecycleStale } from "@/lib/sidebar/dataTabOpenPolicy";
import { dataTabExecutionDatabase } from "@/lib/table/dataTabExecutionDatabase";
import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
import { getCachedTableMetadata, loadTableColumns, loadTableIndexes, loadTableMetadata, type TableMetadataRequest } from "@/lib/metadata/tableMetadataCache";
import { getCachedTableMetadata, loadTableColumns, loadTableIndexes, loadTableMetadata, tableMetadataToDataTabMeta, type TableMetadataRequest } from "@/lib/metadata/tableMetadataCache";
import { MetadataTaskLimiter } from "@/lib/metadata/metadataTaskLimiter";
import { buildTableSelectSql, quoteTableDataIdentifier } from "@/lib/table/tableSelectSql";
import { connectionObjectTreeNodeSchema, connectionQueryExecutionSchema, connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection, gaussdbCountQueryDopHint, metadataSchemaForConnection } from "@/lib/database/jdbcDialect";
@@ -2819,26 +2820,55 @@ export const useQueryStore = defineStore("query", () => {
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 connStore = useConnectionStore();
const conn = connStore.getConfig(tab.connectionId);
const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
const identifierQuote = connStore.connectionIdentifierQuote?.(tab.connectionId);
clearInvalidDataTabSortState(tab, tableMeta.columns);
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 ?? tableOpenPageLimit(settingsStore.editorSettings.tableOpenPageSize);
const offset = tab.resultPageOffset ?? 0;
const useDriverRowOffset = conn?.db_type === "jdbc" && effectiveDbType === "iris";
const refreshPreparationId = uuid();
// Reserve the tab synchronously before SQL construction yields so repeated
// refresh requests cannot build and execute duplicate queries.
setExecutingWithId(tab.id, refreshPreparationId);
try {
let tableMeta = tableMetaForDataTab(tab);
if (!tableMeta?.tableName) return false;
// 生命周期代次校验:disconnect / 关库 / 死池重连后的首次刷新必须先从
// 新连接源头重建结构,否则旧显式列列表会生成错误 SELECT(issue #6623 /
// PR #6640 review blocker 2)。reload 路径不读 tableMetaUpdatedAt 风干
// 判定、只读 tableMeta 本身,因此在这里显式强制重建。
const connectionGeneration = connStore.metadataGenerationFor(tab.connectionId, tab.database);
if (isDataTabMetadataLifecycleStale(tab, connectionGeneration)) {
const metadataGenerationAtStart = connectionGeneration;
const reloadedMetadata = await loadTableMetadata({
connectionId: tab.connectionId,
database: tab.database,
schema: tableMeta.schema,
tableName: tableMeta.tableName,
tableType: tableMeta.tableType,
catalog: tableMeta.catalog,
databaseType: effectiveDbType ?? conn?.db_type ?? "",
driverProfile: conn?.driver_profile,
force: true,
});
// 重建期间又跨越了一次连接生命周期边界 → 放弃本次刷新,避免旧结果
// 二次写回 tab(PR #6640 review blocker 1 的 tab-local 半边)
if (connStore.metadataGenerationFor(tab.connectionId, tab.database) !== metadataGenerationAtStart) return false;
const current = tabs.value.find((candidate) => candidate.id === id);
if (!current || current.executionId !== refreshPreparationId) return false;
setTableMeta(tab.id, tableMetadataToDataTabMeta(reloadedMetadata.metadata, { schema: tableMeta.schema }));
tableMeta = tableMetaForDataTab(tab) ?? tableMeta;
}
clearInvalidDataTabSortState(tab, tableMeta.columns);
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 ?? tableOpenPageLimit(settingsStore.editorSettings.tableOpenPageSize);
const offset = tab.resultPageOffset ?? 0;
const useDriverRowOffset = conn?.db_type === "jdbc" && effectiveDbType === "iris";
const sql = await buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: conn?.driver_profile,
@@ -2913,6 +2943,21 @@ export const useQueryStore = defineStore("query", () => {
releaseTabsWhere((tab) => tab.connectionId === connectionId && tab.database === database);
}
/**
* 连接生命周期边界(断开连接 / 关闭数据库连接 / 后端连接池失效重连)。
* 数据标签页的 tableMeta 为展示/编辑保留(不清除 UI、主键与编辑安全门控),
* 但清掉 freshness 戳:此后 openData 的 tab-local 暖缓存判定、激活路径的
* stale 判定、以及网格 reload 的 metadata age 判定全部按"冷缓存"处理,
* 即使位于 30s TTL 窗口内也会重新拉取结构(issue #6623)。
*/
function staleConnectionDataTabMetadata(connectionId: string, database?: string) {
for (const tab of tabs.value) {
if (tab.mode !== "data" || tab.connectionId !== connectionId) continue;
if (database != null && tab.database !== database) continue;
tab.tableMetaUpdatedAt = undefined;
}
}
function isDatabaseOpen(connectionId: string, database: string) {
return openDatabaseKeys.value.has(`${connectionId}\x00${database}`);
}
@@ -3297,6 +3342,10 @@ export const useQueryStore = defineStore("query", () => {
const tab = tabs.value.find((t) => t.id === id);
if (tab) {
tab.tableMeta = meta;
// 记录写入时的连接元数据代次:disconnect/关库/死池重连会使该代次递增,
// 代次失配视同冷缓存,即使位于 30s TTL 窗口内也会重建结构(issue #6623 /
// PR #6640)。同一代次内的多次写入与连接Store保持一致,无需额外入参。
tab.tableMetaGeneration = useConnectionStore().metadataGenerationFor(tab.connectionId, tab.database) ?? 0;
tab.tableMetaUpdatedAt = Date.now();
if (meta.columns.length > 0) clearInvalidDataTabSortState(tab, meta.columns);
// 只有真实元数据(columns 非空)落地才结束行标识等待;多处调用方会先写
@@ -6255,6 +6304,7 @@ export const useQueryStore = defineStore("query", () => {
refreshDataTabsForTable,
releaseConnectionTabs,
releaseDatabaseTabs,
staleConnectionDataTabMetadata,
isDatabaseOpen,
openDatabaseKeys,
rollbackConnectionTransactions,