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
feat(editor): highlight sql table aliases and references
二丫讲梵5cd4706d3d8c
diff --git a/apps/desktop/src/components/editor/QueryEditor.vue b/apps/desktop/src/components/editor/QueryEditor.vueindex a99d96154f..b25390b0f4 100644--- a/apps/desktop/src/components/editor/QueryEditor.vue+++ b/apps/desktop/src/components/editor/QueryEditor.vue@@ -133,6 +133,7 @@ import { normalizeShortcutSettings, shortcutToCodeMirrorKey } from "@/lib/editorimport { trimmedSelectionLayer } from "@/lib/editor/codemirrorTrimmedSelectionLayer";import { currentStatementFrameLayer } from "@/lib/editor/codemirrorCurrentStatementFrameLayer";import { selectionMatchOccurrences } from "@/lib/editor/codemirrorSelectionMatches";+import { createSqlAliasHighlights } from "@/lib/editor/codemirrorSqlAliasHighlights";import { createInsertValueHintsExtension, requestInsertValueHintsRefresh, supportsInsertValueHints } from "@/lib/editor/codemirrorInsertValueHints";import { sqlBlockFoldService } from "@/lib/editor/codemirrorSqlBlockFolding";import { focusEditorView } from "@/lib/editor/queryEditorFocus";@@ -6059,6 +6060,7 @@ onMounted(async () => {const SQL_SEMANTIC_HIGHLIGHT_DEBOUNCE_MS = 100;const refreshSqlSemanticHighlightEffect = StateEffect.define<null>();buildSqlSemanticHighlightExtension = () => [+ createSqlAliasHighlights({ databaseType: props.databaseType, dialect: sqlBehaviorDialect(), enabled: queryEditorSelectionLanguage() === "sql" }),ViewPlugin.fromClass(class {decorations: import("@codemirror/view").DecorationSet;diff --git a/apps/desktop/src/lib/__tests__/sql/semantic/aliasHighlights.spec.ts b/apps/desktop/src/lib/__tests__/sql/semantic/aliasHighlights.spec.tsnew file mode 100644index 0000000000..83f960f193--- /dev/null+++ b/apps/desktop/src/lib/__tests__/sql/semantic/aliasHighlights.spec.ts@@ -0,0 +1,162 @@+import { describe, expect, it } from "vitest";+import { sqlAliasHighlightGroups, type SqlAliasHighlightGroup } from "@/lib/sql/semantic/aliasHighlights";++function spanTexts(sql: string, spans: Array<{ start: number; end: number }>): string[] {+ return spans.map((span) => sql.slice(span.start, span.end));+}++function groupByDeclaration(sql: string, groups: SqlAliasHighlightGroup[]): Map<string, SqlAliasHighlightGroup> {+ return new Map(groups.map((group) => [sql.slice(group.declaration.start, group.declaration.end), group]));+}++describe("sqlAliasHighlightGroups", () => {+ it("highlights an alias declaration, qualifiers, and qualified references", () => {+ const sql = "SELECT u.id, o.amount FROM users u JOIN orders o ON o.user_id = u.id";+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql));++ expect(spanTexts(sql, [groups.get("u")!.declaration])).toEqual(["u"]);+ expect(spanTexts(sql, groups.get("u")!.qualifiers)).toEqual(["u", "u"]);+ expect(spanTexts(sql, groups.get("u")!.references)).toEqual(["u.id", "u.id"]);+ expect(spanTexts(sql, groups.get("o")!.qualifiers)).toEqual(["o", "o"]);+ expect(spanTexts(sql, groups.get("o")!.references)).toEqual(["o.amount", "o.user_id"]);+ });++ it("keeps a star column inside the reference span", () => {+ const sql = "SELECT u.* FROM users u";+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql));++ expect(spanTexts(sql, groups.get("u")!.references)).toEqual(["u.*"]);+ });++ it("still returns an unreferenced alias so its declaration can highlight itself", () => {+ const sql = "SELECT id FROM users u";+ const groups = sqlAliasHighlightGroups(sql);++ expect(groups).toHaveLength(1);+ expect(spanTexts(sql, [groups[0].declaration])).toEqual(["u"]);+ expect(groups[0].qualifiers).toEqual([]);+ expect(groups[0].references).toEqual([]);+ });++ it("mixes referenced and unreferenced aliases without dropping either", () => {+ const sql = "SELECT u.id FROM users u, audit_log a";+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql));++ expect(spanTexts(sql, groups.get("u")!.references)).toEqual(["u.id"]);+ expect(groups.get("a")!.references).toEqual([]);+ });++ it("drops duplicate alias declarations that would produce no spans at all", () => {+ const sql = "SELECT u.id FROM users u, logs u";+ const groups = sqlAliasHighlightGroups(sql);++ expect(groups).toEqual([]);+ });++ it("does not mistake schema.table.column or table function calls for alias references", () => {+ const sql = "SELECT db.users.id FROM db.users";+ const groups = sqlAliasHighlightGroups(sql);++ expect(groups).toEqual([]);+ });++ it("resolves inner alias references to the shadowing subquery block", () => {+ const sql = "SELECT * FROM users u WHERE u.id IN (SELECT ur.role FROM user_roles ur)";+ const groups = sqlAliasHighlightGroups(sql);++ expect(groups).toHaveLength(2);+ expect(+ spanTexts(+ sql,+ groups.map((group) => group.declaration),+ ),+ ).toEqual(["u", "ur"]);+ expect(spanTexts(sql, groups[0].references)).toEqual(["u.id"]);+ expect(spanTexts(sql, groups[1].references)).toEqual(["ur.role"]);+ });++ it("shadows an outer alias reused as the inner subquery alias", () => {+ const sql = "SELECT * FROM users u WHERE u.id IN (SELECT u.role FROM user_roles u)";+ const groups = sqlAliasHighlightGroups(sql);++ expect(groups).toHaveLength(2);+ expect(+ spanTexts(+ sql,+ groups.map((group) => group.declaration),+ ),+ ).toEqual(["u", "u"]);+ expect(spanTexts(sql, groups[0].references)).toEqual(["u.id"]);+ expect(spanTexts(sql, groups[1].references)).toEqual(["u.role"]);+ });++ it("scopes grouped join sources and their group alias separately", () => {+ const sql = "SELECT g.id FROM (users a JOIN orders b ON a.user_id = b.id) g WHERE g.amount > 0";+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql));++ expect(spanTexts(sql, groups.get("a")!.references)).toEqual(["a.user_id"]);+ expect(spanTexts(sql, groups.get("b")!.references)).toEqual(["b.id"]);+ expect(spanTexts(sql, groups.get("g")!.qualifiers)).toEqual(["g", "g"]);+ expect(spanTexts(sql, groups.get("g")!.references)).toEqual(["g.id", "g.amount"]);+ });++ it("keeps an unaliased parenthesized join transparent to the enclosing scope", () => {+ const sql = "SELECT a.id FROM (users a JOIN orders b ON a.user_id = b.id)";+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql));++ expect(spanTexts(sql, groups.get("a")!.references)).toEqual(["a.id", "a.user_id"]);+ expect(spanTexts(sql, groups.get("b")!.references)).toEqual(["b.id"]);+ });++ it.each([+ ["unbalanced open parenthesis", "SELECT * FROM (SELECT * FROM users u"],+ ["stray close parenthesis", "SELECT * FROM users u) WHERE u.id > 0"],+ ["unclosed string literal", "SELECT u.id FROM users u WHERE u.name = 'oops"],+ ["unclosed mysql backtick identifier", "SELECT `e`.id FROM users `e"],+ ["truncated before alias", "SELECT u.id FROM users"],+ ["empty statement", ""],+ ] as const)("returns no groups for a %s", (_label, sql) => {+ expect(sqlAliasHighlightGroups(sql, { databaseType: "mysql" })).toEqual([]);+ });++ it("matches mysql backtick-quoted aliases and references", () => {+ const sql = "SELECT `e`.id FROM `analytics`.`events` `e`";+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql, { databaseType: "mysql" }));++ expect(spanTexts(sql, [groups.get("`e`")!.declaration])).toEqual(["`e`"]);+ expect(spanTexts(sql, groups.get("`e`")!.references)).toEqual(["`e`.id"]);+ });++ it("treats mysql double quotes as strings, not alias qualifiers", () => {+ const sql = 'SELECT "e".id FROM users e';+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql, { databaseType: "mysql" }));++ expect(groups.get("e")!.references).toEqual([]);+ });++ it("matches sqlite double-quoted aliases and references", () => {+ const sql = 'SELECT "u".id FROM users AS "u"';+ const groups = groupByDeclaration(sql, sqlAliasHighlightGroups(sql, { databaseType: "sqlite" }));++ expect(spanTexts(sql, [groups.get('"u"')!.declaration])).toEqual(['"u"']);+ expect(spanTexts(sql, groups.get('"u"')!.references)).toEqual(['"u".id']);+ });++ it.each([+ ["mysql unquoted alias", { databaseType: "mysql" }, "SELECT u.id FROM users U", true],+ ["mysql backtick alias with different case", { databaseType: "mysql" }, "SELECT `e`.id FROM users `E`", true],+ ["sql server unquoted alias", { databaseType: "sqlserver" }, "SELECT u.id FROM users U", true],+ ["sql server bracket alias", { databaseType: "sqlserver" }, "SELECT [u].id FROM users [U]", true],+ ["sqlite ascii fold", { databaseType: "sqlite" }, "SELECT U.id FROM users u", true],+ ["postgres folds unquoted identifiers", { databaseType: "postgres" }, "SELECT u.id FROM users U", true],+ ["postgres quoted alias keeps its case", { databaseType: "postgres" }, 'SELECT u.id FROM users "U"', false],+ ["oracle folds unquoted identifiers up", { databaseType: "oracle" }, "SELECT U.ID FROM users u", true],+ ["oracle quoted alias keeps its case", { databaseType: "oracle" }, 'SELECT u.id FROM users "u"', false],+ ["generic dialect stays case-sensitive", {}, "SELECT u.id FROM users U", false],+ ] as const)("resolves %s case handling", (_label, options, sql, matches) => {+ const groups = sqlAliasHighlightGroups(sql, options);+ const withReferences = groups.filter((group) => group.references.length > 0);++ expect(withReferences).toHaveLength(matches ? 1 : 0);+ });+});diff --git a/apps/desktop/src/lib/editor/codemirrorSqlAliasHighlights.ts b/apps/desktop/src/lib/editor/codemirrorSqlAliasHighlights.tsnew file mode 100644index 0000000000..ee70b73605--- /dev/null+++ b/apps/desktop/src/lib/editor/codemirrorSqlAliasHighlights.ts@@ -0,0 +1,96 @@+import { StateEffect, type Extension, type Text } from "@codemirror/state";+import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view";+import { MAX_ALIAS_HIGHLIGHT_SQL_LENGTH, sqlAliasHighlightGroups, type SqlAliasHighlightGroup } from "@/lib/sql/semantic/aliasHighlights";+import { sqlSemanticDialectFor } from "@/lib/sql/semantic/dialect";+import { resolveSqlStatementWindow, resolveStatementWindowFromSyntaxTree } from "@/lib/sql/sqlSyntaxTreeWindow";+import type { SqlSemanticBuildOptions } from "@/lib/sql/semantic/types";++const refreshAliasHighlights = StateEffect.define<null>();+const aliasMark = Decoration.mark({ class: "cm-sqlAliasHighlight" });++export function createSqlAliasHighlights(options: SqlSemanticBuildOptions & { enabled: boolean }): Extension {+ if (!options.enabled) return [];+ return [+ ViewPlugin.fromClass(+ class {+ decorations: DecorationSet = Decoration.none;+ private timer: ReturnType<typeof setTimeout> | null = null;+ private doc: Text | null = null;+ private sql = "";+ private window: { from: number; to: number } | null = null;+ private groups: SqlAliasHighlightGroup[] = [];++ constructor(view: EditorView) {+ this.schedule(view);+ }++ update(update: ViewUpdate) {+ if (update.docChanged || update.selectionSet || update.focusChanged) {+ this.decorations = Decoration.none;+ this.schedule(update.view);+ } else if (update.transactions.some((transaction) => transaction.effects.some((effect) => effect.is(refreshAliasHighlights)))) {+ this.render(update.view);+ } else if (update.viewportChanged) {+ this.render(update.view);+ }+ }++ destroy() {+ if (this.timer !== null) clearTimeout(this.timer);+ }++ private schedule(view: EditorView) {+ if (this.timer !== null) clearTimeout(this.timer);+ this.timer = null;+ if (!view.hasFocus || view.state.selection.ranges.length !== 1 || !view.state.selection.main.empty) return;+ this.timer = setTimeout(() => {+ this.timer = null;+ view.dispatch({ effects: refreshAliasHighlights.of(null) });+ }, 100);+ }++ private render(view: EditorView) {+ const { state } = view;+ this.decorations = Decoration.none;+ if (this.timer !== null || !view.hasFocus || state.selection.ranges.length !== 1 || !state.selection.main.empty) return;+ const cursor = state.selection.main.head;+ if (this.doc !== state.doc) {+ this.doc = state.doc;+ this.sql = "";+ this.window = null;+ }+ if (!this.window || cursor < this.window.from || cursor >= this.window.to) {+ let window = resolveStatementWindowFromSyntaxTree(state, cursor);+ if (!window) {+ // Avoid flattening huge documents while the incremental parser is still catching up.+ if (state.doc.length > MAX_ALIAS_HIGHLIGHT_SQL_LENGTH) return;+ this.sql ||= state.doc.toString();+ window = resolveSqlStatementWindow(this.sql, cursor, state, sqlSemanticDialectFor(options).id);+ }+ this.window = window;+ this.groups = window.to - window.from <= MAX_ALIAS_HIGHLIGHT_SQL_LENGTH ? sqlAliasHighlightGroups(state.doc.sliceString(window.from, window.to), options) : [];+ }+ const offset = this.window.from;+ const localCursor = cursor - offset;+ const containsCursor = (span: { start: number; end: number }) => span.start <= localCursor && localCursor <= span.end;+ const group = this.groups.find((candidate) => containsCursor(candidate.declaration) || candidate.qualifiers.some(containsCursor));+ if (!group) return;+ const ranges = [group.declaration, ...group.references].filter((span) => view.visibleRanges.some((visible) => span.end + offset > visible.from && span.start + offset < visible.to)).map((span) => aliasMark.range(span.start + offset, span.end + offset));+ this.decorations = Decoration.set(ranges, true);+ }+ },+ { decorations: (plugin) => plugin.decorations },+ ),+ EditorView.baseTheme({+ ".cm-sqlAliasHighlight": {+ backgroundColor: "rgb(34 139 74 / 0.16)",+ boxShadow: "inset 0 0 0 1px rgb(34 139 74 / 0.28)",+ borderRadius: "2px",+ },+ "&dark .cm-sqlAliasHighlight": {+ backgroundColor: "rgb(110 231 183 / 0.18)",+ boxShadow: "inset 0 0 0 1px rgb(110 231 183 / 0.32)",+ },+ }),+ ];+}diff --git a/apps/desktop/src/lib/sql/semantic/aliasHighlights.ts b/apps/desktop/src/lib/sql/semantic/aliasHighlights.tsnew file mode 100644index 0000000000..bd8d519917--- /dev/null+++ b/apps/desktop/src/lib/sql/semantic/aliasHighlights.ts@@ -0,0 +1,138 @@+import { sqlSemanticDialectFor } from "@/lib/sql/semantic/dialect";+import { sqlSemanticQueryBlockSources, type SqlSemanticGroupedSourceScope } from "@/lib/sql/semantic/model";+import { tokenizeSqlSemantic, tokenIsIdentifier, unquoteSqlSemanticIdentifier } from "@/lib/sql/semantic/tokens";+import type { SqlSemanticBuildOptions, SqlSemanticSpan, SqlSemanticToken } from "@/lib/sql/semantic/types";++export interface SqlAliasHighlightGroup {+ declaration: SqlSemanticSpan;+ qualifiers: SqlSemanticSpan[];+ references: SqlSemanticSpan[];+}++interface QueryBlock {+ start: number;+ end: number;+ depth: number;+ parent?: QueryBlock;+ aliases: Map<string, SqlAliasHighlightGroup | null>;+ sources: SqlSemanticSpan[];+}++const SET_OPERATORS = new Set(["union", "intersect", "except"]);+// MySQL aliases and SQL Server default collations compare identifiers case-insensitively.+const CASE_INSENSITIVE_ALIAS_DIALECTS = new Set(["mysql", "sqlserver", "sqlite"]);+export const MAX_ALIAS_HIGHLIGHT_SQL_LENGTH = 128 * 1024;++function lastBlock(blocks: QueryBlock[], predicate: (block: QueryBlock) => boolean): QueryBlock | undefined {+ for (let index = blocks.length - 1; index >= 0; index--) {+ if (predicate(blocks[index])) return blocks[index];+ }+ return undefined;+}++/** Input is a single statement; all returned spans are relative to that statement. */+export function sqlAliasHighlightGroups(sql: string, options: SqlSemanticBuildOptions = {}): SqlAliasHighlightGroup[] {+ if (sql.length > MAX_ALIAS_HIGHLIGHT_SQL_LENGTH) return [];+ const dialect = sqlSemanticDialectFor(options);+ const allTokens = tokenizeSqlSemantic(sql, dialect.id, {+ mysqlDashCommentRequiresWhitespace: dialect.id === "mysql",+ mysqlBackslashEscape: dialect.id === "mysql",+ mysqlDoubleQuoteIsString: dialect.id === "mysql",+ });+ if (allTokens.some((token) => token.closed === false)) return [];+ const tokens = allTokens.filter((token) => token.kind !== "comment");+ if (tokens.length > 20_000) return [];+ let parentheses = 0;+ for (const token of tokens) {+ if (token.text === "(") parentheses++;+ if (token.text === ")" && --parentheses < 0) return [];+ }+ if (parentheses !== 0) return [];+ const tokensByStart = new Map(tokens.map((token) => [token.span.start, token]));+ const nameOf = (token: SqlSemanticToken) => {+ const name = dialect.normalizeIdentifier(unquoteSqlSemanticIdentifier(token), token.kind === "quoted_identifier");+ // These dialects compare even quoted identifiers case-insensitively for ASCII letters.+ // Keep the spelling normalizer unchanged, and preserve other dialects' quote and case semantics.+ return CASE_INSENSITIVE_ALIAS_DIALECTS.has(dialect.id) ? name.replace(/[A-Z]/g, (letter) => letter.toLowerCase()) : name;+ };+ const blocks: QueryBlock[] = [];+ const groups: SqlAliasHighlightGroup[] = [];++ for (let index = 0; index < tokens.length; index++) {+ const token = tokens[index];+ if (token.kind !== "word" || token.normalized !== "select") continue;+ if (blocks.length >= 128) return [];+ let end = index + 1;+ while (end < tokens.length) {+ const next = tokens[end];+ if (next.depth < token.depth || next.text === ";" || (next.depth === token.depth && next.kind === "word" && SET_OPERATORS.has(next.normalized))) break;+ end++;+ }+ const groupedScopes: SqlSemanticGroupedSourceScope[] = [];+ const sources = sqlSemanticQueryBlockSources(tokens.slice(index, end), options, groupedScopes);+ const scopes = [+ { start: index, end, depth: token.depth, sources },+ ...groupedScopes.map((scope) => ({+ start: tokens.findIndex((candidate) => candidate.span.start >= scope.span.start),+ end: tokens.findIndex((candidate) => candidate.span.start >= scope.span.end),+ depth: scope.depth,+ sources: scope.sources,+ })),+ ];+ for (const scope of scopes) {+ if (scope.start < 0 || scope.end <= scope.start) continue;+ if (blocks.length >= 128) return [];+ const block: QueryBlock = { start: scope.start, end: scope.end, depth: scope.depth, aliases: new Map(), sources: [] };+ for (const source of scope.sources) {+ // Only exclude the source name itself; table-function arguments can reference aliases.+ if (source.qualifiedName) block.sources.push(source.qualifiedName.span);+ if (!source.aliasSpan) {+ // An unaliased local table also hides an outer alias with the same name.+ const parts = source.qualifiedName?.parts;+ const localName = parts?.[parts.length - 1];+ const localToken = localName && tokensByStart.get(localName.span.start);+ if (localToken) block.aliases.set(nameOf(localToken), null);+ continue;+ }+ const declaration = tokensByStart.get(source.aliasSpan.start);+ if (!declaration) continue;+ const key = nameOf(declaration);+ const group: SqlAliasHighlightGroup = { declaration: source.aliasSpan, qualifiers: [], references: [] };+ if (block.aliases.has(key)) block.aliases.set(key, null);+ else block.aliases.set(key, group);+ }+ blocks.push(block);+ }+ }++ // Group scopes can be discovered before their nested SELECTs. Establish containment only+ // after collecting all scopes so inner names never leak into the enclosing query.+ blocks.sort((left, right) => left.start - right.start || right.end - left.end);+ for (let index = 0; index < blocks.length; index++) {+ const block = blocks[index];+ block.parent = lastBlock(blocks.slice(0, index), (candidate) => candidate.depth < block.depth && candidate.start <= block.start && candidate.end >= block.end);+ }++ for (let index = 0; index + 2 < tokens.length; index++) {+ const qualifier = tokens[index];+ const column = tokens[index + 2];+ if (!tokenIsIdentifier(qualifier) || tokens[index + 1].text !== "." || (column.text !== "*" && !tokenIsIdentifier(column))) continue;+ // Do not mistake schema.table.column or a qualified function call for alias.column.+ if (tokens[index - 1]?.text === "." || tokens[index + 3]?.text === "." || tokens[index + 3]?.text === "(") continue;+ const block = lastBlock(blocks, (candidate) => candidate.start <= index && index < candidate.end);+ if (!block || block.sources.some((span) => span.start <= qualifier.span.start && column.span.end <= span.end)) continue;+ const key = nameOf(qualifier);+ let owner: QueryBlock | undefined = block;+ while (owner && !owner.aliases.has(key)) owner = owner.parent;+ const group = owner?.aliases.get(key);+ if (!group) continue;+ group.qualifiers.push(qualifier.span);+ group.references.push({ start: qualifier.span.start, end: column.span.end });+ }+ for (const block of blocks) {+ // Keep unreferenced declarations too: the caller still highlights the declaration itself+ // when the cursor sits on it. Only shadowed (null) entries produce no spans at all.+ for (const group of block.aliases.values()) if (group) groups.push(group);+ }+ return groups;+}diff --git a/apps/desktop/src/lib/sql/semantic/model.ts b/apps/desktop/src/lib/sql/semantic/model.tsindex 816c2661fb..408f84707e 100644--- a/apps/desktop/src/lib/sql/semantic/model.ts+++ b/apps/desktop/src/lib/sql/semantic/model.ts@@ -34,6 +34,14 @@ interface ParseState {tokens: SqlSemanticToken[];statement: SqlSemanticStatement;cteSources: SqlSemanticRowSource[];+ expandGroupedSources?: boolean;+ groupedSourceScopes?: SqlSemanticGroupedSourceScope[];+}++export interface SqlSemanticGroupedSourceScope {+ span: SqlSemanticSpan;+ depth: number;+ sources: SqlSemanticRowSource[];}interface QuerySourceRange {@@ -437,6 +445,25 @@ function parseRowSource(state: ParseState, target: number, introducer: string, sreturn parseTableFunctionSource(state, target, introducer, sourceIndex) ?? parseTableSource(state, target, introducer, sourceIndex);}+function parseRowSourceList(state: ParseState, target: number, introducer: string, sourceIndex: number): { sources: SqlSemanticRowSource[]; nextIndex: number } | null {+ const open = state.tokens[target];+ if (state.expandGroupedSources && open?.text === "(" && open.depth < 128) {+ const close = findMatchingParenToken(state.tokens, target);+ const first = state.tokens[target + 1];+ const isQuery = first?.kind === "word" && (first.normalized === "select" || first.normalized === "with");+ if (close >= 0 && !isQuery) {+ // An unaliased parenthesized join is transparent to the surrounding query scope.+ // A SELECT body or an explicitly aliased group must retain its own boundary.+ const from: SqlSemanticToken = { ...open, kind: "word", text: "from", normalized: "from", depth: open.depth + 1 };+ const sources = parseRowSourcesAtDepth({ ...state, tokens: [from, ...state.tokens.slice(target + 1, close)] }, from.depth, sourceIndex);+ if (!aliasAfter(state.tokens, close + 1, state.dialect).alias) return { sources, nextIndex: close + 1 };+ state.groupedSourceScopes?.push({ span: { start: open.span.end, end: state.tokens[close].span.start }, depth: from.depth, sources });+ }+ }+ const parsed = parseRowSource(state, target, introducer, sourceIndex);+ return parsed ? { sources: [parsed.source], nextIndex: parsed.nextIndex } : null;+}+function parseRowSourcesAtDepth(state: ParseState, sourceDepth: number, sourceIndexOffset = 0): SqlSemanticRowSource[] {const sources: SqlSemanticRowSource[] = [];let inSelectFromClause = false;@@ -449,9 +476,9 @@ function parseRowSourcesAtDepth(state: ParseState, sourceDepth: number, sourceInelse if (inSelectFromClause && FROM_CLAUSE_BOUNDARIES.has(item.normalized)) inSelectFromClause = false;}if (inSelectFromClause && item.text === ",") {- const parsed = parseRowSource(state, index + 1, "from", sourceIndexOffset + sources.length);+ const parsed = parseRowSourceList(state, index + 1, "from", sourceIndexOffset + sources.length);if (parsed) {- sources.push(parsed.source);+ sources.push(...parsed.sources);index = parsed.nextIndex - 1;}continue;@@ -465,9 +492,9 @@ function parseRowSourcesAtDepth(state: ParseState, sourceDepth: number, sourceInwhile (JOIN_MODIFIERS.has(state.tokens[target]?.normalized ?? "")) target += 1;target = sqlServerMaintenanceTableTarget(state.tokens, target, normalized, state.dialect);for (;;) {- const parsed = parseRowSource(state, target, normalized, sourceIndexOffset + sources.length);+ const parsed = parseRowSourceList(state, target, normalized, sourceIndexOffset + sources.length);if (!parsed) break;- sources.push(parsed.source);+ sources.push(...parsed.sources);index = parsed.nextIndex - 1;const separator = state.tokens[parsed.nextIndex];@@ -478,6 +505,17 @@ function parseRowSourcesAtDepth(state: ParseState, sourceDepth: number, sourceInreturn dedupeSources(sources);}+/** Parse declarations in one query block without merging outer or sibling sources. */+export function sqlSemanticQueryBlockSources(tokens: SqlSemanticToken[], options: SqlSemanticBuildOptions = {}, groupedSourceScopes?: SqlSemanticGroupedSourceScope[]): SqlSemanticRowSource[] {+ if (!tokens.length) return [];+ const statement: SqlSemanticStatement = {+ kind: statementKind(tokens),+ span: { start: tokens[0].span.start, end: tokens[tokens.length - 1].span.end },+ text: "",+ };+ return parseRowSourcesAtDepth({ dialect: sqlSemanticDialectFor(options), tokens, statement, cteSources: [], expandGroupedSources: true, groupedSourceScopes }, tokens[0].depth);+}+function querySourceRanges(tokens: readonly SqlSemanticToken[], cursor: number): QuerySourceRange[] {const rootDepth = tokens.reduce((min, item) => Math.min(min, item.depth), Number.POSITIVE_INFINITY);const fallbackDepth = Number.isFinite(rootDepth) ? rootDepth : 0;