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(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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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, sqlForma
import { 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 = "ge
return 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;
}