fix(memory): release closed query and connection resources

This commit is contained in:
zipg authored and GitHub committed 2026-08-25 15:47:23 +08:00
1 parent 88e659833d
commit 81c3cc15d2
12 files changed
+477 -32

No files matched your search

@@ -1,11 +1,13 @@
import { beforeEach, describe, expect, it } from "vitest";
import { loadDataGridStructuredFilterState, saveDataGridStructuredFilterState } from "@/lib/dataGrid/dataGridFilterBuilderPersistence";
import { clearDataGridStructuredFilterStatesForTab, loadDataGridStructuredFilterState, saveDataGridStructuredFilterState } from "@/lib/dataGrid/dataGridFilterBuilderPersistence";
describe("data grid structured filter persistence", () => {
const cacheKey = "issue-436-filter-view";
const scopeKey = "mysql\0demo\0users";
beforeEach(() => {
clearDataGridStructuredFilterStatesForTab("issue-436-filter-view");
clearDataGridStructuredFilterStatesForTab("lru-tab");
saveDataGridStructuredFilterState(cacheKey, {
scopeKey,
manualWhereInput: "tenant_id = 7",
@@ -36,4 +38,44 @@ describe("data grid structured filter persistence", () => {
serverColumnFilters: {},
});
});
it("clears every result-grid state owned by a closed tab", () => {
saveDataGridStructuredFilterState("tab-1-run-1-0", {
scopeKey,
manualWhereInput: "id > 1",
rules: [],
appliedWhereInput: "id > 1",
serverColumnFilters: {},
});
saveDataGridStructuredFilterState("tab-10-run-1-0", {
scopeKey,
manualWhereInput: "id > 10",
rules: [],
appliedWhereInput: "id > 10",
serverColumnFilters: {},
});
clearDataGridStructuredFilterStatesForTab("tab-1");
expect(loadDataGridStructuredFilterState("tab-1-run-1-0", scopeKey)).toBeUndefined();
expect(loadDataGridStructuredFilterState("tab-10-run-1-0", scopeKey)?.manualWhereInput).toBe("id > 10");
clearDataGridStructuredFilterStatesForTab("tab-10");
});
it("bounds cached result-grid states and refreshes recency on read", () => {
const state = {
scopeKey,
manualWhereInput: "",
rules: [],
appliedWhereInput: "",
serverColumnFilters: {},
};
for (let index = 0; index < 128; index += 1) saveDataGridStructuredFilterState(`lru-tab-${index}`, state);
expect(loadDataGridStructuredFilterState("lru-tab-0", scopeKey)).toBeDefined();
saveDataGridStructuredFilterState("lru-tab-128", state);
expect(loadDataGridStructuredFilterState("lru-tab-0", scopeKey)).toBeDefined();
expect(loadDataGridStructuredFilterState("lru-tab-1", scopeKey)).toBeUndefined();
});
});
@@ -14,6 +14,7 @@ export type DataGridStructuredFilterCacheState = {
serverColumnFilters: Record<number, DataGridCachedServerColumnFilter>;
};
const STRUCTURED_FILTER_STATE_CACHE_MAX_ENTRIES = 128;
const structuredFilterStateCache = new Map<string, DataGridStructuredFilterCacheState>();
export function cloneDataGridStructuredFilterRules(rules: readonly DataGridStructuredFilterRule[]): DataGridStructuredFilterRule[] {
@@ -23,6 +24,8 @@ export function cloneDataGridStructuredFilterRules(rules: readonly DataGridStruc
export function loadDataGridStructuredFilterState(cacheKey: string, scopeKey: string): DataGridStructuredFilterCacheState | undefined {
const cached = structuredFilterStateCache.get(cacheKey);
if (!cached || cached.scopeKey !== scopeKey) return undefined;
structuredFilterStateCache.delete(cacheKey);
structuredFilterStateCache.set(cacheKey, cached);
return {
...cached,
rules: cloneDataGridStructuredFilterRules(cached.rules),
@@ -31,9 +34,22 @@ export function loadDataGridStructuredFilterState(cacheKey: string, scopeKey: st
}
export function saveDataGridStructuredFilterState(cacheKey: string, state: DataGridStructuredFilterCacheState) {
structuredFilterStateCache.delete(cacheKey);
structuredFilterStateCache.set(cacheKey, {
...state,
rules: cloneDataGridStructuredFilterRules(state.rules),
serverColumnFilters: structuredClone(state.serverColumnFilters),
});
while (structuredFilterStateCache.size > STRUCTURED_FILTER_STATE_CACHE_MAX_ENTRIES) {
const oldest = structuredFilterStateCache.keys().next().value;
if (oldest === undefined) break;
structuredFilterStateCache.delete(oldest);
}
}
export function clearDataGridStructuredFilterStatesForTab(tabId: string) {
structuredFilterStateCache.delete(tabId);
for (const cacheKey of structuredFilterStateCache.keys()) {
if (cacheKey.startsWith(`${tabId}-`)) structuredFilterStateCache.delete(cacheKey);
}
}
@@ -94,6 +94,17 @@ describe("objectBrowserRowsCache", () => {
expect(getCachedObjectBrowserRows(isolatedScope)).toEqual([row]);
});
it("rejects old write tokens after their bounded generation state is evicted", () => {
const staleScope = { connectionId: "stale", database: "db", schema: "public" };
const staleToken = createObjectBrowserRowsCacheWriteToken(staleScope);
for (let index = 0; index < 128; index += 1) {
createObjectBrowserRowsCacheWriteToken({ connectionId: `c${index}`, database: "db", schema: "public" });
}
expect(cacheObjectBrowserRows(staleToken, [row])).toBeUndefined();
expect(getCachedObjectBrowserRows(staleScope)).toBeUndefined();
});
it("preserves the original object list freshness when statistics update cached rows", () => {
vi.useFakeTimers();
vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
+9 -1
View File
@@ -5070,12 +5070,20 @@ function computeBoost(candidate: string, prefix: string): number {
}
// --- History-based ranking ---
const COMPLETION_STATS_MAX_ENTRIES = 512;
const completionStats = new Map<string, number>();
/** Record a user selection to boost future rankings. */
export function recordCompletionSelection(label: string, type: string): void {
const key = `${type}:${label}`;
completionStats.set(key, (completionStats.get(key) || 0) + 1);
const count = completionStats.get(key) || 0;
completionStats.delete(key);
completionStats.set(key, count + 1);
while (completionStats.size > COMPLETION_STATS_MAX_ENTRIES) {
const oldest = completionStats.keys().next().value;
if (oldest === undefined) break;
completionStats.delete(oldest);
}
}
function getHistoryBoost(label: string, type: string): number {
@@ -4,6 +4,7 @@ import type { ObjectBrowserRow } from "@/lib/table/objectBrowserRows";
const OBJECT_BROWSER_ROWS_CACHE_TTL_MS = 30_000;
const OBJECT_BROWSER_ROWS_CACHE_MAX_ENTRIES = 24;
const OBJECT_BROWSER_ROWS_GENERATION_MAX_ENTRIES = 128;
export interface ObjectBrowserRowsCacheScope {
connectionId: string;
@@ -28,6 +29,7 @@ const objectBrowserRowsCache = new MetadataResultCache<ObjectBrowserRow[]>({
now: () => Date.now(),
});
const objectBrowserRowsCacheGenerations = new Map<string, ObjectBrowserRowsCacheGeneration>();
let nextObjectBrowserRowsCacheGeneration = 0;
function objectBrowserRowsScope(scope: ObjectBrowserRowsCacheScope): MetadataScopeInput {
return {
@@ -48,7 +50,15 @@ function objectBrowserRowsCacheGeneration(scope: ObjectBrowserRowsCacheScope): O
const key = metadataScopeKey(cacheScope);
let state = objectBrowserRowsCacheGenerations.get(key);
if (!state) {
state = { generation: 0, scope: metadataScopeParts(cacheScope) };
state = { generation: ++nextObjectBrowserRowsCacheGeneration, scope: metadataScopeParts(cacheScope) };
objectBrowserRowsCacheGenerations.set(key, state);
while (objectBrowserRowsCacheGenerations.size > OBJECT_BROWSER_ROWS_GENERATION_MAX_ENTRIES) {
const oldest = objectBrowserRowsCacheGenerations.keys().next().value;
if (oldest === undefined) break;
objectBrowserRowsCacheGenerations.delete(oldest);
}
} else {
objectBrowserRowsCacheGenerations.delete(key);
objectBrowserRowsCacheGenerations.set(key, state);
}
return state;
@@ -83,13 +93,13 @@ export function cacheObjectBrowserRows(token: ObjectBrowserRowsCacheWriteToken,
export function invalidateObjectBrowserRowsCache(match: MetadataCacheInvalidation): number {
const projected = objectBrowserRowsCacheInvalidation(match);
const matches = metadataCacheInvalidationMatcher(projected);
for (const state of objectBrowserRowsCacheGenerations.values()) {
if (matches(state.scope)) state.generation++;
for (const [key, state] of objectBrowserRowsCacheGenerations) {
if (matches(state.scope)) objectBrowserRowsCacheGenerations.delete(key);
}
return objectBrowserRowsCache.invalidate(projected);
}
export function clearObjectBrowserRowsCache(): void {
objectBrowserRowsCache.clear();
for (const state of objectBrowserRowsCacheGenerations.values()) state.generation++;
objectBrowserRowsCacheGenerations.clear();
}