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): speed up join header comments and show type lengths

Mo-Moore741b10b435f8
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index 78e24b0e99..07c88ef335 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -118,7 +118,7 @@ import { buildTableSelectSql, qualifyTableReferencesInSql, quoteTableDataIdentif
import { uuid } from "@/lib/common/utils";
import { generateCellValues, type CellValueGenerationKind, type CellValueGenerationOptions } from "@/lib/dataGrid/cellValueGeneration";
import { MONGO_DOCUMENT_GRID_NULL, mongoDocumentGridClipboardText, mongoDocumentGridDisplayText, mongoDocumentGridEditorText, mongoDocumentGridExternalValue, mongoDocumentGridInputValue, mongoDocumentGridNumericValue, mongoDocumentRelaxedExtendedJson } from "@/lib/mongo/mongoDocumentValues";
-import { compactHeaderColumnType, formatMetadataColumnTypeLabel, isNumericColumnType, resolveDataGridTypeVisualKind, resolveHeaderColumnType, resolveResultColumnType } from "@/lib/dataGrid/dataGridColumnType";
+import { compactHeaderColumnType, formatMetadataColumnTypeLabel, isNumericColumnType, resolveDataGridTypeVisualKind, resolveHeaderColumnType, resolveResultColumnType, shortHeaderTypeName } from "@/lib/dataGrid/dataGridColumnType";
import { dataGridCellTextClass, dataGridTypeVisualClass } from "@/lib/dataGrid/dataGridCellTextVisual";
import { DATA_GRID_TYPE_COLOR_KEYS, resolveActiveDataGridTypeColors } from "@/lib/dataGrid/dataGridTypeColorScheme";
import {
@@ -520,6 +520,11 @@ interface DataGridProps {
* or computed) — the grid shows no comment instead of a wrong one.
*/
resultColumnComments?: Array<string | undefined>;
+ /**
+ * Display-only type labels from multi-source enrichment (by result ordinal),
+ * carrying declared length/precision when ResultSet column_types omit them.
+ */
+ resultColumnTypeLabels?: Array<string | undefined>;
/**
* Display-only result-column -> source mapping for multi-source results,
* indexed by result-column ordinal; each entry carries the source identity
@@ -902,6 +907,7 @@ function headerColumnType(column: string, actualColIdx: number): string {
if (!showColumnTypesInHeader.value) return "";
const resolved = resolveHeaderColumnType({
tableColumnType: columnTypeMap.value.get(column),
+ displayColumnType: props.resultColumnTypeLabels?.[actualColIdx],
resultColumnTypes: props.result.column_types,
actualColIdx,
});
@@ -917,18 +923,6 @@ const reserveColumnTypeLine = computed(() => reserveDataGridHeaderLine(showColum
const reserveColumnCommentLine = computed(() => reserveDataGridHeaderLine(showColumnCommentsInHeader.value, props.result.columns, (column, index) => headerColumnComment(column, index)));
function shortTypeName(t: string): string {
- const s = t.toLowerCase();
- if (s === "character varying") return "varchar";
- if (s === "character") return "char";
- if (s === "double precision") return "double";
- if (s === "timestamp without time zone") return "timestamp";
- if (s === "timestamp with time zone") return "timestamptz";
- if (s === "time without time zone") return "time";
- if (s === "time with time zone") return "timetz";
- if (s === "boolean") return "bool";
- if (s === "integer") return "int";
- if (s === "smallint") return "int2";
- if (s === "real") return "float4";
// GaussDB M mode uses MySQL-style type names
if (resolvedDatabaseType.value === "gaussdb") {
const conn = resolvedConnectionConfig.value;
@@ -936,7 +930,7 @@ function shortTypeName(t: string): string {
return gaussdbMTypeDisplayName(t);
}
}
- return t;
+ return shortHeaderTypeName(t);
}
function gaussdbMColumnType(dataType: string): string {
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index d2c61da232..2617d64d58 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -2735,6 +2735,7 @@ defineExpose({
:has-unique-query-insert-target="!!activeTab.tableMeta && activeTab.queryAnalysis?.multiSource !== true && (activeTab.queryAnalysis?.sources?.length ?? 1) === 1 && (activeTab.queryWriteTargets?.length ?? 1) <= 1"
:readonly-column-indexes="hasNeo4jNodes ? undefined : groupedQueryReadonlyColumnIndexes(activeTab)"
:result-column-comments="hasNeo4jNodes ? undefined : activeTab.resultColumnComments"
+ :result-column-type-labels="hasNeo4jNodes ? undefined : activeTab.resultColumnTypeLabels"
:query-display-source-columns="hasNeo4jNodes ? undefined : activeTab.queryDisplaySourceColumns"
:custom-save-handler="mongoQueryResultSaveHandler"
:mongo-update-target="mongoQueryResultSaveHandler && activeTab.result.mongo_copy_documents?.length === activeTab.result.rows.length ? activeTab.mongoEditTarget : undefined"
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/visibleColumnTypesPriority.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/visibleColumnTypesPriority.spec.ts
index 5e13056afc..7f24fcd2f6 100644
--- a/apps/desktop/src/lib/__tests__/dataGrid/visibleColumnTypesPriority.spec.ts
+++ b/apps/desktop/src/lib/__tests__/dataGrid/visibleColumnTypesPriority.spec.ts
@@ -1,5 +1,5 @@
import { describe, expect, it } from "vitest";
-import { isNumericColumnType, resolveResultColumnType } from "@/lib/dataGrid/dataGridColumnType";
+import { formatMetadataColumnTypeLabel, isNumericColumnType, resolveHeaderColumnType, resolveResultColumnType, shortHeaderTypeName } from "@/lib/dataGrid/dataGridColumnType";
describe("resolveResultColumnType", () => {
function tableTypes(entries: Record<string, string>): Map<string, string> {
@@ -115,3 +115,43 @@ describe("resolveResultColumnType", () => {
expect(isNumericColumnType(castToInteger)).toBe(true);
});
});
+
+describe("resolveHeaderColumnType", () => {
+ it("prefers single-table metadata, then display enrichment, then ResultSet types", () => {
+ expect(
+ resolveHeaderColumnType({
+ tableColumnType: "varchar(32)",
+ displayColumnType: "varchar(64)",
+ resultColumnTypes: ["varchar"],
+ actualColIdx: 0,
+ }),
+ ).toBe("varchar(32)");
+
+ expect(
+ resolveHeaderColumnType({
+ tableColumnType: undefined,
+ displayColumnType: "character varying(50)",
+ resultColumnTypes: ["varchar"],
+ actualColIdx: 0,
+ }),
+ ).toBe("character varying(50)");
+
+ expect(
+ resolveHeaderColumnType({
+ tableColumnType: undefined,
+ displayColumnType: undefined,
+ resultColumnTypes: ["varchar"],
+ actualColIdx: 0,
+ }),
+ ).toBe("varchar");
+ });
+});
+
+describe("shortHeaderTypeName", () => {
+ it("shortens verbose PostgreSQL type names while keeping length suffixes", () => {
+ expect(shortHeaderTypeName("character varying(50)")).toBe("varchar(50)");
+ expect(shortHeaderTypeName("character varying")).toBe("varchar");
+ expect(shortHeaderTypeName("timestamp without time zone")).toBe("timestamp");
+ expect(formatMetadataColumnTypeLabel({ dataType: "varchar", characterMaximumLength: 50 })).toBe("varchar(50)");
+ });
+});
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts
index bc6d8b7da2..5b9bface64 100644
--- a/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts
@@ -16,16 +16,24 @@ import { isElasticsearchCompatibleDatabaseType, isSolrDatabaseType, type Databas
export interface HeaderColumnTypeSources {
/** Type from table metadata for this column (looked up by name), if any. */
tableColumnType?: string;
+ /**
+ * Type label from multi-source display enrichment (by result ordinal), used
+ * when a single `tableMeta` cannot cover every JOIN source column.
+ */
+ displayColumnType?: string;
/** `QueryResult.column_types`, parallel to `result.columns` (by index). */
resultColumnTypes?: readonly string[];
/** Index of the column within `result.columns`. */
actualColIdx: number;
}
-export function resolveHeaderColumnType({ tableColumnType, resultColumnTypes, actualColIdx }: HeaderColumnTypeSources): string | undefined {
+export function resolveHeaderColumnType({ tableColumnType, displayColumnType, resultColumnTypes, actualColIdx }: HeaderColumnTypeSources): string | undefined {
const fromMeta = tableColumnType?.trim();
if (fromMeta) return fromMeta;
+ const fromDisplay = displayColumnType?.trim();
+ if (fromDisplay) return fromDisplay;
+
const fromResult = resultColumnTypes?.[actualColIdx]?.trim();
return fromResult ? fromResult : undefined;
}
@@ -55,6 +63,27 @@ export function formatMetadataColumnTypeLabel({ dataType, characterMaximumLength
return typeName;
}
+/** Shorten verbose SQL type names while preserving a trailing `(length)` / `(p,s)` suffix. */
+export function shortHeaderTypeName(dataType: string): string {
+ const trimmed = dataType.trim();
+ const match = /^(.*?)(\([^)]*\))$/.exec(trimmed);
+ const base = (match?.[1] ?? trimmed).trim();
+ const suffix = match?.[2] ?? "";
+ const lower = base.toLowerCase();
+ if (lower === "character varying") return `varchar${suffix}`;
+ if (lower === "character") return `char${suffix}`;
+ if (lower === "double precision") return `double${suffix}`;
+ if (lower === "timestamp without time zone") return `timestamp${suffix}`;
+ if (lower === "timestamp with time zone") return `timestamptz${suffix}`;
+ if (lower === "time without time zone") return `time${suffix}`;
+ if (lower === "time with time zone") return `timetz${suffix}`;
+ if (lower === "boolean") return `bool${suffix}`;
+ if (lower === "integer") return `int${suffix}`;
+ if (lower === "smallint") return `int2${suffix}`;
+ if (lower === "real") return `float4${suffix}`;
+ return trimmed;
+}
+
/**
* Resolve the data type used to drive per-column alignment and other
* type-driven rendering in the query-result grid.
diff --git a/apps/desktop/src/lib/tabs/tabResultCache.ts b/apps/desktop/src/lib/tabs/tabResultCache.ts
index 0c855fe94b..63a1c47004 100644
--- a/apps/desktop/src/lib/tabs/tabResultCache.ts
+++ b/apps/desktop/src/lib/tabs/tabResultCache.ts
@@ -42,6 +42,7 @@ export interface TabResultSnapshot {
querySourceColumns?: QueryTab["querySourceColumns"];
queryWriteTargets?: QueryTab["queryWriteTargets"];
resultColumnComments?: QueryTab["resultColumnComments"];
+ resultColumnTypeLabels?: QueryTab["resultColumnTypeLabels"];
queryDisplaySourceColumns?: QueryTab["queryDisplaySourceColumns"];
queryEditabilityReason?: QueryTab["queryEditabilityReason"];
mongoEditTarget?: QueryTab["mongoEditTarget"];
@@ -814,6 +815,7 @@ export function buildTabResultSnapshot(tab: QueryTab): TabResultSnapshot | undef
querySourceColumns: tab.querySourceColumns ? [...tab.querySourceColumns] : undefined,
queryWriteTargets: tab.queryWriteTargets?.map((target) => ({ ...target, sourceColumns: [...target.sourceColumns] })),
resultColumnComments: tab.resultColumnComments ? clonePlain(tab.resultColumnComments) : undefined,
+ resultColumnTypeLabels: tab.resultColumnTypeLabels ? clonePlain(tab.resultColumnTypeLabels) : undefined,
queryDisplaySourceColumns: tab.queryDisplaySourceColumns ? [...tab.queryDisplaySourceColumns] : undefined,
queryEditabilityReason: tab.queryEditabilityReason,
mongoEditTarget: tab.mongoEditTarget ? clonePlain(tab.mongoEditTarget) : undefined,
diff --git a/apps/desktop/src/stores/__tests__/queryStore.multiSourceColumnComments.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.multiSourceColumnComments.spec.ts
index e903cc6941..b72ae1de91 100644
--- a/apps/desktop/src/stores/__tests__/queryStore.multiSourceColumnComments.spec.ts
+++ b/apps/desktop/src/stores/__tests__/queryStore.multiSourceColumnComments.spec.ts
@@ -54,8 +54,19 @@ vi.mock("@/stores/settingsStore", () => ({
}),
}));
-function column(name: string, comment: string | null, isPrimaryKey = false) {
- return { name, data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: isPrimaryKey, extra: null, comment };
+function column(name: string, comment: string | null, isPrimaryKey = false, characterMaximumLength: number | null = 64) {
+ return {
+ name,
+ data_type: "varchar",
+ is_nullable: true,
+ column_default: null,
+ is_primary_key: isPrimaryKey,
+ extra: null,
+ comment,
+ character_maximum_length: characterMaximumLength,
+ numeric_precision: null,
+ numeric_scale: null,
+ };
}
const ordersColumns = [column("id", "订单ID", true), column("user_id", "下单用户"), column("amount", "订单金额")];
@@ -141,6 +152,8 @@ describe("queryStore multi-source result column comments", () => {
// Comments are indexed by result ordinal, so the second `id` (users.id)
// keeps its own comment instead of first-source-wins on the name.
expect(tab.resultColumnComments).toEqual(["订单ID", "下单用户", "用户ID", "用户名"]);
+ // Declared lengths come from source ColumnInfo, not bare ResultSet types.
+ expect(tab.resultColumnTypeLabels).toEqual(["varchar(64)", "varchar(64)", "varchar(64)", "varchar(64)"]);
// The display mapping carries both source identity and physical table
// identity per ordinal, so display-only features can share table settings.
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
index 7fd398a1d4..f4352fd990 100644
--- a/apps/desktop/src/stores/queryStore.ts
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -90,6 +90,7 @@ import { isDataTabMetadataLifecycleStale } from "@/lib/sidebar/dataTabOpenPolicy
import type { SqlInsertMode } from "@/lib/export/sqlInsertMode";
import { csvNullLiteralForMode } from "@/lib/export/csvNullMode";
import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
+import { formatMetadataColumnTypeLabel } from "@/lib/dataGrid/dataGridColumnType";
import { getCachedTableMetadata, loadTableColumns, loadTableIndexes, loadTableMetadata, tableMetadataToDataTabMeta, updateCachedTableMetadataType, type TableMetadataRequest } from "@/lib/metadata/tableMetadataCache";
import { loadObjectDdl } from "@/lib/metadata/objectDdlCache";
import { MetadataTaskLimiter } from "@/lib/metadata/metadataTaskLimiter";
@@ -194,7 +195,8 @@ export interface EditorWorkspacePersistState {
sizes: number[];
}
-export type QueryMetadataPatch = Pick<QueryTab, "queryAnalysis" | "querySourceColumns" | "queryWriteTargets" | "queryEditabilityReason" | "tableMeta" | "resultColumnComments" | "queryDisplaySourceColumns">;
+export type QueryMetadataPatch = Pick<QueryTab, "queryAnalysis" | "querySourceColumns" | "queryWriteTargets" | "queryEditabilityReason" | "tableMeta" | "resultColumnComments" | "resultColumnTypeLabels" | "queryDisplaySourceColumns">;
+type QueryDisplayMetadataReady = Pick<QueryMetadataPatch, "resultColumnComments" | "resultColumnTypeLabels" | "queryDisplaySourceColumns">;
interface BatchSqlResumeOptions {
batch: BatchSqlExecution;
@@ -1877,6 +1879,7 @@ export const useQueryStore = defineStore("query", () => {
tab.querySourceColumns = undefined;
tab.queryWriteTargets = undefined;
tab.resultColumnComments = undefined;
+ tab.resultColumnTypeLabels = undefined;
tab.queryDisplaySourceColumns = undefined;
tab.queryEditabilityReason = undefined;
tab.mongoEditTarget = undefined;
@@ -1959,6 +1962,7 @@ export const useQueryStore = defineStore("query", () => {
run.querySourceColumns = undefined;
run.queryWriteTargets = undefined;
run.resultColumnComments = undefined;
+ run.resultColumnTypeLabels = undefined;
run.queryDisplaySourceColumns = undefined;
run.queryEditabilityReason = undefined;
run.mongoEditTarget = undefined;
@@ -2009,6 +2013,7 @@ export const useQueryStore = defineStore("query", () => {
tab.querySourceColumns = run.querySourceColumns;
tab.queryWriteTargets = run.queryWriteTargets;
tab.resultColumnComments = run.resultColumnComments;
+ tab.resultColumnTypeLabels = run.resultColumnTypeLabels;
tab.queryDisplaySourceColumns = run.queryDisplaySourceColumns;
tab.queryEditabilityReason = run.queryEditabilityReason;
tab.mongoEditTarget = run.mongoEditTarget;
@@ -2307,6 +2312,7 @@ export const useQueryStore = defineStore("query", () => {
querySourceColumns: run.querySourceColumns,
queryWriteTargets: run.queryWriteTargets,
resultColumnComments: run.resultColumnComments,
+ resultColumnTypeLabels: run.resultColumnTypeLabels,
queryDisplaySourceColumns: run.queryDisplaySourceColumns,
queryEditabilityReason: run.queryEditabilityReason,
tableMeta: run.tableMeta,
@@ -2400,6 +2406,7 @@ export const useQueryStore = defineStore("query", () => {
querySourceColumns: tab.querySourceColumns,
queryWriteTargets: tab.queryWriteTargets,
resultColumnComments: tab.resultColumnComments,
+ resultColumnTypeLabels: tab.resultColumnTypeLabels,
queryDisplaySourceColumns: tab.queryDisplaySourceColumns,
queryEditabilityReason: tab.queryEditabilityReason,
mongoEditTarget: tab.mongoEditTarget,
@@ -2510,6 +2517,7 @@ export const useQueryStore = defineStore("query", () => {
querySourceColumns: tab.querySourceColumns,
queryWriteTargets: tab.queryWriteTargets,
resultColumnComments: tab.resultColumnComments,
+ resultColumnTypeLabels: tab.resultColumnTypeLabels,
queryDisplaySourceColumns: tab.queryDisplaySourceColumns,
queryEditabilityReason: tab.queryEditabilityReason,
mongoEditTarget: tab.mongoEditTarget,
@@ -5097,6 +5105,7 @@ export const useQueryStore = defineStore("query", () => {
querySourceColumns: original.querySourceColumns ? [...original.querySourceColumns] : undefined,
queryWriteTargets: original.queryWriteTargets?.map((target) => ({ ...target, sourceColumns: [...target.sourceColumns] })),
resultColumnComments: original.resultColumnComments ? [...original.resultColumnComments] : undefined,
+ resultColumnTypeLabels: original.resultColumnTypeLabels ? [...original.resultColumnTypeLabels] : undefined,
queryDisplaySourceColumns: original.queryDisplaySourceColumns ? [...original.queryDisplaySourceColumns] : undefined,
queryEditabilityReason: original.queryEditabilityReason,
resultEvicted: undefined,
@@ -6492,7 +6501,7 @@ export const useQueryStore = defineStore("query", () => {
* identifiers keep exact casing. Ambiguous or unresolved columns yield
* `undefined` (no comment) instead of first-source-wins on a shared name.
*/
- function resolveResultColumnInfo(dbType: string, analysis: EditableQueryInfo, resultColumns: string[], loadedSources: LoadedEditableSource[]): { comments: Array<string | undefined>; mapping: Array<QueryResultSourceColumnRef | undefined> } {
+ function resolveResultColumnInfo(dbType: string, analysis: EditableQueryInfo, resultColumns: string[], loadedSources: LoadedEditableSource[]): { comments: Array<string | undefined>; typeLabels: Array<string | undefined>; mapping: Array<QueryResultSourceColumnRef | undefined> } {
const refs = resolveSourceColumnsByOrdinal(
dbType,
analysis,
@@ -6500,16 +6509,29 @@ export const useQueryStore = defineStore("query", () => {
resultColumns.length,
);
const comments: Array<string | undefined> = [];
+ const typeLabels: Array<string | undefined> = [];
const mapping: Array<QueryResultSourceColumnRef | undefined> = [];
for (const ref of refs) {
if (!ref) {
comments.push(undefined);
+ typeLabels.push(undefined);
mapping.push(undefined);
continue;
}
const loaded = loadedSources.find((entry) => entry.source.key === ref.sourceKey);
- const comment = loaded?.tableMeta.columns.find((column) => column.name === ref.sourceColumn)?.comment?.trim();
+ const column = loaded?.tableMeta.columns.find((candidate) => candidate.name === ref.sourceColumn);
+ const comment = column?.comment?.trim();
comments.push(comment || undefined);
+ typeLabels.push(
+ column
+ ? formatMetadataColumnTypeLabel({
+ dataType: column.data_type,
+ characterMaximumLength: column.character_maximum_length,
+ numericPrecision: column.numeric_precision,
+ numericScale: column.numeric_scale,
+ }) || undefined
+ : undefined,
+ );
mapping.push({
...ref,
database: loaded?.tableMeta.database,
@@ -6517,7 +6539,7 @@ export const useQueryStore = defineStore("query", () => {
tableName: loaded?.tableMeta.tableName,
});
}
- return { comments, mapping };
+ return { comments, typeLabels, mapping };
}
function mysqlColumnIsGenerated(column: { extra: string | null }): boolean {
@@ -6580,6 +6602,12 @@ export const useQueryStore = defineStore("query", () => {
return databaseType !== "oracle" || !!loaded.tableMeta.tableType?.trim();
}
+ function applyQueryDisplayMetadata(tab: QueryTab, display: QueryDisplayMetadataReady) {
+ if (display.resultColumnComments !== undefined) tab.resultColumnComments = display.resultColumnComments;
+ if (display.resultColumnTypeLabels !== undefined) tab.resultColumnTypeLabels = display.resultColumnTypeLabels;
+ if (display.queryDisplaySourceColumns !== undefined) tab.queryDisplaySourceColumns = display.queryDisplaySourceColumns;
+ }
+
function applyQueryMetadataPatch(tab: QueryTab, patch: QueryMetadataPatch, databaseType?: DatabaseType, database?: string) {
tab.queryAnalysis = patch.queryAnalysis;
tab.querySourceColumns = patch.querySourceColumns;
@@ -6588,6 +6616,7 @@ export const useQueryStore = defineStore("query", () => {
tab.mongoEditTarget = undefined;
tab.tableMeta = patch.tableMeta;
tab.resultColumnComments = patch.resultColumnComments;
+ tab.resultColumnTypeLabels = patch.resultColumnTypeLabels;
tab.queryDisplaySourceColumns = patch.queryDisplaySourceColumns;
if (patch.tableMeta?.tableName && tab.result?.sourceStatement && tab.result.sourceLabel) {
@@ -6756,6 +6785,51 @@ export const useQueryStore = defineStore("query", () => {
return loadedEditableSourceFromMetadata(target, loadedMetadata.metadata);
}
+ /**
+ * Load JOIN/source table metadata in two phases so result headers can show
+ * comments and declared type lengths as soon as columns return, without
+ * waiting for index discovery / editability.
+ */
+ async function loadEditableSourcesWithEarlyDisplay(
+ tab: QueryTab,
+ analysis: EditableQueryInfo,
+ sources: EditableQuerySource[],
+ conn: ConnectionConfig | undefined,
+ dbType: string,
+ executionDatabase: string,
+ traceId: string | undefined,
+ elapsed: (() => string) | undefined,
+ onDisplayReady?: (display: QueryDisplayMetadataReady) => void,
+ ): Promise<LoadedEditableSource[]> {
+ const targets = sources.map((source) => resolveEditableSourceMetadataTarget(tab, analysis, source, conn, dbType, executionDatabase));
+ const limiterScope = `${GROUPED_DISPLAY_LIMITER_SCOPE_PREFIX}${tab.connectionId}`;
+
+ const columnSources = await Promise.all(
+ targets.map((target) =>
+ groupedDisplayMetadataLimiter.run(limiterScope, "query-column-comments", async () => {
+ const loadedColumns = await loadTableColumns({
+ ...target.request,
+ traceLogger: (event) => queryExecutionLog("debug", "metadata:table-columns-trace", { sourceTraceId: traceId, ...event }),
+ });
+ return loadedEditableSourceFromColumns(target, loadedColumns);
+ }),
+ ),
+ );
+
+ if (onDisplayReady && tab.result?.columns.length) {
+ const displayInfo = resolveResultColumnInfo(dbType, analysis, tab.result.columns, columnSources);
+ onDisplayReady({
+ resultColumnComments: displayInfo.comments,
+ resultColumnTypeLabels: displayInfo.typeLabels,
+ queryDisplaySourceColumns: displayInfo.mapping,
+ });
+ }
+
+ // Columns are warm in the shared cache; full loads only pay for indexes /
+ // primary-key resolution needed by editability. Multi-source stays bounded.
+ return Promise.all(sources.map((source) => groupedDisplayMetadataLimiter.run(limiterScope, "query-table-metadata", async () => loadEditableQuerySource(tab, analysis, source, conn, dbType, executionDatabase, traceId, elapsed))));
+ }
+
function missingPrimaryKeysForSource(databaseType: DatabaseType, primaryKeys: string[], analysis: EditableQueryInfo, sourceKey: string): string[] {
if (analysis.selectStar) return [];
const selectedColumns = new Set(
@@ -6995,17 +7069,16 @@ export const useQueryStore = defineStore("query", () => {
// coordinator deduplicates identical tables across concurrent callers,
// so this path issues no indexes requests and never loads full editable
// metadata.
- const loadedSources: LoadedEditableSource[] = [];
const targets = sources.map((source) => resolveEditableSourceMetadataTarget(tab, analysis, source, conn, dbType, executionDatabase));
const limiterScope = `${GROUPED_DISPLAY_LIMITER_SCOPE_PREFIX}${tab.connectionId}`;
- await Promise.all(
+ const loadedSources = await Promise.all(
targets.map((target) =>
groupedDisplayMetadataLimiter.run(limiterScope, "query-column-comments", async () => {
const loadedColumns = await loadTableColumns({
...target.request,
traceLogger: (event) => queryExecutionLog("debug", "metadata:table-columns-trace", { sourceTraceId: traceId, ...event }),
});
- loadedSources.push(loadedEditableSourceFromColumns(target, loadedColumns));
+ return loadedEditableSourceFromColumns(target, loadedColumns);
}),
),
);
@@ -7016,6 +7089,7 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: readOnlyReason,
tableMeta: undefined,
resultColumnComments: displayInfo.comments,
+ resultColumnTypeLabels: displayInfo.typeLabels,
queryDisplaySourceColumns: displayInfo.mapping,
};
if (!allowMysqlEditing || dbType !== "mysql" || (conn?.driver_profile || conn?.db_type) !== "mysql") return readOnlyPatch;
@@ -7064,6 +7138,7 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: undefined,
tableMeta: target.tableMeta,
resultColumnComments: displayInfo.comments,
+ resultColumnTypeLabels: displayInfo.typeLabels,
queryDisplaySourceColumns: displayInfo.mapping,
};
} catch (err) {
@@ -7075,7 +7150,16 @@ export const useQueryStore = defineStore("query", () => {
}
}
- async function buildQueryMetadataPatch(tab: QueryTab, sql: string, executionDatabase: string, traceId?: string, elapsed?: () => string, hiddenPrimaryKeys: HiddenPrimaryKeyProjection[] = [], connection?: ConnectionConfig): Promise<QueryMetadataPatch | undefined> {
+ async function buildQueryMetadataPatch(
+ tab: QueryTab,
+ sql: string,
+ executionDatabase: string,
+ traceId?: string,
+ elapsed?: () => string,
+ hiddenPrimaryKeys: HiddenPrimaryKeyProjection[] = [],
+ connection?: ConnectionConfig,
+ onDisplayReady?: (display: QueryDisplayMetadataReady) => void,
+ ): Promise<QueryMetadataPatch | undefined> {
if (tab.mode !== "query") return;
if (!tab.result || !tab.result.columns.length) {
return {
@@ -7131,11 +7215,8 @@ export const useQueryStore = defineStore("query", () => {
const conn = connection ?? useConnectionStore().getConfig(tab.connectionId);
const dbType = conn?.db_type || "";
const sources = editableQuerySources(analysis);
- const loadedSources: LoadedEditableSource[] = [];
try {
- for (const source of sources) {
- loadedSources.push(await loadEditableQuerySource(tab, analysis, source, conn, dbType, executionDatabase, traceId, elapsed));
- }
+ const loadedSources = await loadEditableSourcesWithEarlyDisplay(tab, analysis, sources, conn, dbType, executionDatabase, traceId, elapsed, onDisplayReady);
const allSourceColumns = loadedSources.map((source) => ({ source: source.source, columns: source.tableMeta.columns }));
// Match DBeaver's safety model: a joined result is writable only when one
@@ -7180,6 +7261,7 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: "no-primary-key",
tableMeta: loaded.tableMeta,
resultColumnComments: displaySourceInfo.comments,
+ resultColumnTypeLabels: displaySourceInfo.typeLabels,
queryDisplaySourceColumns: displaySourceInfo.mapping,
};
}
@@ -7191,6 +7273,7 @@ export const useQueryStore = defineStore("query", () => {
querySourceColumns: undefined,
queryEditabilityReason: "primary-key-not-returned",
tableMeta: loaded.tableMeta,
+ resultColumnTypeLabels: displaySourceInfo.typeLabels,
queryDisplaySourceColumns: displaySourceInfo.mapping,
};
}
@@ -7201,6 +7284,7 @@ export const useQueryStore = defineStore("query", () => {
querySourceColumns: undefined,
queryEditabilityReason: "aliased-columns",
tableMeta: loaded.tableMeta,
+ resultColumnTypeLabels: displaySourceInfo.typeLabels,
queryDisplaySourceColumns: displaySourceInfo.mapping,
};
}
@@ -7211,6 +7295,9 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: undefined,
tableMeta: primaryKeys === loaded.tableMeta.primaryKeys ? loaded.tableMeta : { ...loaded.tableMeta, primaryKeys },
resultColumnComments: primaryKeys.length === 0 ? displaySourceInfo.comments : undefined,
+ // Single-table editable results already expose declared types via
+ // tableMeta; keep ordinal labels only when comments also use that path.
+ resultColumnTypeLabels: primaryKeys.length === 0 ? displaySourceInfo.typeLabels : undefined,
queryDisplaySourceColumns: displaySourceInfo.mapping,
};
}
@@ -7228,6 +7315,7 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: loadedSources.some((loaded) => loaded.tableMeta.primaryKeys.length > 0) ? "primary-key-not-returned" : "no-primary-key",
tableMeta: undefined,
resultColumnComments: multiSourceInfo?.comments,
+ resultColumnTypeLabels: multiSourceInfo?.typeLabels,
queryDisplaySourceColumns: multiSourceInfo?.mapping,
};
}
@@ -7244,6 +7332,7 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: undefined,
tableMeta: target.tableMeta,
resultColumnComments: multiSourceInfo?.comments,
+ resultColumnTypeLabels: multiSourceInfo?.typeLabels,
queryDisplaySourceColumns: multiSourceInfo?.mapping,
};
}
@@ -7266,6 +7355,7 @@ export const useQueryStore = defineStore("query", () => {
queryEditabilityReason: undefined,
tableMeta: target.tableMeta,
resultColumnComments: multiSourceInfo?.comments,
+ resultColumnTypeLabels: multiSourceInfo?.typeLabels,
queryDisplaySourceColumns: multiSourceInfo?.mapping,
};
} catch (err) {
@@ -7287,9 +7377,16 @@ export const useQueryStore = defineStore("query", () => {
const tab = tabs.value.find((t) => t.id === tabId);
if (!tab || tab.result !== result) return;
queryExecutionLog("info", "metadata:start", { traceId, elapsed: elapsed() });
+ const applyDisplayReady = (display: QueryDisplayMetadataReady) => {
+ const current = tabs.value.find((t) => t.id === tabId);
+ if (!current || current.result !== result) return;
+ applyQueryDisplayMetadata(current, display);
+ syncActiveResultRunFromDisplayed(current);
+ queryExecutionLog("info", "metadata:display-ready", { traceId, elapsed: elapsed() });
+ };
// Metadata requests outlive the displayed result when another query starts
// or a retained run is selected. Analyze this result, not the live tab.
- const patch = await buildQueryMetadataPatch({ ...tab, result }, sql, executionDatabase, traceId, elapsed, hiddenPrimaryKeys, connection);
+ const patch = await buildQueryMetadataPatch({ ...tab, result }, sql, executionDatabase, traceId, elapsed, hiddenPrimaryKeys, connection, applyDisplayReady);
if (patch?.queryAnalysis && hasHiddenPhysicalRowKey(databaseType, hiddenPrimaryKeys)) {
patch.queryAnalysis = { ...patch.queryAnalysis, allowInsert: false };
}
@@ -7745,6 +7842,7 @@ export const useQueryStore = defineStore("query", () => {
current.queryAnalysis = undefined;
current.querySourceColumns = undefined;
current.resultColumnComments = undefined;
+ current.resultColumnTypeLabels = undefined;
current.queryDisplaySourceColumns = undefined;
current.mongoEditTarget = undefined;
if (!producedResult) {
@@ -7813,6 +7911,7 @@ export const useQueryStore = defineStore("query", () => {
current.querySourceColumns = undefined;
current.queryWriteTargets = undefined;
current.resultColumnComments = undefined;
+ current.resultColumnTypeLabels = undefined;
current.queryDisplaySourceColumns = undefined;
current.queryEditabilityReason = undefined;
current.mongoEditTarget = undefined;
@@ -8281,6 +8380,7 @@ export const useQueryStore = defineStore("query", () => {
current.querySourceColumns = undefined;
current.queryWriteTargets = undefined;
current.resultColumnComments = undefined;
+ current.resultColumnTypeLabels = undefined;
current.queryDisplaySourceColumns = undefined;
current.queryEditabilityReason = undefined;
current.mongoEditTarget = mongoCommands.length === 1 ? mongoEditTarget : undefined;
@@ -8354,6 +8454,7 @@ export const useQueryStore = defineStore("query", () => {
current.querySourceColumns = undefined;
current.queryWriteTargets = undefined;
current.resultColumnComments = undefined;
+ current.resultColumnTypeLabels = undefined;
current.queryDisplaySourceColumns = undefined;
current.queryEditabilityReason = undefined;
current.mongoEditTarget = undefined;
@@ -9044,6 +9145,7 @@ export const useQueryStore = defineStore("query", () => {
current.querySourceColumns = undefined;
current.queryWriteTargets = undefined;
current.resultColumnComments = undefined;
+ current.resultColumnTypeLabels = undefined;
current.queryDisplaySourceColumns = undefined;
current.queryEditabilityReason = undefined;
current.mongoEditTarget = undefined;
@@ -9690,6 +9792,7 @@ export const useQueryStore = defineStore("query", () => {
tab.querySourceColumns = undefined;
tab.queryWriteTargets = undefined;
tab.resultColumnComments = undefined;
+ tab.resultColumnTypeLabels = undefined;
tab.queryDisplaySourceColumns = undefined;
tab.queryEditabilityReason = undefined;
tab.mongoEditTarget = undefined;
@@ -9819,6 +9922,7 @@ export const useQueryStore = defineStore("query", () => {
tab.querySourceColumns = snapshot.querySourceColumns;
tab.queryWriteTargets = snapshot.queryWriteTargets;
tab.resultColumnComments = snapshot.resultColumnComments;
+ tab.resultColumnTypeLabels = snapshot.resultColumnTypeLabels;
tab.queryDisplaySourceColumns = snapshot.queryDisplaySourceColumns;
tab.queryEditabilityReason = snapshot.queryEditabilityReason;
tab.mongoEditTarget = snapshot.mongoEditTarget;
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 8be519062b..fe9fbb57bd 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -1631,6 +1631,7 @@ export interface QueryResultRun {
querySourceColumns?: QueryTab["querySourceColumns"];
queryWriteTargets?: QueryTab["queryWriteTargets"];
resultColumnComments?: QueryTab["resultColumnComments"];
+ resultColumnTypeLabels?: QueryTab["resultColumnTypeLabels"];
queryDisplaySourceColumns?: QueryTab["queryDisplaySourceColumns"];
queryEditabilityReason?: QueryTab["queryEditabilityReason"];
mongoEditTarget?: QueryTab["mongoEditTarget"];
@@ -2464,6 +2465,14 @@ export interface QueryTab {
* (e.g. multi-table JOIN), so joined results still show column comments.
*/
resultColumnComments?: Array<string | undefined>;
+ /**
+ * Display-only column type labels for multi-source (or otherwise enriched)
+ * query results, indexed by result-column ordinal. Built from resolved base
+ * column metadata so headers can show declared length/precision (e.g.
+ * `varchar(50)`) even when ResultSet `column_types` only carry bare type
+ * names. `undefined` entries fall back to ResultSet / single-table metadata.
+ */
+ resultColumnTypeLabels?: Array<string | undefined>;
/**
* Display-only result-column to source mapping for multi-source results,
* indexed by result-column ordinal. Each entry carries the source identity