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(format): indent the body of a stored procedure (#13015)
弈秋a785a0e6c812
diff --git a/apps/desktop/src/lib/__tests__/sql/routineBlockLayout.spec.ts b/apps/desktop/src/lib/__tests__/sql/routineBlockLayout.spec.tsnew file mode 100644index 0000000000..e0ffd98c03--- /dev/null+++ b/apps/desktop/src/lib/__tests__/sql/routineBlockLayout.spec.ts@@ -0,0 +1,99 @@+import { describe, expect, it } from "vitest";+import { formatSqlText } from "@/lib/sql/sqlFormatter";+import { indentRoutineBlocks } from "@/lib/sql/routineBlockLayout";+import { tokenizeSqlSemantic } from "@/lib/sql/semantic/tokens";++function tokenStream(sql: string, dialect: string): string[] {+ return tokenizeSqlSemantic(sql, dialect).map((tokenValue) => tokenValue.normalized);+}++const issueProcedure = `CREATE PROCEDURE AAA AS BEGIN+SELECT *+FROM SysUser su IF EXISTS (SELECT TOP 1 1 FROM SysUser su2) BEGIN PRINT '123';++END END`;++describe("routine block layout", () => {+ it("indents the body of a T-SQL procedure", async () => {+ expect(await formatSqlText(issueProcedure, "sqlserver")).toBe(["CREATE PROCEDURE AAA", "AS", "BEGIN", " SELECT *", " FROM SysUser su", " IF EXISTS (SELECT TOP 1 1 FROM SysUser su2)", " BEGIN", " PRINT '123';", " END", "END"].join("\n"));+ });++ it("follows the configured indent width", async () => {+ const formatted = await formatSqlText(issueProcedure, "sqlserver", { tabWidth: 4 });++ expect(formatted).toContain("\n SELECT *");+ expect(formatted).toContain("\n PRINT '123';");+ expect(formatted).toContain("\n END\nEND");+ });++ it("indents with tabs when the settings ask for tabs", async () => {+ const formatted = await formatSqlText(issueProcedure, "sqlserver", { useTabs: true, tabWidth: 4 });++ expect(formatted).toContain("\n\tSELECT *");+ expect(formatted).toContain("\n\t\tPRINT '123';");+ });++ it.each([+ ["sqlserver", issueProcedure],+ ["oracle", "CREATE OR REPLACE PROCEDURE p(x IN NUMBER) AS BEGIN IF x > 0 THEN DBMS_OUTPUT.PUT_LINE('pos'); ELSE DBMS_OUTPUT.PUT_LINE('neg'); END IF; END;"],+ ["mysql", "CREATE PROCEDURE p() BEGIN SELECT 1; END"],+ ])("keeps every token of a %s routine", async (dialect, sql) => {+ const formatted = await formatSqlText(sql, dialect);++ expect(tokenStream(formatted, dialect)).toEqual(tokenStream(sql, dialect));+ });++ it("is idempotent", async () => {+ const once = await formatSqlText(issueProcedure, "sqlserver");++ expect(await formatSqlText(once, "sqlserver")).toBe(once);+ });++ it("preserves the end of MySQL hash comments before a routine header", () => {+ const sql = "# keep this comment\nCREATE PROCEDURE p() BEGIN SELECT 1; END;";+ const formatted = indentRoutineBlocks(sql, "mysql", 2, false);++ expect(formatted).toMatch(/^# keep this comment\nCREATE PROCEDURE/);+ expect(tokenStream(formatted, "mysql")).toEqual(tokenStream(sql, "mysql"));+ });++ it("keeps a CASE expression on the line its clause produced", async () => {+ const formatted = await formatSqlText("CREATE PROCEDURE p AS BEGIN SELECT CASE WHEN a = 1 THEN 'x' ELSE 'y' END AS label FROM t; END", "sqlserver");++ expect(formatted).toContain("SELECT CASE WHEN a = 1 THEN 'x' ELSE 'y' END AS label");+ expect(formatted.endsWith("\nEND")).toBe(true);+ });++ it("does not nest the statements after BEGIN TRANSACTION", async () => {+ const formatted = await formatSqlText("CREATE PROCEDURE p AS BEGIN BEGIN TRANSACTION; UPDATE t SET a = 1; COMMIT; END", "sqlserver");++ expect(formatted).toBe(["CREATE PROCEDURE p", "AS", "BEGIN", " BEGIN TRANSACTION;", " UPDATE t SET a = 1;", " COMMIT;", "END"].join("\n"));+ });++ it("keeps BEGIN TRY / END CATCH together and nests their bodies", async () => {+ const formatted = await formatSqlText("CREATE PROCEDURE p AS BEGIN BEGIN TRY SELECT 1; END TRY BEGIN CATCH SELECT 2; END CATCH END", "sqlserver");++ expect(formatted).toContain("\n BEGIN TRY\n");+ expect(formatted).toContain("\n END TRY\n");+ expect(formatted).toContain("\n BEGIN CATCH\n");+ expect(formatted).toContain("\n END CATCH\n");+ });++ it("indents a PL/SQL IF ... THEN body and its ELSE branch", async () => {+ const formatted = await formatSqlText("CREATE OR REPLACE PROCEDURE p AS BEGIN IF x > 0 THEN DBMS_OUTPUT.PUT_LINE('pos'); ELSE DBMS_OUTPUT.PUT_LINE('neg'); END IF; END;", "oracle");++ expect(formatted).toBe(["CREATE OR REPLACE PROCEDURE p", "AS", "BEGIN", " IF x > 0 THEN", " DBMS_OUTPUT.PUT_LINE('pos');", " ELSE", " DBMS_OUTPUT.PUT_LINE('neg');", " END IF;", "END;"].join("\n"));+ });++ it("collapses a signature the clause layout split one token per line", () => {+ const split = ["CREATE", "OR", "REPLACE", "PROCEDURE", "p", "(x IN NUMBER)", "AS", "BEGIN", "SELECT 1;", "END;"].join("\n");++ expect(indentRoutineBlocks(split, "oracle", 2, false)).toBe(["CREATE OR REPLACE PROCEDURE p (x IN NUMBER)", "AS", "BEGIN", " SELECT 1;", "END;"].join("\n"));+ });++ it("leaves input that is not a routine definition alone", () => {+ for (const sql of ["SELECT 1", "BEGIN TRANSACTION;\nSELECT 1;\nCOMMIT;", "CREATE TABLE t (a int)", "CREATE PROCEDURE p AS SELECT 1"]) {+ expect(indentRoutineBlocks(sql, "sqlserver", 2, false)).toBe(sql);+ }+ });+});diff --git a/apps/desktop/src/lib/sql/routineBlockLayout.ts b/apps/desktop/src/lib/sql/routineBlockLayout.tsnew file mode 100644index 0000000000..fbd5e5b202--- /dev/null+++ b/apps/desktop/src/lib/sql/routineBlockLayout.ts@@ -0,0 +1,210 @@+import { tokenizeSqlSemantic } from "@/lib/sql/semantic/tokens";+import type { SqlSemanticToken } from "@/lib/sql/semantic/types";++/**+ * Routine bodies are the one shape the clause layout printer cannot structure.+ *+ * sql-formatter's grammar has no block nodes, so `CREATE PROCEDURE ... AS BEGIN+ * ... END` parses as a flat clause list — `CREATE PROCEDURE`, `SELECT`, `FROM`,+ * and then a separate statement holding the leftover `END` keywords. The printer+ * therefore emits one clause per line at column 0, and the body keeps no+ * indentation at all, which is what users see when they format a stored+ * procedure.+ *+ * This pass restores the block structure from the token stream *after*+ * formatting: it keeps the printer's clause layout inside each statement and+ * adds the line breaks and indentation the block keywords imply. It only+ * inserts whitespace — every token is emitted verbatim, so the statement the+ * user ends up with is the one they started with, plus the missing structure.+ */++const ROUTINE_KEYWORDS = new Set(["procedure", "proc", "function", "trigger", "package"]);++/**+ * `BEGIN` also starts a transaction, which is a statement rather than a block.+ * Those forms must not open an indented body, or every following statement+ * would be nested under it.+ */+const NON_BLOCK_BEGIN = new Set(["transaction", "tran", "distributed", "work"]);++/** `END` closes a block together with the word that names it: `END IF`, `END LOOP`, ... */+const END_SUFFIXES = new Set(["if", "loop", "while", "case", "try", "catch", "repeat"]);++/**+ * Statements inside a routine body that the clause layout cannot start a line+ * for on its own — it only breaks at clause boundaries, so a `PRINT` or an `IF`+ * that follows a `FROM` would otherwise stay on that line.+ */+const STATEMENT_STARTERS = new Set(["if", "while", "else", "return", "print", "exec", "execute", "throw", "raiserror", "waitfor", "goto", "break", "continue"]);++function previousSignificantToken(tokens: SqlSemanticToken[], index: number): SqlSemanticToken | undefined {+ for (let cursor = index - 1; cursor >= 0; cursor -= 1) {+ if (tokens[cursor].kind !== "comment") return tokens[cursor];+ }+ return undefined;+}++function nextSignificantToken(tokens: SqlSemanticToken[], index: number): SqlSemanticToken | undefined {+ for (let cursor = index + 1; cursor < tokens.length; cursor += 1) {+ if (tokens[cursor].kind !== "comment") return tokens[cursor];+ }+ return undefined;+}++function wordAt(tokens: SqlSemanticToken[], index: number): string {+ const tokenValue = tokens[index];+ return tokenValue?.kind === "word" ? tokenValue.normalized : "";+}++/** `CREATE [OR ALTER|OR REPLACE] PROCEDURE|PROC|FUNCTION|TRIGGER|PACKAGE ...` */+function isRoutineDefinition(tokens: SqlSemanticToken[]): boolean {+ let cursor = 0;+ while (cursor < tokens.length && tokens[cursor].kind === "comment") cursor += 1;+ if (wordAt(tokens, cursor) !== "create") return false;+ cursor += 1;++ const next = wordAt(tokens, cursor);+ if (next === "or") {+ const modifier = wordAt(tokens, cursor + 1);+ if (modifier !== "alter" && modifier !== "replace") return false;+ cursor += 2;+ }+ return ROUTINE_KEYWORDS.has(wordAt(tokens, cursor));+}++/** A routine body only needs re-indenting when it actually contains a block. */+function hasBlockBody(tokens: SqlSemanticToken[]): boolean {+ return tokens.some((tokenValue, index) => {+ if (tokenValue.kind !== "word" || tokenValue.normalized !== "begin" || tokenValue.depth !== 0) return false;+ return !NON_BLOCK_BEGIN.has(nextSignificantToken(tokens, index)?.normalized ?? "");+ });+}++/**+ * Re-indents the block structure of a routine definition, leaving every other+ * input untouched.+ *+ * Returns `sql` unchanged unless it is a routine definition with a `BEGIN`+ * block, so callers can apply this unconditionally to formatted output.+ */+export function indentRoutineBlocks(sql: string, dialectId: string, indentWidth: number, useTabs: boolean): string {+ if (!sql.trim()) return sql;++ const tokens = tokenizeSqlSemantic(sql, dialectId);+ if (!isRoutineDefinition(tokens) || !hasBlockBody(tokens)) return sql;++ const indentUnit = useTabs ? "\t" : " ".repeat(Math.max(1, indentWidth));+ const lines: string[] = [];+ let current = "";+ let level = 0;+ // `CASE ... END` closes with the same keyword as a block, so its depth is+ // tracked separately and its `END` is never treated as a block terminator.+ let caseDepth = 0;+ // `IF ... THEN` (PL/SQL) opens a body without a `BEGIN`, so its depth is+ // counted apart from `BEGIN` blocks to let `ELSE` close and reopen it.+ let thenBlocks = 0;+ let headerDone = false;+ let forceBreak = false;+ let previousWord = "";+ let previousToken: SqlSemanticToken | undefined;++ const flush = () => {+ const trimmed = current.replace(/\s+$/, "");+ if (trimmed) lines.push(trimmed);+ current = "";+ };+ const startLine = () => {+ if (current.trim()) flush();+ };+ const write = (text: string) => {+ current = current.trim() ? current + text : indentUnit.repeat(level) + text;+ };++ for (let index = 0; index < tokens.length; index += 1) {+ const tokenValue = tokens[index];+ const gap = previousToken ? sql.slice(previousToken.span.end, tokenValue.span.start) : "";++ const word = tokenValue.kind === "word" ? tokenValue.normalized : "";+ const nextWord = nextSignificantToken(tokens, index)?.normalized ?? "";+ const previous = previousSignificantToken(tokens, index);+ const isBlockBegin = word === "begin" && tokenValue.depth === 0 && !NON_BLOCK_BEGIN.has(nextWord);+ // A `CASE` expression owns its `THEN`/`ELSE`/`END`; none of them is block syntax.+ const closesCase = word === "end" && tokenValue.depth === 0 && caseDepth > 0;+ const isBlockEnd = word === "end" && tokenValue.depth === 0 && caseDepth === 0;+ // `IF(...)` as a function call and `a = IF(...)` keep their line: only a+ // statement position starts a new one.+ const atStatementPosition = previous === undefined || (previous.kind === "word" && previous.normalized !== "select") || (previous.kind === "punctuation" && previous.text !== ",");+ // A `CASE` expression owns its `THEN`/`ELSE`/`END`; none of them is block syntax.+ const isStatementStart = STATEMENT_STARTERS.has(word) && headerDone && level > 0 && tokenValue.depth === 0 && caseDepth === 0 && previousWord !== "end" && atStatementPosition;+ const closesThenBlock = word === "else" && thenBlocks > 0;+ const breaksBeforeElse = word === "else" && caseDepth === 0;+ // The header's `AS`/`IS` separates the signature from the body and always+ // sits on a line of its own.+ const isHeaderSeparator = !headerDone && (word === "as" || word === "is") && tokenValue.depth === 0;+ // A signature stays on one line even when the printer split it: the clause+ // rules have no clause to hang a routine header on, so some dialects emit it+ // one token per line.+ const joinsHeader = !headerDone && !isHeaderSeparator && !isBlockBegin;+ // `BEGIN TRY` / `END CATCH` name their block with a second keyword, which+ // the clause layout treats as its own token and breaks away.+ const joinsBlockSuffix = (previousWord === "begin" && (word === "try" || word === "catch")) || (previousWord === "end" && END_SUFFIXES.has(word));++ if (forceBreak || (gap.includes("\n") && !joinsHeader && !joinsBlockSuffix)) {+ startLine();+ forceBreak = false;+ }+ if (isStatementStart || isBlockBegin || isBlockEnd || closesThenBlock || isHeaderSeparator || breaksBeforeElse) startLine();+ if (isBlockEnd || closesThenBlock) level = Math.max(0, level - 1);++ // The gap is empty exactly where the input had no whitespace (`a.b`, `(x)`),+ // so reusing it keeps the printer's spacing inside a line. A statement+ // terminator never takes a space, even where the printer emitted one.+ const isTerminator = tokenValue.kind === "punctuation" && tokenValue.text === ";";+ const spacing = isTerminator ? "" : gap.includes("\n") ? " " : gap;+ write((current.trim() ? spacing : "") + tokenValue.text);++ if (closesCase) {+ caseDepth -= 1;+ } else if (isBlockBegin) {+ headerDone = true;+ level += 1;+ // `BEGIN TRY` / `BEGIN CATCH` name their block, so the suffix stays on the+ // keyword's line and the break happens after it instead.+ forceBreak = !END_SUFFIXES.has(nextWord);+ } else if (word === "try" || word === "catch") {+ forceBreak = true;+ } else if (isBlockEnd) {+ forceBreak = !END_SUFFIXES.has(nextWord) && nextSignificantToken(tokens, index)?.text !== ";";+ } else if (END_SUFFIXES.has(word) && previousWord === "end") {+ if (word === "if") thenBlocks = Math.max(0, thenBlocks - 1);+ forceBreak = nextSignificantToken(tokens, index)?.text !== ";";+ } else if (word === "case") {+ caseDepth += 1;+ } else if (word === "then" && tokenValue.depth === 0 && caseDepth === 0) {+ thenBlocks += 1;+ level += 1;+ forceBreak = true;+ } else if (word === "loop" && tokenValue.depth === 0 && previousWord !== "end") {+ level += 1;+ forceBreak = true;+ } else if (closesThenBlock) {+ level += 1;+ forceBreak = true;+ } else if (breaksBeforeElse) {+ forceBreak = true;+ } else if (tokenValue.kind === "punctuation" && tokenValue.text === ";" && tokenValue.depth === 0) {+ forceBreak = true;+ } else if (tokenValue.kind === "comment" && (tokenValue.text.startsWith("--") || tokenValue.text.startsWith("#"))) {+ forceBreak = true;+ } else if (isHeaderSeparator) {+ headerDone = true;+ forceBreak = true;+ }++ if (word) previousWord = word;+ previousToken = tokenValue;+ }++ flush();+ return lines.join("\n");+}diff --git a/apps/desktop/src/lib/sql/sqlFormatter.ts b/apps/desktop/src/lib/sql/sqlFormatter.tsindex 56e1507122..9b93d99a40 100644--- a/apps/desktop/src/lib/sql/sqlFormatter.ts+++ b/apps/desktop/src/lib/sql/sqlFormatter.ts@@ -2,6 +2,7 @@ import { DEFAULT_SQL_FORMATTER_SETTINGS, normalizeSqlFormatterSettings, sqlFormaimport { formatSqlLayout, type SqlLayoutOptions } from "@/lib/sql/layout";import { looksLikeXml } from "@/lib/sql/autoFormat";import { compressCypherText, formatCypherText } from "@/lib/sql/cypherFormatter";+import { indentRoutineBlocks } from "@/lib/sql/routineBlockLayout";import { tokenizeSqlSemantic } from "@/lib/sql/semantic/tokens";export type SqlFormatDialect = "mysql" | "postgres" | "sqlite" | "sqlserver" | "oracle" | "clickhouse" | "dameng" | "duckdb" | "cypher" | "generic";@@ -571,14 +572,19 @@ export async function formatSqlText(sql: string, dialect: SqlFormatDialect = "gereturn laidOut ?? formatWithFallback(input);};+ // Routine bodies have no block nodes in sql-formatter's grammar, so the+ // clause layout prints their statements at column 0. Re-indent them once all+ // other passes have run, i.e. on text that is already the final SQL.+ const applyRoutineBlockLayout = (formatted: string): string => indentRoutineBlocks(formatted, dialect, normalizedSettings.tabWidth, normalizedSettings.useTabs);+try {- return finalizeFormattedSql(await formatOnce(protectedInput.sql));+ return applyRoutineBlockLayout(finalizeFormattedSql(await formatOnce(protectedInput.sql)));} catch (err) {const trailingDot = dialect === "dameng" ? splitTrailingStandaloneDot(protectedInput.sql) : null;if (!trailingDot) throw err;try {- return finalizeFormattedSql(`${await formatOnce(trailingDot.body)}${trailingDot.suffix}`);+ return applyRoutineBlockLayout(finalizeFormattedSql(`${await formatOnce(trailingDot.body)}${trailingDot.suffix}`));} catch {throw err;}