fix(grid): show comments for joined query results
This commit is contained in:
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());
|
||||
|
||||
@@ -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 };
|
||||
|
||||
@@ -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,
|
||||
|
||||
Reference in new issue
Block a user