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(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.ts
index 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.ts
index 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): InsertValuesCl
return {
...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.ts
index 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: number
return { 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: number
return { 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[], selectIndex
if (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[], selectIndex
if (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): InsertValuesCl
return {
...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[], op
for (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.png
new file mode 100644
index 0000000000..bc5f20c5c2
Binary files /dev/null and b/docs/screenshots/issue-9277-after.png differ
diff --git a/docs/screenshots/issue-9277-before.png b/docs/screenshots/issue-9277-before.png
new file mode 100644
index 0000000000..de24784409
Binary files /dev/null and b/docs/screenshots/issue-9277-before.png differ
diff --git a/packages/app-tests/insertValueHints.test.ts b/packages/app-tests/insertValueHints.test.ts
index 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),