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。

feat(grid): remember sql result column widths

lxk955f77ddbce356e
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index e47cfef94d..e8b30cbd63 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -2744,12 +2744,11 @@ const columnWidthMode = computed(() => settingsStore.editorSettings.dataGridColu
const tableFontFamily = computed(() => settingsStore.editorSettings.tableFontFamily);
const columnWidthCacheKey = computed(() => props.columnWidthCacheKey?.trim() || props.cacheKey?.trim() || undefined);
const columnStructureSignature = computed(() => createDataGridColumnStructureSignature(props.result.columns, props.result.column_types));
-// Bumped once the configured header font is ready, so widths measured against a temporary fallback
-// font get re-measured without reacting to unrelated fonts loaded elsewhere in the application.
-const dataGridFontReadyTick = ref(0);
-const columnFormatterReadyTick = ref(0);
-const columnHeaderMeasurementKey = computed(() => [tableFontSize.value, tableFontFamily.value, dataGridFontReadyTick.value, columnFormatterReadyTick.value]);
+// The configured header font is re-measured once ready (grown-only, never clearing user
+// adjustments), without reacting to unrelated fonts loaded elsewhere in the application.
+const columnHeaderMeasurementKey = computed(() => [tableFontSize.value, tableFontFamily.value]);
let columnHeaderMeasureContext: CanvasRenderingContext2D | null | undefined;
+let triggerGrowColumnWidths: (() => void) | undefined;
if (typeof document !== "undefined" && document.fonts) {
let fontLoadRequestId = 0;
@@ -2762,7 +2761,9 @@ if (typeof document !== "undefined" && document.fonts) {
} catch {
return;
}
- if (requestId === fontLoadRequestId) dataGridFontReadyTick.value++;
+ if (requestId === fontLoadRequestId) {
+ triggerGrowColumnWidths?.();
+ }
},
{ immediate: true },
);
@@ -2787,7 +2788,7 @@ function columnWidthDisplayValue(value: CellValue, columnIndex: number): CellVal
return showWhitespaceEnabled.value && typeof display === "string" ? gridCellDisplayValue(display, flatteningMultiLineEnabled.value, true) : display;
}
-const { initColumnWidths, onResizeStart, autoFitColumn, autoFitAllColumns, renderedColumnWidths, totalWidth, columnVars, getIsResizing } = useDataGridColumnResize({
+const { initColumnWidths, growColumnWidthsToFitSamples, onResizeStart, autoFitColumn, autoFitAllColumns, renderedColumnWidths, totalWidth, columnVars, getIsResizing } = useDataGridColumnResize({
columns: visibleColumns,
sourceRows: computed(() => props.result.rows),
columnIndexes: visibleColumnIndexes,
@@ -2803,6 +2804,7 @@ const { initColumnWidths, onResizeStart, autoFitColumn, autoFitAllColumns, rende
viewportWidth: gridViewportWidth,
displayValue: columnWidthDisplayValue,
});
+triggerGrowColumnWidths = growColumnWidthsToFitSamples;
const gridStyle = computed(() => ({
...columnVars.value,
"--header-total-w": dataGridHeaderContentWidth("var(--total-w)", gridScrollbarGutter.value),
@@ -5680,7 +5682,6 @@ const {
toast,
});
columnFormatterForWidth = columnFormatter;
-columnFormatterReadyTick.value++;
initColumnWidths();
watch([visibleColumnIndexes, () => renderedColumnWidths.value.length], () => scheduleColumnLayoutRefresh());
diff --git a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts
index d50700da03..64132287d8 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts
@@ -348,6 +348,33 @@ describe("useDataGridColumnResize", () => {
expect(remounted.columnWidths.value).toEqual(first.columnWidths.value);
});
+ it("restores adjusted column widths for external SQL file executions across tab reopens", () => {
+ const firstTab = { id: "tab-instance-1", externalSqlPath: "/queries/monthly_report.sql", activeResultIndex: 0 };
+ const secondTab = { id: "tab-instance-2", externalSqlPath: "/queries/monthly_report.sql", activeResultIndex: 0 };
+ const firstKey = resultGridColumnWidthCacheKey(firstTab);
+ const secondKey = resultGridColumnWidthCacheKey(secondTab);
+
+ expect(secondKey).toBe(firstKey);
+
+ const firstGrid = createResizeState({
+ columns: ["id", "report_data"],
+ rows: [[1, "summary"]],
+ cacheKey: firstKey,
+ });
+ firstGrid.initColumnWidths();
+ firstGrid.onResizeStart(1, new MouseEvent("mousedown", { clientX: 100, cancelable: true }));
+ document.dispatchEvent(new MouseEvent("mouseup", { clientX: 350 }));
+
+ const secondGrid = createResizeState({
+ columns: ["id", "report_data"],
+ rows: [[2, "another summary"]],
+ cacheKey: secondKey,
+ });
+ secondGrid.initColumnWidths();
+
+ expect(secondGrid.columnWidths.value[1]).toBe(firstGrid.columnWidths.value[1]);
+ });
+
it("isolates widths by result cache key", () => {
const first = createResizeState({ columns: ["id"], rows: [["x".repeat(120)]], cacheKey: "result-a" });
first.initColumnWidths();
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.ts
new file mode 100644
index 0000000000..f0111f41b1
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.ts
@@ -0,0 +1,88 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { clearDataGridColumnWidthStates, createDataGridColumnMeasurementSignature, createDataGridColumnStructureSignature, DATA_GRID_COLUMN_WIDTH_STATE_LIMIT, loadDataGridColumnWidthState, removeDataGridColumnWidthState, saveDataGridColumnWidthState } from "@/lib/dataGrid/dataGridColumnWidthState";
+
+describe("dataGridColumnWidthState", () => {
+ const structureSignature = createDataGridColumnStructureSignature(["id", "name"], ["INT", "VARCHAR"]);
+ const measurementSignature = createDataGridColumnMeasurementSignature("standard", true, [12, "Inter"]);
+
+ beforeEach(() => {
+ localStorage.clear();
+ clearDataGridColumnWidthStates();
+ });
+
+ it("stores and retrieves column width state in memory", () => {
+ const identity = { cacheKey: "result-1", structureSignature, measurementSignature };
+ saveDataGridColumnWidthState(identity, [0, 1], [100, 250], new Set([1]));
+
+ const loaded = loadDataGridColumnWidthState(identity, [0, 1]);
+ expect(loaded?.widths).toEqual([100, 250]);
+ expect(loaded?.userSizedColumnIndexes).toEqual(new Set([1]));
+ });
+
+ it("persists user-sized column widths to localStorage and restores them when in-memory cache is cold", async () => {
+ const identity = { cacheKey: "result-file-/queries/test.sql-0", structureSignature, measurementSignature };
+ saveDataGridColumnWidthState(identity, [0, 1], [120, 300], new Set([1]));
+
+ // Emulate new session or cold in-memory cache
+ const rawSaved = localStorage.getItem("dbx-data-grid-column-widths:result-file-/queries/test.sql-0");
+ expect(rawSaved).toBeTruthy();
+
+ // Simulate an app restart: fresh module instance => empty in-memory map, same localStorage.
+ vi.resetModules();
+ const fresh = await import("@/lib/dataGrid/dataGridColumnWidthState");
+ const coldIdentity = { cacheKey: "result-file-/queries/test.sql-0", structureSignature, measurementSignature };
+ expect(fresh.dataGridColumnWidthStateCount()).toBe(0);
+ const reloaded = fresh.loadDataGridColumnWidthState(coldIdentity, [0, 1]);
+ expect(reloaded?.widths).toEqual([120, 300]);
+ expect(reloaded?.userSizedColumnIndexes).toEqual(new Set([1]));
+ });
+
+ it("does not persist to localStorage if no columns are user-sized", () => {
+ const identity = { cacheKey: "auto-fit-only", structureSignature, measurementSignature };
+ saveDataGridColumnWidthState(identity, [0, 1], [80, 150], new Set());
+
+ expect(localStorage.getItem("dbx-data-grid-column-widths:auto-fit-only")).toBeNull();
+ });
+
+ it("removes from localStorage when removeDataGridColumnWidthState is called", () => {
+ const identity = { cacheKey: "to-remove", structureSignature, measurementSignature };
+ saveDataGridColumnWidthState(identity, [0, 1], [100, 200], new Set([0, 1]));
+ expect(localStorage.getItem("dbx-data-grid-column-widths:to-remove")).toBeTruthy();
+
+ removeDataGridColumnWidthState("to-remove");
+ expect(localStorage.getItem("dbx-data-grid-column-widths:to-remove")).toBeNull();
+ expect(loadDataGridColumnWidthState(identity, [0, 1])).toBeUndefined();
+ });
+
+ it("rejects persisted widths when structure signature does not match", () => {
+ const identity = { cacheKey: "result-file-modified", structureSignature, measurementSignature };
+ saveDataGridColumnWidthState(identity, [0, 1], [100, 200], new Set([1]));
+
+ const differentStructure = createDataGridColumnStructureSignature(["id", "name", "email"]);
+ const loaded = loadDataGridColumnWidthState({ cacheKey: "result-file-modified", structureSignature: differentStructure, measurementSignature }, [0, 1, 2]);
+ expect(loaded).toBeUndefined();
+ });
+
+ it("rejects persisted widths when measurement signature does not match", () => {
+ const identity = { cacheKey: "result-font-change", structureSignature, measurementSignature };
+ saveDataGridColumnWidthState(identity, [0, 1], [100, 200], new Set([1]));
+
+ const differentMeasurement = createDataGridColumnMeasurementSignature("standard", true, [16, "Roboto"]);
+ const loaded = loadDataGridColumnWidthState({ cacheKey: "result-font-change", structureSignature, measurementSignature: differentMeasurement }, [0, 1]);
+ expect(loaded).toBeUndefined();
+ });
+
+ it("evicts oldest localStorage entries when exceeding state limit", () => {
+ for (let i = 0; i < DATA_GRID_COLUMN_WIDTH_STATE_LIMIT + 5; i++) {
+ saveDataGridColumnWidthState({ cacheKey: `item-${i}`, structureSignature, measurementSignature }, [0], [100 + i], new Set([0]));
+ }
+
+ // Earliest 5 should be evicted from localStorage
+ expect(localStorage.getItem("dbx-data-grid-column-widths:item-0")).toBeNull();
+ expect(localStorage.getItem("dbx-data-grid-column-widths:item-4")).toBeNull();
+ // Latest should exist
+ expect(localStorage.getItem(`dbx-data-grid-column-widths:item-${DATA_GRID_COLUMN_WIDTH_STATE_LIMIT + 4}`)).toBeTruthy();
+ });
+});
diff --git a/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts b/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts
index 6ae7c65bb6..c982f1585d 100644
--- a/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts
+++ b/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts
@@ -310,6 +310,26 @@ describe("query result grid identity", () => {
expect(resultGridColumnWidthCacheKey(rerun)).toBe(resultGridColumnWidthCacheKey(first));
expect(resultGridColumnWidthCacheKey({ ...first, activeResultIndex: 1 })).not.toBe(resultGridColumnWidthCacheKey(first));
});
+
+ it("identifies external SQL file tabs stably across different tab IDs and normalizes paths", () => {
+ const tab1 = queryTab({ id: "tab-uuid-1", externalSqlPath: "/workspace/query.sql", activeResultIndex: 0 });
+ const tab2 = queryTab({ id: "tab-uuid-2", externalSqlPath: "\\workspace\\query.sql", activeResultIndex: 0 });
+ const tabOtherResult = queryTab({ id: "tab-uuid-3", externalSqlPath: "/workspace/query.sql", activeResultIndex: 1 });
+
+ expect(resultGridColumnWidthCacheKey(tab1)).toBe("result-column-width-file-/workspace/query.sql-0");
+ expect(resultGridColumnWidthCacheKey(tab2)).toBe(resultGridColumnWidthCacheKey(tab1));
+ expect(resultGridColumnWidthCacheKey(tabOtherResult)).toBe("result-column-width-file-/workspace/query.sql-1");
+ });
+
+ it("identifies saved SQL queries stably across different tab IDs", () => {
+ const tab1 = queryTab({ id: "tab-uuid-1", savedSqlId: "saved-sql-42", activeResultIndex: 0 });
+ const tab2 = queryTab({ id: "tab-uuid-2", savedSqlId: "saved-sql-42", activeResultIndex: 0 });
+ const tabOtherResult = queryTab({ id: "tab-uuid-3", savedSqlId: "saved-sql-42", activeResultIndex: 2 });
+
+ expect(resultGridColumnWidthCacheKey(tab1)).toBe("result-column-width-saved-saved-sql-42-0");
+ expect(resultGridColumnWidthCacheKey(tab2)).toBe(resultGridColumnWidthCacheKey(tab1));
+ expect(resultGridColumnWidthCacheKey(tabOtherResult)).toBe("result-column-width-saved-saved-sql-42-2");
+ });
});
describe("result run labels", () => {
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts
index 4d6c15b17c..63e258c05d 100644
--- a/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts
@@ -1,6 +1,9 @@
+import { safeLocalStorageGet, safeLocalStorageRemove, safeLocalStorageSet } from "@/lib/backend/safeStorage";
import type { ColumnWidthDensity } from "@/stores/settingsStore";
export const DATA_GRID_COLUMN_WIDTH_STATE_LIMIT = 128;
+const STORAGE_PREFIX = "dbx-data-grid-column-widths:";
+const STORAGE_INDEX_KEY = "dbx-data-grid-column-widths-index";
interface DataGridColumnWidthState {
structureSignature: string;
@@ -9,6 +12,14 @@ interface DataGridColumnWidthState {
userSizedColumnIndexes: Set<number>;
}
+interface StoredDataGridColumnWidthState {
+ version: number;
+ structureSignature: string;
+ measurementSignature: string;
+ widths: Array<[number, number]>;
+ userSizedColumnIndexes: number[];
+}
+
interface DataGridColumnWidthStateIdentity {
cacheKey?: string;
structureSignature: string;
@@ -27,6 +38,93 @@ function touchColumnWidthState(cacheKey: string, state: DataGridColumnWidthState
columnWidthStates.set(cacheKey, state);
}
+function loadStorageIndex(): string[] {
+ const raw = safeLocalStorageGet(STORAGE_INDEX_KEY);
+ if (!raw) return [];
+ try {
+ const parsed = JSON.parse(raw);
+ return Array.isArray(parsed) ? parsed.filter((key): key is string => typeof key === "string") : [];
+ } catch {
+ return [];
+ }
+}
+
+function saveStorageIndex(index: string[]) {
+ safeLocalStorageSet(STORAGE_INDEX_KEY, JSON.stringify(index));
+}
+
+function touchStorageKey(cacheKey: string) {
+ const index = loadStorageIndex().filter((key) => key !== cacheKey);
+ index.push(cacheKey);
+ while (index.length > DATA_GRID_COLUMN_WIDTH_STATE_LIMIT) {
+ const oldest = index.shift();
+ if (oldest) safeLocalStorageRemove(`${STORAGE_PREFIX}${oldest}`);
+ }
+ saveStorageIndex(index);
+}
+
+function removeStorageKey(cacheKey: string) {
+ const index = loadStorageIndex().filter((key) => key !== cacheKey);
+ saveStorageIndex(index);
+ safeLocalStorageRemove(`${STORAGE_PREFIX}${cacheKey}`);
+}
+
+function loadPersistentDataGridColumnWidthState(cacheKey: string): DataGridColumnWidthState | undefined {
+ const raw = safeLocalStorageGet(`${STORAGE_PREFIX}${cacheKey}`);
+ if (!raw) return undefined;
+ try {
+ const parsed = JSON.parse(raw) as Partial<StoredDataGridColumnWidthState>;
+ if (parsed.version !== 1 || typeof parsed.structureSignature !== "string" || typeof parsed.measurementSignature !== "string" || !Array.isArray(parsed.widths) || !Array.isArray(parsed.userSizedColumnIndexes)) {
+ removeStorageKey(cacheKey);
+ return undefined;
+ }
+ const widthsByColumnIndex = new Map<number, number>();
+ for (const entry of parsed.widths) {
+ if (Array.isArray(entry) && typeof entry[0] === "number" && typeof entry[1] === "number" && Number.isFinite(entry[1])) {
+ widthsByColumnIndex.set(entry[0], entry[1]);
+ }
+ }
+ const userSizedColumnIndexes = new Set<number>();
+ for (const index of parsed.userSizedColumnIndexes) {
+ if (typeof index === "number") userSizedColumnIndexes.add(index);
+ }
+ touchStorageKey(cacheKey);
+ return {
+ structureSignature: parsed.structureSignature,
+ measurementSignature: parsed.measurementSignature,
+ widthsByColumnIndex,
+ userSizedColumnIndexes,
+ };
+ } catch {
+ removeStorageKey(cacheKey);
+ return undefined;
+ }
+}
+
+function savePersistentDataGridColumnWidthState(cacheKey: string, state: DataGridColumnWidthState) {
+ const payload: StoredDataGridColumnWidthState = {
+ version: 1,
+ structureSignature: state.structureSignature,
+ measurementSignature: state.measurementSignature,
+ widths: Array.from(state.widthsByColumnIndex.entries()),
+ userSizedColumnIndexes: Array.from(state.userSizedColumnIndexes),
+ };
+ safeLocalStorageSet(`${STORAGE_PREFIX}${cacheKey}`, JSON.stringify(payload));
+ touchStorageKey(cacheKey);
+}
+
+function removePersistentDataGridColumnWidthState(cacheKey: string) {
+ removeStorageKey(cacheKey);
+}
+
+function clearPersistentDataGridColumnWidthStates() {
+ const index = loadStorageIndex();
+ for (const key of index) {
+ safeLocalStorageRemove(`${STORAGE_PREFIX}${key}`);
+ }
+ safeLocalStorageRemove(STORAGE_INDEX_KEY);
+}
+
export function createDataGridColumnStructureSignature(columns: readonly string[], columnTypes?: readonly (string | undefined)[]): string {
return JSON.stringify(columns.map((column, index) => [column, columnTypes?.[index] ?? ""]));
}
@@ -38,10 +136,17 @@ export function createDataGridColumnMeasurementSignature(density: ColumnWidthDen
export function loadDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[]): DataGridColumnWidthStateSnapshot | undefined {
const cacheKey = identity.cacheKey?.trim();
if (!cacheKey) return undefined;
- const state = columnWidthStates.get(cacheKey);
+ let state = columnWidthStates.get(cacheKey);
+ if (!state) {
+ state = loadPersistentDataGridColumnWidthState(cacheKey);
+ if (state) {
+ columnWidthStates.set(cacheKey, state);
+ }
+ }
if (!state) return undefined;
if (state.structureSignature !== identity.structureSignature || state.measurementSignature !== identity.measurementSignature) {
columnWidthStates.delete(cacheKey);
+ removePersistentDataGridColumnWidthState(cacheKey);
return undefined;
}
touchColumnWidthState(cacheKey, state);
@@ -54,7 +159,7 @@ export function loadDataGridColumnWidthState(identity: DataGridColumnWidthStateI
export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[], widths: readonly number[], userSizedColumnIndexes: ReadonlySet<number>) {
const cacheKey = identity.cacheKey?.trim();
if (!cacheKey || columnIndexes.length !== widths.length) return;
- const existing = columnWidthStates.get(cacheKey);
+ const existing = columnWidthStates.get(cacheKey) ?? loadPersistentDataGridColumnWidthState(cacheKey);
const widthsByColumnIndex = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Map(existing.widthsByColumnIndex) : new Map<number, number>();
const nextUserSizedColumnIndexes = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Set(existing.userSizedColumnIndexes) : new Set<number>();
columnIndexes.forEach((columnIndex, visibleIndex) => {
@@ -63,13 +168,18 @@ export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateI
if (userSizedColumnIndexes.has(columnIndex)) nextUserSizedColumnIndexes.add(columnIndex);
else nextUserSizedColumnIndexes.delete(columnIndex);
});
- touchColumnWidthState(cacheKey, {
+ const nextState: DataGridColumnWidthState = {
structureSignature: identity.structureSignature,
measurementSignature: identity.measurementSignature,
widthsByColumnIndex,
userSizedColumnIndexes: nextUserSizedColumnIndexes,
- });
- // Query result keys are session-scoped, so bound the in-memory cache instead of relying on store cleanup paths.
+ };
+ touchColumnWidthState(cacheKey, nextState);
+ if (nextUserSizedColumnIndexes.size > 0) {
+ savePersistentDataGridColumnWidthState(cacheKey, nextState);
+ } else {
+ removePersistentDataGridColumnWidthState(cacheKey);
+ }
while (columnWidthStates.size > DATA_GRID_COLUMN_WIDTH_STATE_LIMIT) {
const oldestCacheKey = columnWidthStates.keys().next().value;
if (oldestCacheKey === undefined) break;
@@ -79,11 +189,15 @@ export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateI
export function removeDataGridColumnWidthState(cacheKey?: string) {
const normalizedCacheKey = cacheKey?.trim();
- if (normalizedCacheKey) columnWidthStates.delete(normalizedCacheKey);
+ if (normalizedCacheKey) {
+ columnWidthStates.delete(normalizedCacheKey);
+ removePersistentDataGridColumnWidthState(normalizedCacheKey);
+ }
}
export function clearDataGridColumnWidthStates() {
columnWidthStates.clear();
+ clearPersistentDataGridColumnWidthStates();
}
export function dataGridColumnWidthStateCount(): number {
diff --git a/apps/desktop/src/lib/tabs/tabPresentation.ts b/apps/desktop/src/lib/tabs/tabPresentation.ts
index 45535df0c4..d7f4edb1e2 100644
--- a/apps/desktop/src/lib/tabs/tabPresentation.ts
+++ b/apps/desktop/src/lib/tabs/tabPresentation.ts
@@ -12,6 +12,7 @@ import { sqlTextFingerprint } from "@/lib/sql/sqlTextFingerprint";
import { isQueryExecutionErrorResult } from "@/lib/query/queryResultError";
import type { SqlErrorPosition } from "@/lib/backend/errorUtils";
import { queryResultSourceNameParts } from "@/lib/sql/queryResultSource";
+import { normalizeExternalSqlPath } from "@/lib/sql/sqlFileOpen";
import type { BatchSqlExecution, ConnectionConfig, DatabaseType, QueryResult, QueryResultRun, QueryTab } from "@/types/database";
import type { ResultTabNamingMode } from "@/stores/settingsStore";
@@ -664,8 +665,15 @@ export function resultGridCacheKey(tab: Pick<QueryTab, "id" | "activeResultRunId
return `${tab.id}-${tab.activeResultRunId ?? "current"}-${tab.activeResultIndex ?? 0}`;
}
-export function resultGridColumnWidthCacheKey(tab: Pick<QueryTab, "id"> & Partial<Pick<QueryTab, "activeResultIndex">>): string {
- return `result-column-width-${tab.id}-${tab.activeResultIndex ?? 0}`;
+export function resultGridColumnWidthCacheKey(tab: Pick<QueryTab, "id"> & Partial<Pick<QueryTab, "activeResultIndex" | "externalSqlPath" | "savedSqlId">>): string {
+ const resultIndex = tab.activeResultIndex ?? 0;
+ if (tab.externalSqlPath) {
+ return `result-column-width-file-${normalizeExternalSqlPath(tab.externalSqlPath)}-${resultIndex}`;
+ }
+ if (tab.savedSqlId) {
+ return `result-column-width-saved-${tab.savedSqlId}-${resultIndex}`;
+ }
+ return `result-column-width-${tab.id}-${resultIndex}`;
}
export function resultGridInstanceKey(tab: Pick<QueryTab, "id" | "activeResultRunId" | "activeResultIndex" | "resultGridRevision">): string {