fix(grid): show comments for joined query results

This commit is contained in:
jearhe authored and GitHub committed 2026-08-16 15:34:03 +08:00
1 parent d5f18034f9
commit 64e5e88c27
11 files changed
+867 -9

No files matched your search

@@ -0,0 +1,176 @@
import { describe, expect, it } from "vitest";
import { analyzeEditableQueryEditability, resolveSourceColumnsByOrdinal } from "@/lib/sql/sqlAnalysis";
/**
* Result columns resolve by projection ordinal, each carrying its source
* identity (sourceKey + canonical source column), so joined results keep
* per-source comments instead of first-source-wins on name clashes.
*/
describe("multi-source result column mapping", () => {
it("parses a JOIN as multi-source with per-source columns", () => {
const result = analyzeEditableQueryEditability("SELECT a.id, a.user_id, b.name FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const sources = result.analysis.sources!;
expect(sources.map((source) => source.tableName)).toEqual(["orders", "users"]);
expect(result.analysis.columns.map((column) => column.resultName)).toEqual(["id", "user_id", "name"]);
expect(result.analysis.columns.map((column) => column.sourceKey)).toEqual(["a:0", "a:0", "b:1"]);
});
it("maps each JOIN result column back to (source, column) by ordinal", () => {
const result = analyzeEditableQueryEditability("SELECT a.id, a.user_id, b.name FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"mysql",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }, { name: "amount" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "name" }] },
],
3,
);
expect(resolved).toEqual([
{ sourceKey: "a:0", sourceColumn: "id" },
{ sourceKey: "a:0", sourceColumn: "user_id" },
{ sourceKey: "b:1", sourceColumn: "name" },
]);
});
it("keeps duplicate result column names resolved per source (both tables have id)", () => {
const result = analyzeEditableQueryEditability("SELECT a.id, b.id FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"mysql",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "name" }] },
],
2,
);
// Result column #0 is orders.id, #1 is users.id — no first-source-wins.
expect(resolved).toEqual([
{ sourceKey: "a:0", sourceColumn: "id" },
{ sourceKey: "b:1", sourceColumn: "id" },
]);
});
it("resolves a uniquely qualified unqualified alias (name AS username) back to its physical column", () => {
const result = analyzeEditableQueryEditability("SELECT name AS username FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"mysql",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }, { name: "amount" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "name" }] },
],
1,
);
expect(resolved).toEqual([{ sourceKey: "b:1", sourceColumn: "name" }]);
});
it("returns undefined for an ambiguous unqualified column shared by several sources", () => {
const result = analyzeEditableQueryEditability("SELECT id FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"mysql",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "name" }] },
],
1,
);
expect(resolved).toEqual([undefined]);
});
it("resolves quoted mixed-case identifiers exactly (case preserved)", () => {
const result = analyzeEditableQueryEditability('SELECT a."ID", b."Name" FROM orders a JOIN users b ON a.user_id = b.id');
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"postgres",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "ID" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "Name" }] },
],
2,
);
expect(resolved).toEqual([
{ sourceKey: "a:0", sourceColumn: "ID" },
{ sourceKey: "b:1", sourceColumn: "Name" },
]);
});
it("does not collapse an unquoted lower-case name onto a distinct quoted mixed-case column", () => {
const result = analyzeEditableQueryEditability('SELECT a.id, b."ID" FROM orders a JOIN users b ON a.user_id = b.id');
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"postgres",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "ID" }, { name: "name" }] },
],
2,
);
// a.id folds to postgres `id`; b."ID" matches the quoted column exactly.
expect(resolved).toEqual([
{ sourceKey: "a:0", sourceColumn: "id" },
{ sourceKey: "b:1", sourceColumn: "ID" },
]);
});
it("expands a qualified star projection in projection order", () => {
const result = analyzeEditableQueryEditability("SELECT a.*, b.name FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"mysql",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }, { name: "amount" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "name" }] },
],
4,
);
expect(resolved).toEqual([
{ sourceKey: "a:0", sourceColumn: "id" },
{ sourceKey: "a:0", sourceColumn: "user_id" },
{ sourceKey: "a:0", sourceColumn: "amount" },
{ sourceKey: "b:1", sourceColumn: "name" },
]);
});
it("returns undefined for computed columns and extra result columns", () => {
const result = analyzeEditableQueryEditability("SELECT a.id, a.amount + b.id AS total, b.name FROM orders a JOIN users b ON a.user_id = b.id");
expect(result.editable).toBe(true);
if (!result.editable) return;
const resolved = resolveSourceColumnsByOrdinal(
"mysql",
result.analysis,
[
{ source: result.analysis.sources![0]!, columns: [{ name: "id" }, { name: "user_id" }, { name: "amount" }] },
{ source: result.analysis.sources![1]!, columns: [{ name: "id" }, { name: "name" }] },
],
3,
);
expect(resolved).toEqual([{ sourceKey: "a:0", sourceColumn: "id" }, undefined, { sourceKey: "b:1", sourceColumn: "name" }]);
});
});
@@ -193,6 +193,60 @@ describe("tab result cache statement execution metadata", () => {
expect(restored?.querySourceColumns).toEqual(["id", "name"]);
});
it("restores multi-source column comments and their source identity from the snapshot", () => {
const snapshot = {
result: {
columns: ["id", "user_id", "id_1", "name"],
rows: [[1, 100, 7, "Alice"]],
affected_rows: 0,
execution_time_ms: 1,
},
resultRuns: [
{
id: "run-join",
title: "Run 1",
sequence: 1,
sql: "SELECT a.id, a.user_id, b.id, b.name FROM orders a JOIN users b ON a.user_id = b.id",
createdAt: 1,
result: {
columns: ["id", "user_id", "id_1", "name"],
rows: [[1, 100, 7, "Alice"]],
affected_rows: 0,
execution_time_ms: 1,
},
resultColumnComments: ["订单ID", "下单用户", "用户ID", "用户名"],
queryDisplaySourceColumns: [
{ sourceKey: "a", sourceColumn: "id" },
{ sourceKey: "a", sourceColumn: "user_id" },
{ sourceKey: "b", sourceColumn: "id" },
{ sourceKey: "b", sourceColumn: "name" },
],
},
],
activeResultRunId: "run-join",
resultColumnComments: ["订单ID", "下单用户", "用户ID", "用户名"],
queryDisplaySourceColumns: [
{ sourceKey: "a", sourceColumn: "id" },
{ sourceKey: "a", sourceColumn: "user_id" },
{ sourceKey: "b", sourceColumn: "id" },
{ sourceKey: "b", sourceColumn: "name" },
],
cachedAt: 1,
};
const restored = decodeTabResultSnapshot(encodeTabResultSnapshot(snapshot));
expect(restored?.resultColumnComments).toEqual(["订单ID", "下单用户", "用户ID", "用户名"]);
expect(restored?.queryDisplaySourceColumns).toEqual([
{ sourceKey: "a", sourceColumn: "id" },
{ sourceKey: "a", sourceColumn: "user_id" },
{ sourceKey: "b", sourceColumn: "id" },
{ sourceKey: "b", sourceColumn: "name" },
]);
expect(restored?.resultRuns?.[0]?.resultColumnComments).toEqual(["订单ID", "下单用户", "用户ID", "用户名"]);
expect(restored?.resultRuns?.[0]?.queryDisplaySourceColumns?.[2]).toEqual({ sourceKey: "b", sourceColumn: "id" });
});
it("treats corrupt and unsupported snapshots as missing", () => {
expect(decodeTabResultSnapshot(new Uint8Array([0xff, 0x00]))).toBeUndefined();
const encoded = encodeTabResultSnapshot(queryResultLifecycleSnapshot());
+108
View File
@@ -86,6 +86,114 @@ export function resolveMetadataColumnName(databaseType: string, sourceName: stri
return caseOnlyMatches.length === 1 ? caseOnlyMatches[0] : undefined;
}
export interface ResolvedSourceColumnRef {
sourceKey: string;
sourceColumn: string;
}
/**
* Expand `*` / `alias.*` projections against each source table's columns so the
* returned stream aligns 1:1 with the executed result columns (projection
* order). A star whose source table is not among `tableSources` collapses to
* `undefined` (unresolvable). Whole-table `SELECT *` is expanded against the
* single source table when present.
*/
function expandProjectionColumnsForSources(analysis: EditableQueryInfo, tableSources: Array<{ source: EditableQuerySource; columns: readonly { name: string }[] }>): Array<EditableQueryColumn | undefined> {
if (analysis.selectStar || analysis.columns.length === 0) {
return tableSources.flatMap(({ source, columns }) =>
columns.map((column) => ({
sourceName: column.name,
sourceNameQuoted: false,
sourceKey: source.key,
resultName: column.name,
expression: column.name,
})),
);
}
const expanded: Array<EditableQueryColumn | undefined> = [];
for (const column of analysis.columns) {
if (!column.star) {
expanded.push(column);
continue;
}
const tableSource = tableSources.find((entry) => entry.source.key === column.sourceKey);
if (!tableSource) {
expanded.push(undefined);
continue;
}
for (const tableColumn of tableSource.columns) {
expanded.push({
...column,
star: false,
sourceName: tableColumn.name,
sourceNameQuoted: false,
resultName: tableColumn.name,
expression: column.sourceQualifier ? `${column.sourceQualifier}.${tableColumn.name}` : tableColumn.name,
});
}
}
return expanded;
}
function resolveProjectionColumnToSource(databaseType: string, column: EditableQueryColumn | undefined, tableSources: Array<{ source: EditableQuerySource; columns: readonly { name: string }[] }>): ResolvedSourceColumnRef | undefined {
if (!column || column.star || !column.sourceName) return undefined;
// A qualified reference whose qualifier could not be bound to a unique source
// stays unresolved rather than guessing from the bare column name.
if (column.sourceQualifier && !column.sourceKey) return undefined;
if (column.sourceKey) {
const tableIndex = tableSources.findIndex((entry) => entry.source.key === column.sourceKey);
if (tableIndex < 0) return undefined;
const canonicalName = resolveMetadataColumnName(
databaseType,
column.sourceName,
column.sourceNameQuoted,
tableSources[tableIndex]!.columns.map((entry) => entry.name),
);
return canonicalName ? { sourceKey: column.sourceKey, sourceColumn: canonicalName } : undefined;
}
// Unqualified reference: bind only when exactly one source resolves it, so an
// ambiguous name shared by several tables yields undefined instead of
// first-source-wins.
const matches: ResolvedSourceColumnRef[] = [];
for (const tableSource of tableSources) {
const canonicalName = resolveMetadataColumnName(
databaseType,
column.sourceName,
column.sourceNameQuoted,
tableSource.columns.map((entry) => entry.name),
);
if (canonicalName) matches.push({ sourceKey: tableSource.source.key, sourceColumn: canonicalName });
}
return matches.length === 1 ? matches[0] : undefined;
}
/**
* Resolve each result column — in projection (ordinal) order — back to exactly
* one base-table column across the query sources, using the same
* database-aware identifier canonicalization as the editability binder
* (`resolveMetadataColumnName`): quoted identifiers match metadata exactly
* (case preserved), unquoted identifiers fold per the database's rules
* (PostgreSQL-compatible lower, Oracle-compatible upper, others
* case-insensitive when unambiguous).
*
* Star projections are expanded against the source table columns so the
* returned array aligns 1:1 with the executed result columns. An entry is
* `undefined` when the result column cannot be resolved to a single source
* column: ambiguous unqualified references, computed expressions, unknown
* columns, or a star whose source table is unknown. Consumers must show no
* comment for such columns rather than guessing.
*/
export function resolveSourceColumnsByOrdinal(databaseType: string, analysis: EditableQueryInfo, tableSources: Array<{ source: EditableQuerySource; columns: readonly { name: string }[] }>, columnCount: number): Array<ResolvedSourceColumnRef | undefined> {
const expanded = expandProjectionColumnsForSources(analysis, tableSources);
const resolved: Array<ResolvedSourceColumnRef | undefined> = [];
for (let index = 0; index < columnCount; index++) {
resolved.push(resolveProjectionColumnToSource(databaseType, expanded[index], tableSources));
}
return resolved;
}
export type QueryEditabilityReason = "not-select" | "cte" | "set-operation" | "aggregation" | "external-source" | "complex-source" | "computed-columns" | "no-table" | "no-primary-key" | "primary-key-not-returned" | "aliased-columns" | "metadata-unavailable";
export type QueryEditability = { editable: true; analysis: EditableQueryInfo } | { editable: false; reason: QueryEditabilityReason };
+9 -1
View File
@@ -34,6 +34,8 @@ export interface TabResultSnapshot {
activeResultRunId?: string;
queryAnalysis?: QueryTab["queryAnalysis"];
querySourceColumns?: QueryTab["querySourceColumns"];
resultColumnComments?: QueryTab["resultColumnComments"];
queryDisplaySourceColumns?: QueryTab["queryDisplaySourceColumns"];
queryEditabilityReason?: QueryTab["queryEditabilityReason"];
mongoEditTarget?: QueryTab["mongoEditTarget"];
tableMeta?: QueryTab["tableMeta"];
@@ -318,7 +320,11 @@ async function deleteIndexedDbCacheOwner(ownerId: string): Promise<void> {
function clonePlain<T>(value: T): T {
const raw = toRaw(value);
if (typeof structuredClone === "function") return structuredClone(raw);
return JSON.parse(JSON.stringify(raw)) as T;
try {
return JSON.parse(JSON.stringify(raw)) as T;
} catch {
return raw;
}
}
function stripSessionIds(result: QueryResult | undefined): QueryResult | undefined {
@@ -727,6 +733,8 @@ export function buildTabResultSnapshot(tab: QueryTab): TabResultSnapshot | undef
activeResultRunId: tab.activeResultRunId,
queryAnalysis: tab.queryAnalysis ? clonePlain(tab.queryAnalysis) : undefined,
querySourceColumns: tab.querySourceColumns ? [...tab.querySourceColumns] : undefined,
resultColumnComments: tab.resultColumnComments ? clonePlain(tab.resultColumnComments) : undefined,
queryDisplaySourceColumns: tab.queryDisplaySourceColumns ? [...tab.queryDisplaySourceColumns] : undefined,
queryEditabilityReason: tab.queryEditabilityReason,
mongoEditTarget: tab.mongoEditTarget ? clonePlain(tab.mongoEditTarget) : undefined,
tableMeta: tab.tableMeta ? clonePlain(tab.tableMeta) : undefined,