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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(editor): skip INSERT hints duplicating projection aliases
zipg3cb1faf1c6f3
diff --git a/apps/desktop/src/lib/__tests__/editor/codemirrorInsertValueHints.spec.ts b/apps/desktop/src/lib/__tests__/editor/codemirrorInsertValueHints.spec.tsindex 64a714cda7..7c42489b5a 100644--- a/apps/desktop/src/lib/__tests__/editor/codemirrorInsertValueHints.spec.ts+++ b/apps/desktop/src/lib/__tests__/editor/codemirrorInsertValueHints.spec.ts@@ -1,6 +1,7 @@import { strict as assert } from "node:assert";import { test } from "vitest";import { buildInsertValueHintDecorations, insertValueHintsRefreshDispatchSpec, isInsertValueHintDecorationAt } from "@/lib/editor/codemirrorInsertValueHints";+import { parseInsertValueHints } from "@/lib/sql/insertValueHints";test("insertValueHintsRefreshDispatchSpec disables scrollIntoView", () => {assert.equal(insertValueHintsRefreshDispatchSpec.scrollIntoView, false);@@ -18,3 +19,10 @@ test("isInsertValueHintDecorationAt detects widget anchors", () => {assert.equal(isInsertValueHintDecorationAt(decorations, valueTwo), true);assert.equal(isInsertValueHintDecorationAt(decorations, sql.indexOf("INSERT")), false);});++test("a projection that already aliases its target column renders no hint widget", () => {+ const sql = ["INSERT INTO t (operation_apply_id, pacu_status)", "SELECT", " noprid.ruid as operation_apply_id,", " noprid.flag", "FROM noprid"].join("\n");+ const decorations = buildInsertValueHintDecorations(parseInsertValueHints(sql));+ assert.equal(isInsertValueHintDecorationAt(decorations, sql.indexOf("noprid.ruid")), false);+ assert.equal(isInsertValueHintDecorationAt(decorations, sql.indexOf("noprid.flag")), true);+});diff --git a/apps/desktop/src/lib/editor/codemirrorInsertValueHints.ts b/apps/desktop/src/lib/editor/codemirrorInsertValueHints.tsindex 2318d4739b..2b9e097ae5 100644--- a/apps/desktop/src/lib/editor/codemirrorInsertValueHints.ts+++ b/apps/desktop/src/lib/editor/codemirrorInsertValueHints.ts@@ -99,7 +99,7 @@ function shiftClause(clause: InsertValuesClause, offset: number): InsertValuesClreturn {...clause,span: { start: clause.span.start + offset, end: clause.span.end + offset },- rows: clause.rows.map((row) => row.map((from) => from + offset)),+ rows: clause.rows.map((row) => row.map((source) => ({ ...source, from: source.from + offset }))),};}diff --git a/apps/desktop/src/lib/sql/insertValueHints.ts b/apps/desktop/src/lib/sql/insertValueHints.tsindex 03d0393b67..0549de7a75 100644--- a/apps/desktop/src/lib/sql/insertValueHints.ts+++ b/apps/desktop/src/lib/sql/insertValueHints.ts@@ -14,11 +14,25 @@ export interface InsertValuesClause {database?: string;/** Explicit column list, or null when `INSERT INTO t VALUES` has no column list. */columns: string[] | null;- /** For each VALUES row or SELECT projection list, start offsets of top-level expressions. */- rows: number[][];+ /** For each VALUES row or SELECT projection list, the top-level source expressions. */+ rows: InsertValueSource[][];span: SqlSemanticSpan;}+/** One source expression of an INSERT, positioned for its inlay hint. */+export interface InsertValueSource {+ /** Document offset where the inlay widget is inserted (before the value expression). */+ from: number;+ /**+ * Explicit alias of a SELECT projection item (`expr AS alias`, `expr alias`), unquoted.+ *+ * The positional hint maps a source expression to its target column; when the projection+ * already names that same column itself, the hint would only duplicate the alias the user+ * typed, so `buildInsertValueHints` drops it.+ */+ alias?: string;+}+export interface ParseInsertValueHintsOptions {/** Resolve table columns when the INSERT has no explicit column list. */resolveTableColumns?: (table: string, schema?: string, database?: string) => string[] | undefined;@@ -115,11 +129,11 @@ function parseColumnList(tokens: readonly SqlSemanticToken[], openIndex: number)return { columns, nextIndex: index };}-function valueStartsInRow(tokens: readonly SqlSemanticToken[], openIndex: number): { starts: number[]; nextIndex: number } | null {+function valueStartsInRow(tokens: readonly SqlSemanticToken[], openIndex: number): { starts: InsertValueSource[]; nextIndex: number } | null {const open = tokens[openIndex];if (!open || open.text !== "(") return null;const contentDepth = open.depth + 1;- const starts: number[] = [];+ const starts: InsertValueSource[] = [];let expectValue = true;let index = openIndex + 1;@@ -130,7 +144,7 @@ function valueStartsInRow(tokens: readonly SqlSemanticToken[], openIndex: numberreturn { starts, nextIndex: index + 1 };}if (expectValue && item.depth === contentDepth) {- starts.push(item.span.start);+ starts.push({ from: item.span.start });expectValue = false;}if (item.text === "," && item.depth === contentDepth) {@@ -141,8 +155,8 @@ function valueStartsInRow(tokens: readonly SqlSemanticToken[], openIndex: numberreturn { starts, nextIndex: index };}-function parseValuesRows(tokens: readonly SqlSemanticToken[], valuesIndex: number): number[][] {- const rows: number[][] = [];+function parseValuesRows(tokens: readonly SqlSemanticToken[], valuesIndex: number): InsertValueSource[][] {+ const rows: InsertValueSource[][] = [];let index = valuesIndex + 1;while (index < tokens.length) {const item = tokens[index];@@ -205,7 +219,7 @@ function isWildcardProjection(tokens: readonly SqlSemanticToken[], from: number,return topLevel.length % 2 === 1 && topLevel.every((item, index) => (index % 2 === 0 ? (index === topLevel.length - 1 ? item.text === "*" : tokenIsIdentifier(item)) : item.text === "."));}-function selectProjectionStarts(tokens: readonly SqlSemanticToken[], selectIndex: number): number[] {+function selectProjectionStarts(tokens: readonly SqlSemanticToken[], selectIndex: number): InsertValueSource[] {const select = tokens[selectIndex];if (!select) return [];const depth = select.depth;@@ -239,7 +253,7 @@ function selectProjectionStarts(tokens: readonly SqlSemanticToken[], selectIndexif (tokens[index]?.depth === depth && tokens[index]?.normalized === "with" && tokens[index + 1]?.depth === depth && tokens[index + 1]?.normalized === "ties") index += 2;}- const starts: number[] = [];+ const starts: InsertValueSource[] = [];let expressionStart = index;for (; index < tokens.length; index += 1) {const item = tokens[index];@@ -247,15 +261,37 @@ function selectProjectionStarts(tokens: readonly SqlSemanticToken[], selectIndexif (isSelectClauseBoundary(item, depth)) break;if (item.text !== "," || item.depth !== depth) continue;if (index <= expressionStart || isWildcardProjection(tokens, expressionStart, index, depth)) return [];- starts.push(tokens[expressionStart]!.span.start);+ starts.push(selectProjectionSource(tokens, expressionStart, index, depth));expressionStart = index + 1;}if (index <= expressionStart || isWildcardProjection(tokens, expressionStart, index, depth)) return [];- starts.push(tokens[expressionStart]!.span.start);+ starts.push(selectProjectionSource(tokens, expressionStart, index, depth));return starts;}+/**+ * Projection source expression start, plus the alias that ends the projection when it has one.+ * Only the *trailing name* of a projection is an alias, so the token in front of it decides:+ * `AS` or another identifier (`x total`, `f(x) total`) introduces an alias, while a dotted name+ * (`t.col`), an operator (`x::text`) or an open expression does not.+ */+function selectProjectionSource(tokens: readonly SqlSemanticToken[], from: number, to: number, depth: number): InsertValueSource {+ const source: InsertValueSource = { from: tokens[from]!.span.start };+ const alias = selectProjectionAlias(tokens, to, depth);+ if (alias !== undefined) source.alias = alias;+ return source;+}++function selectProjectionAlias(tokens: readonly SqlSemanticToken[], to: number, depth: number): string | undefined {+ const last = tokens[to - 1];+ if (!tokenIsIdentifier(last) || last.depth !== depth) return undefined;+ const previous = tokens[to - 2];+ if (!previous) return undefined;+ const introducesAlias = previous.kind === "word" || previous.kind === "quoted_identifier" || previous.text === ")";+ return introducesAlias ? unquoteSqlSemanticIdentifier(last) : undefined;+}+function parseInsertClause(tokens: readonly SqlSemanticToken[], span: SqlSemanticSpan): InsertValuesClause | null {const insertIndex = findWordIndex(tokens, "insert");if (insertIndex < 0) return null;@@ -316,7 +352,7 @@ function shiftClause(clause: InsertValuesClause, offset: number): InsertValuesClreturn {...clause,span: { start: clause.span.start + offset, end: clause.span.end + offset },- rows: clause.rows.map((row) => row.map((from) => from + offset)),+ rows: clause.rows.map((row) => row.map((source) => ({ ...source, from: source.from + offset }))),};}@@ -671,16 +707,23 @@ export function buildInsertValueHints(clauses: readonly InsertValuesClause[], opfor (const row of clause.rows) {const count = Math.min(row.length, columns.length);for (let index = 0; index < count; index += 1) {- const from = row[index];+ const source = row[index];const column = columns[index];- if (from === undefined || !column) continue;- hints.push({ from, column });+ if (source === undefined || !column) continue;+ // A projection that already ends with the target column name states the mapping by+ // itself; repeating it as an inlay pill only duplicates the alias the user typed.+ if (source.alias !== undefined && sameSqlIdentifier(source.alias, column)) continue;+ hints.push({ from: source.from, column });}}}return hints;}+function sameSqlIdentifier(left: string, right: string): boolean {+ return left.toLowerCase() === right.toLowerCase();+}+/** Parse SQL and return insert-value inlay hints. */export function parseInsertValueHints(sql: string, options: ParseInsertValueHintsOptions = {}): InsertValueHint[] {return buildInsertValueHints(parseInsertValuesClauses(sql), options);diff --git a/docs/screenshots/issue-9277-after.png b/docs/screenshots/issue-9277-after.pngnew file mode 100644index 0000000000..bc5f20c5c2Binary files /dev/null and b/docs/screenshots/issue-9277-after.png differdiff --git a/docs/screenshots/issue-9277-before.png b/docs/screenshots/issue-9277-before.pngnew file mode 100644index 0000000000..de24784409Binary files /dev/null and b/docs/screenshots/issue-9277-before.png differdiff --git a/packages/app-tests/insertValueHints.test.ts b/packages/app-tests/insertValueHints.test.tsindex 77a646271e..0bbe5b6f24 100644--- a/packages/app-tests/insertValueHints.test.ts+++ b/packages/app-tests/insertValueHints.test.ts@@ -233,6 +233,52 @@ test("returns no positional hints for wildcard INSERT ... SELECT projections", (}});+test("skips the hint when the SELECT projection already aliases its target column", () => {+ // Reported as duplicated aliases that cannot be selected or deleted: the inlay pill repeated+ // the `AS <target column>` name the statement already spells out.+ const sql = ["INSERT INTO t_demo (operation_apply_id, pacu_enter_time, pacu_status)", "SELECT", " noprid.ruid as operation_apply_id,", " noprid.enter_date as pacu_enter_time,", " noprid.flag as unrelated_alias", "FROM noprid"].join("\n");+ const hints = parseInsertValueHints(sql);+ assert.deepEqual(+ hints.map((hint) => ({ column: hint.column, text: sql.slice(hint.from).split(/[ ,]/u, 1)[0] })),+ [{ column: "pacu_status", text: "noprid.flag" }],+ );+});++test("keeps positional mapping when only some projections repeat their target column", () => {+ const sql = "INSERT INTO t (a, b, c) SELECT x AS a, y, z AS c FROM s";+ const hints = parseInsertValueHints(sql);+ assert.deepEqual(+ hints.map((hint) => ({ column: hint.column, text: sql.slice(hint.from).split(/[ ,]/u, 1)[0] })),+ [{ column: "b", text: "y" }],+ );+});++test("matches projection aliases to target columns regardless of case or quoting", () => {+ assert.deepEqual(parseInsertValueHints("INSERT INTO t (operation_apply_id) SELECT noprid.ruid AS Operation_Apply_ID FROM noprid"), []);+ assert.deepEqual(parseInsertValueHints("INSERT INTO t (`pacu_status`) SELECT noprid.flag AS `pacu_status` FROM noprid"), []);+ assert.deepEqual(parseInsertValueHints('INSERT INTO t (total) SELECT npl.additive AS "TOTAL" FROM npl'), []);+});++test("recognises implicit projection aliases without the AS keyword", () => {+ assert.deepEqual(parseInsertValueHints("INSERT INTO t (cnt, name) SELECT COUNT(*) cnt, src.name name FROM s"), []);+ assert.deepEqual(+ parseInsertValueHints("INSERT INTO t (name) SELECT src.name FROM s").map((hint) => hint.column),+ ["name"],+ );+ assert.deepEqual(+ parseInsertValueHints("INSERT INTO t (cnt) SELECT COUNT(*) FROM s").map((hint) => hint.column),+ ["cnt"],+ );+});++test("keeps the hint for a projection whose alias names a different column", () => {+ const sql = "INSERT INTO dbo.users (id, name) SELECT source_id AS old_id, source_name AS display_name FROM staging";+ assert.deepEqual(+ parseInsertValueHints(sql).map((hint) => hint.column),+ ["id", "name"],+ );+});+test("caps INSERT ... SELECT hints to the smaller target or projection count", () => {assert.deepEqual(parseInsertValueHints("INSERT INTO t (a, b) SELECT x, y, z FROM source").map((hint) => hint.column),