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。

feat(formatter): add selectable classic layout style

Abeautifulsnow6c57b0ca9bfe
diff --git a/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue b/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue
index 237a11d5e6..40a529729d 100644
--- a/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue
+++ b/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue
@@ -24,6 +24,7 @@ import {
type SqlFormatterExpressionWidth,
type SqlFormatterFromClauseLayout,
type SqlFormatterIndentStyle,
+ type SqlFormatterLayoutStyle,
type SqlFormatterLinesBetweenQueries,
type SqlFormatterLogicalOperatorNewline,
type SqlFormatterOptionSettings,
@@ -100,10 +101,16 @@ const indentStyleOptions: { value: SqlFormatterIndentStyle; labelKey: string }[]
{ value: "tabularRight", labelKey: "settings.sqlFormatterIndentStyleTabularRight" },
];
+const layoutStyleOptions: { value: SqlFormatterLayoutStyle; labelKey: string }[] = [
+ { value: "dbx", labelKey: "settings.sqlFormatterLayoutStyleDbx" },
+ { value: "classic", labelKey: "settings.sqlFormatterLayoutStyleClassic" },
+];
+
const tabWidthOptions: SqlFormatterTabWidth[] = [2, 4];
const expressionWidthOptions: SqlFormatterExpressionWidth[] = [50, 80, 120];
const linesBetweenQueriesOptions: SqlFormatterLinesBetweenQueries[] = [0, 1, 2];
const sqlFormatterOptionLabelKeys: Record<keyof SqlFormatterOptionSettings, string> = {
+ layoutStyle: "settings.sqlFormatterLayoutStyle",
keywordCase: "settings.sqlFormatterKeywordCase",
dataTypeCase: "settings.sqlFormatterDataTypeCase",
functionCase: "settings.sqlFormatterFunctionCase",
@@ -201,6 +208,10 @@ function onIndentStyle(value: any) {
if (value === "standard" || value === "tabularLeft" || value === "tabularRight") updateOption("indentStyle", value);
}
+function onLayoutStyle(value: any) {
+ if (value === "dbx" || value === "classic") updateOption("layoutStyle", value);
+}
+
function onLogicalOperatorNewline(value: any) {
if (value === "before" || value === "after" || value === "none") updateOption("logicalOperatorNewline", value);
}
@@ -578,7 +589,7 @@ onBeforeUnmount(() => {
</div>
</div>
- <div class="grid gap-4 md:grid-cols-[minmax(0,1fr)_10rem_12rem]">
+ <div class="grid gap-4 md:grid-cols-4">
<div class="space-y-2">
<Label>{{ t("settings.sqlFormatterIndent") }}</Label>
<div class="grid grid-cols-2 gap-2">
@@ -618,6 +629,20 @@ onBeforeUnmount(() => {
</SelectContent>
</Select>
</div>
+
+ <div class="space-y-2">
+ <Label>{{ t("settings.sqlFormatterLayoutStyle") }}</Label>
+ <Select :model-value="settings.layoutStyle" @update:model-value="onLayoutStyle">
+ <SelectTrigger class="w-full">
+ <SelectValue />
+ </SelectTrigger>
+ <SelectContent>
+ <SelectItem v-for="option in layoutStyleOptions" :key="option.value" :value="option.value">
+ {{ t(option.labelKey) }}
+ </SelectItem>
+ </SelectContent>
+ </Select>
+ </div>
</div>
<div class="grid gap-4 md:grid-cols-3">
diff --git a/apps/desktop/src/components/editor/__tests__/SqlFormatterLayoutStylePanel.spec.ts b/apps/desktop/src/components/editor/__tests__/SqlFormatterLayoutStylePanel.spec.ts
new file mode 100644
index 0000000000..70b9d0c669
--- /dev/null
+++ b/apps/desktop/src/components/editor/__tests__/SqlFormatterLayoutStylePanel.spec.ts
@@ -0,0 +1,47 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Source-level guard for the layout-style control in the SQL formatter panel.
+ * Mounting the panel would pull in the CodeMirror JSON editor, so the one
+ * contract that matters for issue #11228 — the style select changes only the
+ * engine, never any other option — is pinned against the component source
+ * instead.
+ *
+ * There is deliberately no "apply classic preset" action: the user's decision
+ * was that choosing the classic mode is enough, and a second control that
+ * writes only part of what the old style needs reads as a partial application
+ * of it. Do not re-add one — the two option values v0.6.16 also changed are
+ * documented, not applied for the user.
+ *
+ * This assertion reads the component as text, so it depends on its current
+ * formatting: `functionBody` requires the closing brace at column 0 — re-run
+ * this spec after any formatter run, and keep comments inside that function
+ * free of a `word:` shape, which the key-set check also scans for.
+ */
+const source = readFileSync(new URL("../SqlFormatterSettingsPanel.vue", import.meta.url), "utf8");
+
+function functionBody(name: string): string {
+ const body = source.match(new RegExp(String.raw`function ${name}\([^)]*\) \{\n([\s\S]*?)\n\}`))?.[1];
+ expect(body, `${name} not found in SqlFormatterSettingsPanel.vue`).toBeTruthy();
+ return body!;
+}
+
+describe("SQL formatter layout style panel wiring", () => {
+ it("writes only layoutStyle when the style select changes", () => {
+ const body = functionBody("onLayoutStyle");
+
+ expect(body).toContain('updateOption("layoutStyle", value)');
+ expect(body).not.toContain("expressionWidth");
+ expect(body).not.toContain("fromClauseLayout");
+ });
+
+ it("offers both layout styles and no preset action", () => {
+ expect(source).toContain('{ value: "dbx", labelKey: "settings.sqlFormatterLayoutStyleDbx" }');
+ expect(source).toContain('{ value: "classic", labelKey: "settings.sqlFormatterLayoutStyleClassic" }');
+ // One control only: the classic mode is chosen here, and nothing writes the
+ // option values it used to imply. DEFAULT_SQL_FORMATTER_SETTINGS already is
+ // the dbx end state, so Restore Defaults covers the other direction.
+ expect(source).not.toContain("ApplyClassicPreset");
+ });
+});
diff --git a/apps/desktop/src/i18n/__tests__/sqlFormatterLayoutStyleParity.spec.ts b/apps/desktop/src/i18n/__tests__/sqlFormatterLayoutStyleParity.spec.ts
new file mode 100644
index 0000000000..22e5c6a0aa
--- /dev/null
+++ b/apps/desktop/src/i18n/__tests__/sqlFormatterLayoutStyleParity.spec.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+
+/**
+ * Every locale must declare the SQL formatter layout-style strings in its own
+ * source file, not fall back to English. The check has to read the raw source:
+ * each non-en locale is wrapped in `withEnglishFallback(...)`, which deep-merges
+ * `en` under the locale at import time, so asserting on the imported modules
+ * would report the key as present even after a locale drops it.
+ */
+const LOCALE_FILES = ["az", "en", "es", "id", "it", "ja", "ko", "pt-BR", "ru", "tr", "zh-CN", "zh-TW"];
+
+const LAYOUT_STYLE_KEYS = ["sqlFormatterLayoutStyle", "sqlFormatterLayoutStyleDbx", "sqlFormatterLayoutStyleClassic"];
+
+function localeSource(name: string): string {
+ return readFileSync(new URL(`../locales/${name}.ts`, import.meta.url), "utf8");
+}
+
+function declaredString(source: string, key: string): string | undefined {
+ return source.match(new RegExp(String.raw`^\s*${key}:\s*"((?:[^"\\]|\\.)*)",\s*$`, "m"))?.[1];
+}
+
+describe("SQL formatter layout style i18n parity", () => {
+ it.each(LOCALE_FILES)("%s declares every layout-style key in its source", (name) => {
+ const source = localeSource(name);
+ for (const key of LAYOUT_STYLE_KEYS) {
+ expect(declaredString(source, key), `${name} is missing ${key}`).toBeTruthy();
+ }
+ });
+
+ it.each(LOCALE_FILES)("%s anchors the cluster after the indent-style keys", (name) => {
+ const source = localeSource(name);
+ const anchor = source.indexOf("sqlFormatterIndentStyleTabularRight:");
+ const layoutStyle = source.indexOf("sqlFormatterLayoutStyle:");
+
+ expect(anchor).toBeGreaterThan(-1);
+ expect(layoutStyle).toBeGreaterThan(anchor);
+ });
+
+ it("en carries the labels the settings panel shows", () => {
+ const source = localeSource("en");
+
+ expect(declaredString(source, "sqlFormatterLayoutStyle")).toBe("Layout style");
+ expect(declaredString(source, "sqlFormatterLayoutStyleDbx")).toBe("DBX (default)");
+ expect(declaredString(source, "sqlFormatterLayoutStyleClassic")).toBe("Classic");
+ });
+
+ it("zh-CN translates the labels instead of leaving them in English", () => {
+ const source = localeSource("zh-CN");
+
+ expect(declaredString(source, "sqlFormatterLayoutStyle")).toBe("排版风格");
+ expect(declaredString(source, "sqlFormatterLayoutStyleClassic")).toContain("经典");
+ });
+});
diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.ts
index ae1493543a..dc631ca8eb 100644
--- a/apps/desktop/src/i18n/locales/az.ts
+++ b/apps/desktop/src/i18n/locales/az.ts
@@ -7086,6 +7086,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Standart",
sqlFormatterIndentStyleTabularLeft: "Sola düzülmüş cədvəl",
sqlFormatterIndentStyleTabularRight: "Sağa düzülmüş cədvəl",
+ sqlFormatterLayoutStyle: "Düzən üslubu",
+ sqlFormatterLayoutStyleDbx: "DBX (standart)",
+ sqlFormatterLayoutStyleClassic: "Klassik",
sqlFormatterLogicalOperatorNewline: "Məntiqi operator üçün yeni sətir",
sqlFormatterLogicalBefore: "Operatordan əvvəl",
sqlFormatterLogicalAfter: "Operatordan sonra",
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 451c6d5abe..5136aba37f 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -8086,6 +8086,9 @@ export default {
sqlFormatterIndentStyleStandard: "Standard",
sqlFormatterIndentStyleTabularLeft: "Tabular left",
sqlFormatterIndentStyleTabularRight: "Tabular right",
+ sqlFormatterLayoutStyle: "Layout style",
+ sqlFormatterLayoutStyleDbx: "DBX (default)",
+ sqlFormatterLayoutStyleClassic: "Classic",
sqlFormatterLogicalOperatorNewline: "Logical operator newline",
sqlFormatterLogicalBefore: "Before operator",
sqlFormatterLogicalAfter: "After operator",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 40af272bb6..129b838bfc 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -7375,6 +7375,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Estándar",
sqlFormatterIndentStyleTabularLeft: "Tabular izquierda",
sqlFormatterIndentStyleTabularRight: "Tabular derecha",
+ sqlFormatterLayoutStyle: "Estilo de diseño",
+ sqlFormatterLayoutStyleDbx: "DBX (predeterminado)",
+ sqlFormatterLayoutStyleClassic: "Clásico",
sqlFormatterLogicalOperatorNewline: "Salto de línea en operador lógico",
sqlFormatterLogicalBefore: "Antes del operador",
sqlFormatterLogicalAfter: "Después del operador",
diff --git a/apps/desktop/src/i18n/locales/id.ts b/apps/desktop/src/i18n/locales/id.ts
index 3b75874fcb..7372aeb27e 100644
--- a/apps/desktop/src/i18n/locales/id.ts
+++ b/apps/desktop/src/i18n/locales/id.ts
@@ -7810,6 +7810,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Standar",
sqlFormatterIndentStyleTabularLeft: "Tabular rata kiri",
sqlFormatterIndentStyleTabularRight: "Tabular rata kanan",
+ sqlFormatterLayoutStyle: "Gaya tata letak",
+ sqlFormatterLayoutStyleDbx: "DBX (bawaan)",
+ sqlFormatterLayoutStyleClassic: "Klasik",
sqlFormatterLogicalOperatorNewline: "Baris baru pada operator logika",
sqlFormatterLogicalBefore: "Sebelum operator",
sqlFormatterLogicalAfter: "Setelah operator",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index d866077d4f..57be5194d5 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -7153,6 +7153,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Standard",
sqlFormatterIndentStyleTabularLeft: "Tabellare sinistra",
sqlFormatterIndentStyleTabularRight: "Tabellare destra",
+ sqlFormatterLayoutStyle: "Stile di impaginazione",
+ sqlFormatterLayoutStyleDbx: "DBX (predefinito)",
+ sqlFormatterLayoutStyleClassic: "Classico",
sqlFormatterLogicalOperatorNewline: "Nuova riga operatore logico",
sqlFormatterLogicalBefore: "Prima dell'operatore",
sqlFormatterLogicalAfter: "Dopo l'operatore",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 535ff18ef5..1cd5e022c8 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -7182,6 +7182,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "標準",
sqlFormatterIndentStyleTabularLeft: "表形式左寄せ",
sqlFormatterIndentStyleTabularRight: "表形式右寄せ",
+ sqlFormatterLayoutStyle: "レイアウトスタイル",
+ sqlFormatterLayoutStyleDbx: "DBX(デフォルト)",
+ sqlFormatterLayoutStyleClassic: "クラシック",
sqlFormatterLogicalOperatorNewline: "論理演算子の改行",
sqlFormatterLogicalBefore: "演算子の前",
sqlFormatterLogicalAfter: "演算子の後",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index 155ab95c91..6177b69636 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -6997,6 +6997,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "표준",
sqlFormatterIndentStyleTabularLeft: "표 왼쪽 정렬",
sqlFormatterIndentStyleTabularRight: "표 오른쪽 정렬",
+ sqlFormatterLayoutStyle: "레이아웃 스타일",
+ sqlFormatterLayoutStyleDbx: "DBX(기본값)",
+ sqlFormatterLayoutStyleClassic: "클래식",
sqlFormatterLogicalOperatorNewline: "논리 연산자 줄바꿈",
sqlFormatterLogicalBefore: "연산자 앞",
sqlFormatterLogicalAfter: "연산자 뒤",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index f8ba4a0b56..73e23dab09 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -7153,6 +7153,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Padrão",
sqlFormatterIndentStyleTabularLeft: "Tabular esquerda",
sqlFormatterIndentStyleTabularRight: "Tabular direita",
+ sqlFormatterLayoutStyle: "Estilo de layout",
+ sqlFormatterLayoutStyleDbx: "DBX (padrão)",
+ sqlFormatterLayoutStyleClassic: "Clássico",
sqlFormatterLogicalOperatorNewline: "Quebra de linha no operador lógico",
sqlFormatterLogicalBefore: "Antes do operador",
sqlFormatterLogicalAfter: "Depois do operador",
diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts
index 32bd07e657..859bdedf49 100644
--- a/apps/desktop/src/i18n/locales/ru.ts
+++ b/apps/desktop/src/i18n/locales/ru.ts
@@ -8395,6 +8395,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Стандартный",
sqlFormatterIndentStyleTabularLeft: "Табличный слева",
sqlFormatterIndentStyleTabularRight: "Табличный справа",
+ sqlFormatterLayoutStyle: "Стиль разметки",
+ sqlFormatterLayoutStyleDbx: "DBX (по умолчанию)",
+ sqlFormatterLayoutStyleClassic: "Классический",
sqlFormatterLogicalOperatorNewline: "Перенос логических операторов",
sqlFormatterLogicalBefore: "Перед оператором",
sqlFormatterLogicalAfter: "После оператора",
diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.ts
index 133d4d0807..cfbbd0cdd9 100644
--- a/apps/desktop/src/i18n/locales/tr.ts
+++ b/apps/desktop/src/i18n/locales/tr.ts
@@ -6967,6 +6967,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "Standart",
sqlFormatterIndentStyleTabularLeft: "Tablo biçiminde sola",
sqlFormatterIndentStyleTabularRight: "Tablo biçiminde sağa",
+ sqlFormatterLayoutStyle: "Düzen biçemi",
+ sqlFormatterLayoutStyleDbx: "DBX (varsayılan)",
+ sqlFormatterLayoutStyleClassic: "Klasik",
sqlFormatterLogicalOperatorNewline: "Mantıksal işleçte satır sonu",
sqlFormatterLogicalBefore: "İşleçten önce",
sqlFormatterLogicalAfter: "İşleçten sonra",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 51378b58b1..93d93e7f93 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -8072,6 +8072,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "标准",
sqlFormatterIndentStyleTabularLeft: "表格式左对齐",
sqlFormatterIndentStyleTabularRight: "表格式右对齐",
+ sqlFormatterLayoutStyle: "排版风格",
+ sqlFormatterLayoutStyleDbx: "DBX(默认)",
+ sqlFormatterLayoutStyleClassic: "经典",
sqlFormatterLogicalOperatorNewline: "逻辑运算符换行",
sqlFormatterLogicalBefore: "运算符前换行",
sqlFormatterLogicalAfter: "运算符后换行",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 0c81eb110e..94c5f58166 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -6507,6 +6507,9 @@ export default withEnglishFallback({
sqlFormatterIndentStyleStandard: "標準",
sqlFormatterIndentStyleTabularLeft: "表格式靠左",
sqlFormatterIndentStyleTabularRight: "表格式靠右",
+ sqlFormatterLayoutStyle: "排版風格",
+ sqlFormatterLayoutStyleDbx: "DBX(預設)",
+ sqlFormatterLayoutStyleClassic: "經典",
sqlFormatterLogicalOperatorNewline: "邏輯運算子換行",
sqlFormatterLogicalBefore: "運算子前換行",
sqlFormatterLogicalAfter: "運算子後換行",
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts
index b6dcb1f0f9..8a05897f2e 100644
--- a/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts
@@ -1,5 +1,6 @@
import { describe, expect, it } from "vitest";
import { canFormatSqlForDatabaseType, compressSqlText, formatSqlForDisplay, formatSqlForEditing, formatSqlText, MAX_SQL_FORMAT_CHARS, sqlFormatDialectForDbType, UnsupportedStructuredInputError } from "@/lib/sql/sqlFormatter";
+import type { SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
import { extractSqlParameters } from "@/lib/sql/sqlParameters";
describe("Neo4j Cypher formatting", () => {
@@ -650,3 +651,153 @@ AND owner_id = 42`,
expect(formatted).toMatch(/,\s*col2\s*-- second column/);
});
});
+
+/**
+ * `layoutStyle: "classic"` selects sql-formatter's own layout — the default
+ * before v0.6.16 replaced it with DBX's printer — so these expectations are the
+ * byte-for-byte output of the verbatim v0.6.15 `formatSqlText` (issue #11228).
+ * The layout engine alone is not a v0.6.15 reproduction: v0.6.16 also changed
+ * the `expressionWidth` and `fromClauseLayout` defaults, so both are set back
+ * explicitly. The remaining options already match the v0.6.15 defaults.
+ *
+ * Regenerate with `git show 455117b8c5^:apps/desktop/src/lib/sql/sqlFormatter.ts`
+ * imported into a throwaway spec and called with these settings; the goldens
+ * below are literals on purpose so the spec never depends on the old source.
+ */
+describe("classic layout style (v0.6.15 reproduction)", () => {
+ const classic: Partial<SqlFormatterSettings> = { layoutStyle: "classic", expressionWidth: 50, fromClauseLayout: "newLine" };
+ const lines = (...rows: string[]) => rows.join("\n");
+
+ it("reproduces a MySQL SELECT with a JOIN", async () => {
+ const sql = "select a.id, a.name, b.total, case when a.status = 1 then 'active' else 'inactive' end as status_label from users a left join orders b on a.id = b.user_id where a.created_at >= '2024-01-01' and b.total > 100 order by a.created_at desc limit 50;";
+
+ expect(await formatSqlText(sql, "mysql", classic)).toBe(
+ lines(
+ "SELECT",
+ " a.id,",
+ " a.name,",
+ " b.total,",
+ " CASE",
+ " WHEN a.status = 1 THEN 'active'",
+ " ELSE 'inactive'",
+ " END AS status_label",
+ "FROM",
+ " users a",
+ " LEFT JOIN orders b ON a.id = b.user_id",
+ "WHERE",
+ " a.created_at >= '2024-01-01'",
+ " AND b.total > 100",
+ "ORDER BY",
+ " a.created_at DESC",
+ "LIMIT",
+ " 50;",
+ ),
+ );
+ });
+
+ it("reproduces a MySQL CTE", async () => {
+ const sql = "with t as (select id, count(*) c from logs group by id) select id, c from t where c > 10";
+
+ expect(await formatSqlText(sql, "mysql", classic)).toBe(lines("WITH", " t AS (", " SELECT", " id,", " count(*) c", " FROM", " logs", " GROUP BY", " id", " )", "SELECT", " id,", " c", "FROM", " t", "WHERE", " c > 10"));
+ });
+
+ it("reproduces a MySQL CREATE TABLE", async () => {
+ const sql =
+ "CREATE TABLE IF NOT EXISTS `delivery_emp_info` (`id` varchar(20) NOT NULL comment 'pk', `emp_id` varchar(20) NOT NULL comment 'emp id', `delivery_type_ids` varchar(512) default NULL comment 'types', `update_time` datetime NOT NULL comment 'updated', CONSTRAINT idx_emp_phone UNIQUE (emp_id)) engine = innodb default charset = utf8mb4 comment 'emp info';";
+
+ // `default` / `comment` staying lowercase is genuine upstream behaviour
+ // (they are not keyword-cased in these positions), not a DBX bug to fix.
+ expect(await formatSqlText(sql, "mysql", classic)).toBe(
+ lines(
+ "CREATE TABLE IF NOT EXISTS `delivery_emp_info` (",
+ " `id` varchar(20) NOT NULL comment 'pk',",
+ " `emp_id` varchar(20) NOT NULL comment 'emp id',",
+ " `delivery_type_ids` varchar(512) default NULL comment 'types',",
+ " `update_time` datetime NOT NULL comment 'updated',",
+ " CONSTRAINT idx_emp_phone UNIQUE (emp_id)",
+ ") engine = innodb default charset = utf8mb4 comment 'emp info';",
+ ),
+ );
+ });
+
+ it("reproduces comments and blank lines", async () => {
+ const sql = "-- 头部说明\nselect id, name from users where status = 1;\n\n/* 第二段 */\nselect count(*) from orders where total > 100 and status = 'paid';";
+
+ expect(await formatSqlText(sql, "mysql", classic)).toBe(lines("-- 头部说明", "SELECT", " id,", " name", "FROM", " users", "WHERE", " status = 1;", "", "/* 第二段 */", "SELECT", " count(*)", "FROM", " orders", "WHERE", " total > 100", " AND status = 'paid';"));
+ });
+
+ it("reproduces a Doris/generic query", async () => {
+ // Doris and StarRocks have no dedicated formatter dialect, so they exercise
+ // the generic grammar plus its PostgreSQL retry.
+ const sql = "select `db`.`t`.`k`, sum(`db`.`t`.`v`) as total from `db`.`t` where `db`.`t`.`dt` = '2024-01-01' group by `db`.`t`.`k` having total > 10 order by total desc limit 20;";
+
+ expect(await formatSqlText(sql, "generic", classic)).toBe(lines("SELECT", " `db`.`t`.`k`,", " sum(`db`.`t`.`v`) AS total", "FROM", " `db`.`t`", "WHERE", " `db`.`t`.`dt` = '2024-01-01'", "GROUP BY", " `db`.`t`.`k`", "HAVING", " total > 10", "ORDER BY", " total DESC", "LIMIT", " 20;"));
+ });
+
+ it("reproduces a short statement without collapsing it", async () => {
+ const sql = "select * from task order by created_at desc;";
+
+ expect(await formatSqlText(sql, "mysql", classic)).toBe(lines("SELECT", " *", "FROM", " task", "ORDER BY", " created_at DESC;"));
+ });
+
+ it("reproduces a nested subquery", async () => {
+ const sql = "select loc_id, loc_name from (select *, row_number() over (partition by loc_id order by update_time desc) as rn from responsible_area_info where date_format(update_time, '%Y-%m') = date_format(now(), '%Y-%m')) t where rn = 1;";
+
+ expect(await formatSqlText(sql, "mysql", classic)).toBe(
+ lines(
+ "SELECT",
+ " loc_id,",
+ " loc_name",
+ "FROM",
+ " (",
+ " SELECT",
+ " *,",
+ " row_number() OVER (",
+ " PARTITION BY",
+ " loc_id",
+ " ORDER BY",
+ " update_time DESC",
+ " ) AS rn",
+ " FROM",
+ " responsible_area_info",
+ " WHERE",
+ " date_format(update_time, '%Y-%m') = date_format(now(), '%Y-%m')",
+ " ) t",
+ "WHERE",
+ " rn = 1;",
+ ),
+ );
+ });
+
+ it("normalizes the Oracle SUBSTRB family under classic (intentional divergence from v0.6.15)", async () => {
+ // v0.6.15 emitted `substrb (NAME, 1, 3)` — the byte/multibyte variants were
+ // unknown to sql-formatter's plsql grammar, so they read as identifiers.
+ // #11251 registers them as function names, and the classic path keeps that
+ // fix: these assertions pin the new behaviour, they must not be reverted.
+ const sql = "select substrb(name, 1, 3), instr2(name, 'x'), lengthb(name) from t;";
+
+ await expect(formatSqlText(sql, "oracle", { ...classic, functionCase: "upper" })).resolves.toBe(lines("SELECT", " SUBSTRB(NAME, 1, 3),", " INSTR2(NAME, 'x'),", " LENGTHB(NAME)", "FROM", " t;"));
+ });
+
+ it("keeps DBX's own printer as the default and for the explicit dbx style", async () => {
+ const sql = "select * from task order by created_at desc;";
+ const collapsed = "SELECT * FROM task ORDER BY created_at DESC;";
+
+ // Same input, opposite layouts: the collapsed form is the DBX printer's,
+ // so this proves the routing split rather than the goldens above.
+ expect(await formatSqlText(sql, "mysql", { layoutStyle: "dbx" })).toBe(collapsed);
+ expect(await formatSqlText(sql, "mysql")).toBe(collapsed);
+ // A settings object saved before `layoutStyle` existed normalizes to dbx.
+ expect(await formatSqlText(sql, "mysql", {} as Partial<SqlFormatterSettings>)).toBe(collapsed);
+ });
+
+ it("merges a classic FROM clause onto its source with a single space under the standard indent", async () => {
+ // `sameLine` (the default) merges the clause line with the source line, and
+ // the merge must not reuse the source's indent as the gap: that is the
+ // tabular styles' alignment column, but under the standard indent it would
+ // read `FROM t`. Selecting classic is now the only path to this merge, so
+ // the classic style is what pins its appearance.
+ expect(await formatSqlText("select * from t", "mysql", classic)).toBe(lines("SELECT", " *", "FROM", " t"));
+ expect(await formatSqlText("select * from t", "mysql", { ...classic, fromClauseLayout: "sameLine" })).toBe(lines("SELECT", " *", "FROM t"));
+ });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts
index ec37ae58ea..73a417b315 100644
--- a/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts
@@ -89,3 +89,42 @@ describe("sqlFormatterConfig shortcut storage", () => {
expect("commaPosition" in sqlFormatterOptions({ commaPosition: "before" })).toBe(false);
});
});
+
+describe("sqlFormatterConfig layout style", () => {
+ it("defaults to the DBX layout and keeps it out of the sql-formatter options", () => {
+ const config = JSON.parse(serializeSqlFormatterConfig({}));
+
+ expect(config.options.layoutStyle).toBe("dbx");
+ // layoutStyle is DBX-private: handing it to sql-formatter would throw.
+ expect("layoutStyle" in sqlFormatterOptions({ layoutStyle: "classic" })).toBe(false);
+ });
+
+ it("round-trips the classic layout style", () => {
+ const serialized = JSON.parse(serializeSqlFormatterConfig({ layoutStyle: "classic" }));
+ expect(serialized.options.layoutStyle).toBe("classic");
+
+ const parsed = parseSqlFormatterConfig(serializeSqlFormatterConfig({ layoutStyle: "classic" }));
+ expect(parsed).toEqual(expect.objectContaining({ ok: true }));
+ if (parsed.ok) expect(parsed.settings.layoutStyle).toBe("classic");
+ });
+
+ it("rejects a layout style outside the accepted values", () => {
+ const result = parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { layoutStyle: "upstream" } }));
+
+ expect(result).toEqual({ ok: false, message: "Invalid formatter option value: layoutStyle." });
+ });
+
+ it("accepts both config versions and rejects anything else", () => {
+ // Version 1 predates layoutStyle; absence normalizes to the current
+ // default and must never be read as a historical choice of classic.
+ const version1 = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { keywordCase: "lower" } }));
+ expect(version1).toEqual(expect.objectContaining({ ok: true }));
+ if (version1.ok) {
+ expect(version1.settings.layoutStyle).toBe("dbx");
+ expect(version1.settings.keywordCase).toBe("lower");
+ }
+
+ expect(parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { layoutStyle: "classic" } }))).toEqual(expect.objectContaining({ ok: true }));
+ expect(parseSqlFormatterConfig(JSON.stringify({ version: 3, formatter: "sql-formatter", options: {} }))).toEqual({ ok: false, message: "Unsupported config version." });
+ });
+});
diff --git a/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts b/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts
index 4fc392f79d..6a65a789a7 100644
--- a/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts
+++ b/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts
@@ -327,7 +327,10 @@ describe("settings search", () => {
{ titleKey: "settings.sqlFormatterIndent", category: "formatter", targetId: "formatter" },
{ titleKey: "settings.sqlFormatterTabWidth", category: "formatter", targetId: "formatter" },
{ titleKey: "settings.sqlFormatterIndentStyle", category: "formatter", targetId: "formatter" },
+ { titleKey: "settings.sqlFormatterLayoutStyle", category: "formatter", targetId: "formatter" },
{ titleKey: "settings.sqlFormatterLogicalOperatorNewline", category: "formatter", targetId: "formatter" },
+ { titleKey: "settings.sqlFormatterCommaPosition", category: "formatter", targetId: "formatter" },
+ { titleKey: "settings.sqlFormatterFromClauseLayout", category: "formatter", targetId: "formatter" },
{ titleKey: "settings.sqlFormatterExpressionWidth", category: "formatter", targetId: "formatter" },
{ titleKey: "settings.sqlFormatterLinesBetweenQueries", category: "formatter", targetId: "formatter" },
{ titleKey: "settings.sqlFormatterPreserveEmptyLines", category: "formatter", targetId: "formatter" },
diff --git a/apps/desktop/src/lib/settings/__tests__/settingsTransfer.spec.ts b/apps/desktop/src/lib/settings/__tests__/settingsTransfer.spec.ts
index daa2d021bd..c5e0910663 100644
--- a/apps/desktop/src/lib/settings/__tests__/settingsTransfer.spec.ts
+++ b/apps/desktop/src/lib/settings/__tests__/settingsTransfer.spec.ts
@@ -502,6 +502,45 @@ describe("settingsTransfer", () => {
expect(result.error.detail).toContain("sqlFormatter");
});
+ it("rejects unknown formatter option keys", () => {
+ const result = parseSettingsTransferFile(fileWith({ sqlFormatter: { ...DEFAULT_EDITOR_SETTINGS.sqlFormatter, layoutEngine: "dbx" } }));
+ expect(result.ok).toBe(false);
+ if (result.ok) return;
+ expect(result.error.detail).toContain("sqlFormatter");
+ });
+
+ it("rejects an invalid value for a formatter option that is present", () => {
+ const result = parseSettingsTransferFile(fileWith({ sqlFormatter: { ...DEFAULT_EDITOR_SETTINGS.sqlFormatter, layoutStyle: "upstream" } }));
+ expect(result.ok).toBe(false);
+ if (result.ok) return;
+ expect(result.error.detail).toContain("sqlFormatter");
+ });
+
+ it("imports a formatter payload exported before commaPosition existed", () => {
+ // Regression: v0.6.35 made the completeness check require every current
+ // key, so files exported by any earlier version failed to import at all.
+ const legacy: Record<string, unknown> = { ...DEFAULT_EDITOR_SETTINGS.sqlFormatter };
+ delete legacy.commaPosition;
+ const result = parseSettingsTransferFile(fileWith({ sqlFormatter: legacy }));
+
+ expect(result.ok).toBe(true);
+ if (!result.ok) return;
+ expect(result.value.editorSettings.sqlFormatter?.commaPosition).toBe("after");
+ expect(result.value.editorSettings.sqlFormatter?.keywordCase).toBe(DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase);
+ });
+
+ it("imports a formatter payload missing both post-transfer keys and defaults them", () => {
+ const legacy: Record<string, unknown> = { ...DEFAULT_EDITOR_SETTINGS.sqlFormatter };
+ delete legacy.commaPosition;
+ delete legacy.layoutStyle;
+ const result = parseSettingsTransferFile(fileWith({ sqlFormatter: legacy }));
+
+ expect(result.ok).toBe(true);
+ if (!result.ok) return;
+ expect(result.value.editorSettings.sqlFormatter?.layoutStyle).toBe("dbx");
+ expect(result.value.editorSettings.sqlFormatter?.commaPosition).toBe("after");
+ });
+
it("rejects malformed sql variable syntax overrides", () => {
const result = parseSettingsTransferFile(fileWith({ sqlVariableSyntaxOverrides: { mysql: { positional: "yes" } } }));
expect(result.ok).toBe(false);
diff --git a/apps/desktop/src/lib/settings/settingsSearch.ts b/apps/desktop/src/lib/settings/settingsSearch.ts
index 2c97b06589..e38938cbf2 100644
--- a/apps/desktop/src/lib/settings/settingsSearch.ts
+++ b/apps/desktop/src/lib/settings/settingsSearch.ts
@@ -176,6 +176,7 @@ export const SETTINGS_SEARCH_DEFINITIONS: readonly SettingsSearchDefinition[] =
{ id: "formatter-indent", category: "formatter", titleKey: "settings.sqlFormatterIndent", targetId: "formatter" },
{ id: "formatter-tab-width", category: "formatter", titleKey: "settings.sqlFormatterTabWidth", targetId: "formatter" },
{ id: "formatter-indent-style", category: "formatter", titleKey: "settings.sqlFormatterIndentStyle", targetId: "formatter" },
+ { id: "formatter-layout-style", category: "formatter", titleKey: "settings.sqlFormatterLayoutStyle", targetId: "formatter" },
{ id: "formatter-logical-operator-newline", category: "formatter", titleKey: "settings.sqlFormatterLogicalOperatorNewline", targetId: "formatter" },
{ id: "formatter-comma-position", category: "formatter", titleKey: "settings.sqlFormatterCommaPosition", targetId: "formatter" },
{ id: "formatter-from-clause-layout", category: "formatter", titleKey: "settings.sqlFormatterFromClauseLayout", targetId: "formatter" },
diff --git a/apps/desktop/src/lib/settings/settingsTransfer.ts b/apps/desktop/src/lib/settings/settingsTransfer.ts
index 699e4f094f..47dcf7ca58 100644
--- a/apps/desktop/src/lib/settings/settingsTransfer.ts
+++ b/apps/desktop/src/lib/settings/settingsTransfer.ts
@@ -3,7 +3,7 @@ import { DEFAULT_CUSTOM_THEME_COLORS, DEFAULT_CUSTOM_THEME_DDL_COLORS, DEFAULT_E
import { EDITOR_MAX_FONT_SIZE, EDITOR_MIN_FONT_SIZE } from "@/lib/editor/editorZoom";
import { DATA_GRID_TYPE_COLOR_KEYS, DATA_GRID_TYPE_COLOR_SCHEME_AUTO_ID } from "@/lib/dataGrid/dataGridTypeColorScheme";
import { SHORTCUT_DEFINITIONS } from "@/lib/editor/shortcutRegistry";
-import { isCompleteSqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
+import { DEFAULT_SQL_FORMATTER_SETTINGS, isCompleteSqlFormatterSettings, type SqlFormatterOptionSettings } from "@/lib/sql/sqlFormatterConfig";
import { SQL_VARIABLE_SYNTAX_KEYS } from "@/lib/sql/sqlVariableSyntax";
/**
@@ -455,6 +455,33 @@ function isRawToolbarItemsShape(value: unknown): boolean {
const SQL_VARIABLE_SYNTAX_KEY_SET = new Set<string>(SQL_VARIABLE_SYNTAX_KEYS);
+/**
+ * Formatter option keys introduced after the settings-transfer format shipped
+ * (v0.6.7). An export written before a key existed legitimately lacks it, so
+ * requiring every current key would reject the entire file and discard every
+ * other setting it carries — which is what happened when `commaPosition`
+ * landed in v0.6.35. Absence is only tolerated for these keys, and only
+ * because the version boundary is known; nothing is inferred about which
+ * style the user meant. Every future formatter option must be added here.
+ */
+const SQL_FORMATTER_KEYS_ADDED_AFTER_TRANSFER_FORMAT = new Set<keyof SqlFormatterOptionSettings>(["commaPosition", "layoutStyle"]);
+
+/**
+ * Complete-schema check that tolerates the absence of the post-transfer
+ * formatter keys: present keys keep the strict check (valid value, no unknown
+ * key), and the missing baseline-compatible ones are filled with their
+ * defaults before delegating, so a payload missing a baseline key such as
+ * `keywordCase` is still rejected.
+ */
+function isTransferableSqlFormatterSettings(value: unknown): boolean {
+ if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+ const filled: Record<string, unknown> = { ...(value as Record<string, unknown>) };
+ for (const key of SQL_FORMATTER_KEYS_ADDED_AFTER_TRANSFER_FORMAT) {
+ if (!(key in filled)) filled[key] = DEFAULT_SQL_FORMATTER_SETTINGS[key];
+ }
+ return isCompleteSqlFormatterSettings(filled);
+}
+
function isSqlVariableSyntaxOverridesShape(value: unknown, isAllowedToggle: (toggle: unknown) => boolean): boolean {
if (!isPlainObject(value)) return false;
return Object.values(value).every((entry) => isPlainObject(entry) && Object.entries(entry).every(([key, toggle]) => SQL_VARIABLE_SYNTAX_KEY_SET.has(key) && isAllowedToggle(toggle)));
@@ -473,7 +500,7 @@ const NESTED_FIELD_VALIDATORS: Partial<Record<EditorSettingsDraftKey, (value: un
dataGridTypeColorSchemes: (value) => isArrayOfShape(value, isDataGridTypeColorSchemeItem),
tableColumnTemplateFields: isNonEmptyStringArray,
shortcuts: isShortcutSettingsShape,
- sqlFormatter: isCompleteSqlFormatterSettings,
+ sqlFormatter: isTransferableSqlFormatterSettings,
sidebarHiddenTablePrefixes: isNonEmptyStringArray,
redisKeyTemplates: isNonEmptyStringArray,
snippets: (value) => isArrayOfShape(value, isSqlSnippetItem),
@@ -498,7 +525,7 @@ const RAW_STRUCTURED_FIELD_VALIDATORS: Partial<Record<EditorSettingsDraftKey, (v
tableColumnTemplateFields: isStringArray,
shortcuts: isRawShortcutSettingsShape,
toolbarItems: isRawToolbarItemsShape,
- sqlFormatter: isCompleteSqlFormatterSettings,
+ sqlFormatter: isTransferableSqlFormatterSettings,
sidebarHiddenTablePrefixes: isStringArray,
redisKeyTemplates: isStringArray,
snippets: (value) => isArrayOfShape(value, isSqlSnippetItem),
diff --git a/apps/desktop/src/lib/sql/sqlFormatter.ts b/apps/desktop/src/lib/sql/sqlFormatter.ts
index 988f3d0a1d..0055b647df 100644
--- a/apps/desktop/src/lib/sql/sqlFormatter.ts
+++ b/apps/desktop/src/lib/sql/sqlFormatter.ts
@@ -1,4 +1,4 @@
-import { DEFAULT_SQL_FORMATTER_SETTINGS, normalizeSqlFormatterSettings, sqlFormatterOptions, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
+import { DEFAULT_SQL_FORMATTER_SETTINGS, normalizeSqlFormatterSettings, sqlFormatterOptions, type SqlFormatterIndentStyle, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
import { formatSqlLayout, type SqlLayoutOptions } from "@/lib/sql/layout";
import { looksLikeXml } from "@/lib/sql/autoFormat";
import { compressCypherText, formatCypherText } from "@/lib/sql/cypherFormatter";
@@ -449,11 +449,14 @@ export async function formatSqlText(sql: string, dialect: SqlFormatDialect = "ge
return emptyLineProtection ? restoreProtectedEmptyLines(laidOut, emptyLineProtection.markers) : laidOut;
};
- // DBX's own layout printer produces the default style. It needs the AST and
- // sql-formatter's internal layout machinery, so it can decline an input — an
- // unparseable statement, an internal shape that moved. `null` means "use the
- // public formatter", which is also what the tabular indent styles ask for:
- // those are an alternative layout this printer deliberately does not reproduce.
+ // DBX's own layout printer produces the default `dbx` style. It needs the AST
+ // and sql-formatter's internal layout machinery, so it can decline an input —
+ // an unparseable statement, an internal shape that moved. `null` means "use
+ // the public formatter", which is also what the `classic` layout style asks
+ // for: that style is sql-formatter's own layout, i.e. the pre-v0.6.16 default,
+ // and the applySqlFormatterLayout post-passes exist to serve it. The tabular
+ // indent styles likewise are an alternative layout this printer deliberately
+ // does not reproduce.
const layoutOptions: Partial<SqlLayoutOptions> = {
lineWidth: normalizedSettings.expressionWidth,
indentWidth: normalizedSettings.tabWidth,
@@ -464,7 +467,7 @@ export async function formatSqlText(sql: string, dialect: SqlFormatDialect = "ge
logicalOperatorNewline: normalizedSettings.logicalOperatorNewline,
commaPosition: normalizedSettings.commaPosition,
};
- const usesDefaultStyle = normalizedSettings.indentStyle === "standard";
+ const usesDefaultStyle = normalizedSettings.layoutStyle === "dbx" && normalizedSettings.indentStyle === "standard";
const formatOnce = async (input: string): Promise<string> => {
const laidOut = usesDefaultStyle ? await formatSqlLayout({ sql: input, language, dialectOptions: resolvedDialect, cfg: formatterOptions, options: layoutOptions }) : null;
@@ -698,7 +701,7 @@ function normalizeLikeOperatorCase(sql: string, settings: SqlFormatterSettings,
return restoreSpans(normalized, spans);
}
-function keepFromClauseAndFirstSourceOnSameLine(sql: string): string {
+function keepFromClauseAndFirstSourceOnSameLine(sql: string, indentStyle: SqlFormatterIndentStyle): string {
const lines = sql.split("\n");
for (let index = 0; index < lines.length - 1; index += 1) {
const clauseMatch = lines[index].match(/^(\s*)FROM\s*$/i);
@@ -714,7 +717,13 @@ function keepFromClauseAndFirstSourceOnSameLine(sql: string): string {
const clauseIndent = clauseMatch[1];
const sourceIndent = sourceMatch[1];
- const separator = sourceIndent.startsWith(clauseIndent) ? sourceIndent.slice(clauseIndent.length) : " ";
+ // The source line's indent is the gap to reuse only for the tabular styles:
+ // there it is the column sql-formatter aligned every clause to, and
+ // collapsing it would destroy that alignment (`FROM t`). Under the
+ // standard indent the same indent is just the clause body's step, so reusing
+ // it doubles the gap (`FROM t`) — the upstream one-line form is a single
+ // space, and that is what merging is supposed to produce.
+ const separator = indentStyle === "standard" ? " " : sourceIndent.startsWith(clauseIndent) ? sourceIndent.slice(clauseIndent.length) : " ";
lines[index] = `${lines[index]}${separator || " "}${source}`;
lines.splice(index + 1, 1);
index -= 1;
@@ -787,7 +796,7 @@ function formatLeadingCommas(sql: string, dialect: SqlFormatDialect = "generic")
function applySqlFormatterLayout(sql: string, settings: SqlFormatterSettings, dialect: SqlFormatDialect): string {
let formatted = normalizeLikeOperatorCase(sql, settings, dialect);
if (settings.logicalOperatorNewline === "none") formatted = keepLogicalOperatorsOnSameLine(formatted, dialect);
- if (settings.fromClauseLayout === "sameLine") formatted = keepFromClauseAndFirstSourceOnSameLine(formatted);
+ if (settings.fromClauseLayout === "sameLine") formatted = keepFromClauseAndFirstSourceOnSameLine(formatted, settings.indentStyle);
if (settings.commaPosition === "before") formatted = formatLeadingCommas(formatted, dialect);
return formatted;
}
diff --git a/apps/desktop/src/lib/sql/sqlFormatterConfig.ts b/apps/desktop/src/lib/sql/sqlFormatterConfig.ts
index db759530e8..9ef0c7bee7 100644
--- a/apps/desktop/src/lib/sql/sqlFormatterConfig.ts
+++ b/apps/desktop/src/lib/sql/sqlFormatterConfig.ts
@@ -1,8 +1,14 @@
-export const SQL_FORMATTER_CONFIG_VERSION = 1;
+export const SQL_FORMATTER_CONFIG_VERSION = 2;
export const SQL_FORMATTER_CONFIG_FORMATTER = "sql-formatter";
+// Version 1 shipped from v0.5.52 through v0.6.37 and predates `commaPosition`
+// and `layoutStyle`, so it must keep parsing: a file is a record of the user's
+// options, and rejecting it would silently discard their whole config.
+const SQL_FORMATTER_CONFIG_VERSIONS = new Set([1, 2]);
+
const CASE_VALUES = ["preserve", "upper", "lower"] as const;
const INDENT_STYLE_VALUES = ["standard", "tabularLeft", "tabularRight"] as const;
+const LAYOUT_STYLE_VALUES = ["dbx", "classic"] as const;
const LOGICAL_OPERATOR_NEWLINE_VALUES = ["before", "after", "none"] as const;
const COMMA_POSITION_VALUES = ["after", "before"] as const;
const FROM_CLAUSE_LAYOUT_VALUES = ["newLine", "sameLine"] as const;
@@ -15,6 +21,7 @@ const SQL_FORMATTER_LEGACY_OPTION_KEYS = new Set(["params"]);
export type SqlFormatterCase = (typeof CASE_VALUES)[number];
export type SqlFormatterIndentStyle = (typeof INDENT_STYLE_VALUES)[number];
+export type SqlFormatterLayoutStyle = (typeof LAYOUT_STYLE_VALUES)[number];
export type SqlFormatterLogicalOperatorNewline = (typeof LOGICAL_OPERATOR_NEWLINE_VALUES)[number];
export type SqlFormatterCommaPosition = (typeof COMMA_POSITION_VALUES)[number];
export type SqlFormatterFromClauseLayout = (typeof FROM_CLAUSE_LAYOUT_VALUES)[number];
@@ -40,6 +47,9 @@ export interface SqlFormatterParamTypes {
}
export interface SqlFormatterOptionSettings {
+ // DBX-private: selects which layout engine runs and never reaches
+ // sql-formatter itself (see sqlFormatterOptions).
+ layoutStyle: SqlFormatterLayoutStyle;
keywordCase: SqlFormatterCase;
dataTypeCase: SqlFormatterCase;
functionCase: SqlFormatterCase;
@@ -69,6 +79,7 @@ export interface SqlFormatterConfigFile {
export type SqlFormatterConfigParseResult = { ok: true; settings: SqlFormatterSettings } | { ok: false; message: string };
export const DEFAULT_SQL_FORMATTER_SETTINGS: SqlFormatterSettings = {
+ layoutStyle: "dbx",
keywordCase: "upper",
dataTypeCase: "preserve",
functionCase: "preserve",
@@ -87,7 +98,14 @@ export const DEFAULT_SQL_FORMATTER_SETTINGS: SqlFormatterSettings = {
paramTypes: null,
};
+// A new key is not done when it is added here: an older settings export
+// legitimately lacks it, so it must also be registered in
+// `SQL_FORMATTER_KEYS_ADDED_AFTER_TRANSFER_FORMAT`
+// (lib/settings/settingsTransfer.ts) or every pre-existing `dbx-settings-*.json`
+// stops importing wholesale, and given a row in the `expectedControls` list of
+// lib/settings/__tests__/settingsSearch.spec.ts so its search entry stays pinned.
const SQL_FORMATTER_OPTION_KEYS = new Set<keyof SqlFormatterOptionSettings>([
+ "layoutStyle",
"keywordCase",
"dataTypeCase",
"functionCase",
@@ -107,6 +125,7 @@ const SQL_FORMATTER_OPTION_KEYS = new Set<keyof SqlFormatterOptionSettings>([
]);
const SQL_FORMATTER_OPTION_VALIDATORS: Record<keyof SqlFormatterOptionSettings, (value: unknown) => boolean> = {
+ layoutStyle: (value) => isStringChoice(value, LAYOUT_STYLE_VALUES),
keywordCase: (value) => isStringChoice(value, CASE_VALUES),
dataTypeCase: (value) => isStringChoice(value, CASE_VALUES),
functionCase: (value) => isStringChoice(value, CASE_VALUES),
@@ -190,6 +209,7 @@ function normalizeParamTypes(value: unknown, fallback: SqlFormatterParamTypes |
export function sqlFormatterOptionSettings(settings: unknown): SqlFormatterOptionSettings {
const input = isObject(settings) ? settings : {};
return {
+ layoutStyle: normalizeChoice(input.layoutStyle, LAYOUT_STYLE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.layoutStyle),
keywordCase: normalizeChoice(input.keywordCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase),
dataTypeCase: normalizeChoice(input.dataTypeCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.dataTypeCase),
functionCase: normalizeChoice(input.functionCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.functionCase),
@@ -252,7 +272,7 @@ export function parseSqlFormatterConfig(text: string): SqlFormatterConfigParseRe
}
if (!isObject(parsed)) return { ok: false, message: "Config must be a JSON object." };
- if (parsed.version !== SQL_FORMATTER_CONFIG_VERSION) return { ok: false, message: "Unsupported config version." };
+ if (typeof parsed.version !== "number" || !SQL_FORMATTER_CONFIG_VERSIONS.has(parsed.version)) return { ok: false, message: "Unsupported config version." };
if (parsed.formatter !== SQL_FORMATTER_CONFIG_FORMATTER) return { ok: false, message: "Unsupported formatter." };
if (!isObject(parsed.options)) return { ok: false, message: "Config options must be a JSON object." };
diff --git a/docs/content/docs/sql-formatter.cn.mdx b/docs/content/docs/sql-formatter.cn.mdx
index a75b62fda2..d243752af2 100644
--- a/docs/content/docs/sql-formatter.cn.mdx
+++ b/docs/content/docs/sql-formatter.cn.mdx
@@ -28,7 +28,11 @@ MongoDB 查询编辑器使用单独的 Mongo Shell 格式化器,不使用本
## 默认风格
-默认排版规则:能放下的语句保持一行,放不下的按子句逐行展开,子句的后续元素与第一个元素对齐;条件的逻辑操作符放在续行行首;`CREATE TABLE` 的列定义按列对齐。下面的设置用于调整这些规则,**恢复默认值**会回到该风格。
+默认的 `dbx` 排版规则:能放下的语句保持一行,放不下的按子句逐行展开,子句的后续元素与第一个元素对齐;条件的逻辑操作符放在续行行首;`CREATE TABLE` 的列定义按列对齐。下面的设置用于调整这些规则,**恢复默认值**会回到该风格。
+
+把 **排版风格** 设为 `classic` 会改用 sql-formatter 自身的排版,也就是 v0.6.16 之前 DBX 的默认样式。v0.6.16 同时还改过两项默认值,因此还要把 **表达式宽度** 设为 `50`、**FROM 子句布局** 设为换行,才能还原旧输出;等价的 JSON 是 `"expressionWidth": 50`、`"fromClauseLayout": "newLine"`,与 `"layoutStyle": "classic"` 并列。除 Oracle 外结果与 v0.6.15 一致:Oracle 的字节/多字节函数变体(`SUBSTRB`、`INSTR2`、`LENGTHB` 等同族函数)保留较新的修复,会被规范为函数形式。
+
+切换排版风格只切引擎,不会顺带改写其它选项。两种缩进样式(`tabularLeft`、`tabularRight`)在两种风格下都使用 sql-formatter 自身的排版。
## 配置格式化选项
@@ -36,6 +40,7 @@ MongoDB 查询编辑器使用单独的 Mongo Shell 格式化器,不使用本
| 选项 | 可用值或作用 |
| --- | --- |
+| 排版风格 | `dbx`(DBX 自研排版,默认)或 `classic`(sql-formatter 上游排版,同 v0.6.15) |
| 关键字、数据类型、函数、标识符大小写 | `upper`、`lower`、`preserve` |
| 缩进样式 | `standard`、`tabularLeft`、`tabularRight` |
| 缩进字符 | 空格或 Tab |
@@ -57,9 +62,10 @@ JSON 模式适合精确编辑、复制或迁移格式化器配置。当前配置
```json
{
- "version": 1,
+ "version": 2,
"formatter": "sql-formatter",
"options": {
+ "layoutStyle": "dbx",
"keywordCase": "upper",
"dataTypeCase": "preserve",
"functionCase": "preserve",
@@ -68,6 +74,7 @@ JSON 模式适合精确编辑、复制或迁移格式化器配置。当前配置
"useTabs": false,
"tabWidth": 2,
"logicalOperatorNewline": "before",
+ "commaPosition": "after",
"fromClauseLayout": "sameLine",
"expressionWidth": 120,
"linesBetweenQueries": 1,
@@ -82,7 +89,7 @@ JSON 模式适合精确编辑、复制或迁移格式化器配置。当前配置
JSON 编辑器会实时校验配置。以下情况会阻止应用或导入:
- JSON 语法错误;
-- `version` 不是 `1`;
+- `version` 不是 `1` 或 `2`;
- `formatter` 不是 `sql-formatter`;
- `options` 中包含未知字段;
- 字段值不在当前代码允许的范围内。
diff --git a/docs/content/docs/sql-formatter.mdx b/docs/content/docs/sql-formatter.mdx
index 9088617061..07a25fda7b 100644
--- a/docs/content/docs/sql-formatter.mdx
+++ b/docs/content/docs/sql-formatter.mdx
@@ -28,7 +28,11 @@ The MongoDB query editor uses a separate Mongo Shell formatter rather than this
## Default Style
-The default layout keeps a statement that fits the width on one line, puts each clause of a longer one on its own line, and aligns a clause's remaining elements under its first element. Conditions keep their logical operators at the start of the continuation line, and `CREATE TABLE` definitions are aligned on a column grid. The settings below change those rules; **Restore Defaults** returns to this style.
+The default `dbx` layout keeps a statement that fits the width on one line, puts each clause of a longer one on its own line, and aligns a clause's remaining elements under its first element. Conditions keep their logical operators at the start of the continuation line, and `CREATE TABLE` definitions are aligned on a column grid. The settings below change those rules; **Restore Defaults** returns to this style.
+
+Set **Layout style** to `classic` to use sql-formatter's own layout instead — the default DBX shipped before v0.6.16. v0.6.16 also changed two option defaults, so also set **Expression width** to `50` and **FROM clause layout** to the new-line value to reproduce the old output; the JSON equivalent is `"expressionWidth": 50` and `"fromClauseLayout": "newLine"`, next to `"layoutStyle": "classic"`. The result matches v0.6.15 except on Oracle, where the byte/multibyte function variants (`SUBSTRB`, `INSTR2`, `LENGTHB` and the rest of that family) keep the newer fix that normalizes them as functions.
+
+Switching the layout style only changes the engine; it never rewrites the other options. The two indent styles (`tabularLeft`, `tabularRight`) always use sql-formatter's own layout, in either mode.
## Configure Formatting Options
@@ -36,6 +40,7 @@ Open **Settings → SQL Formatter**. Form mode exposes:
| Option | Values or behavior |
| --- | --- |
+| Layout style | `dbx` (DBX's own layout, default) or `classic` (sql-formatter's upstream layout, as in v0.6.15) |
| Keyword, data type, function, and identifier case | `upper`, `lower`, or `preserve` |
| Indent style | `standard`, `tabularLeft`, or `tabularRight` |
| Indentation | Spaces or tabs |
@@ -57,9 +62,10 @@ JSON mode is useful for exact editing, copying, or moving formatter settings. Th
```json
{
- "version": 1,
+ "version": 2,
"formatter": "sql-formatter",
"options": {
+ "layoutStyle": "dbx",
"keywordCase": "upper",
"dataTypeCase": "preserve",
"functionCase": "preserve",
@@ -68,6 +74,7 @@ JSON mode is useful for exact editing, copying, or moving formatter settings. Th
"useTabs": false,
"tabWidth": 2,
"logicalOperatorNewline": "before",
+ "commaPosition": "after",
"fromClauseLayout": "sameLine",
"expressionWidth": 120,
"linesBetweenQueries": 1,
@@ -82,7 +89,7 @@ JSON mode is useful for exact editing, copying, or moving formatter settings. Th
The JSON editor validates the draft continuously. DBX blocks apply or import when:
- the text is not valid JSON;
-- `version` is not `1`;
+- `version` is not `1` or `2`;
- `formatter` is not `sql-formatter`;
- `options` contains an unknown field; or
- a value is outside the range accepted by the current build.
diff --git a/packages/app-tests/sqlFormatterConfig.test.ts b/packages/app-tests/sqlFormatterConfig.test.ts
index 2bf4d8fc39..dbc7061874 100644
--- a/packages/app-tests/sqlFormatterConfig.test.ts
+++ b/packages/app-tests/sqlFormatterConfig.test.ts
@@ -72,7 +72,7 @@ test("serializes formatter config as a stable versioned envelope", () => {
json,
JSON.stringify(
{
- version: 1,
+ version: 2,
formatter: "sql-formatter",
options: {
...defaultOptionSettings,
@@ -153,11 +153,32 @@ test("ignores legacy editor shortcut fields in formatter config files", () => {
test("rejects malformed formatter config files", () => {
assert.deepEqual(parseSqlFormatterConfig("{bad json").ok, false);
- assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: {} })).ok, false);
+ assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 3, formatter: "sql-formatter", options: {} })).ok, false);
assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "prettier", options: {} })).ok, false);
assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { unknown: true } })).ok, false);
});
+test("accepts config versions 1 and 2 and defaults a missing layoutStyle to dbx", () => {
+ const version1 = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { keywordCase: "lower" } }));
+ assert.equal(version1.ok, true);
+ if (version1.ok) {
+ assert.equal(version1.settings.layoutStyle, "dbx");
+ assert.equal(version1.settings.keywordCase, "lower");
+ }
+
+ const version2 = parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { layoutStyle: "classic" } }));
+ assert.equal(version2.ok, true);
+ if (version2.ok) assert.equal(version2.settings.layoutStyle, "classic");
+
+ const invalidStyle = parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { layoutStyle: "upstream" } }));
+ assert.equal(invalidStyle.ok, false);
+ if (!invalidStyle.ok) assert.match(invalidStyle.message, /layoutStyle/);
+
+ assert.equal(normalizeSqlFormatterSettings({}).layoutStyle, "dbx");
+ // layoutStyle is DBX-private and must never reach sql-formatter.
+ assert.equal("layoutStyle" in sqlFormatterOptions({ layoutStyle: "classic" }), false);
+});
+
test("rejects invalid known formatter option values when parsing config files", () => {
const invalidKeywordCase = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { keywordCase: "camel" } }));
assert.equal(invalidKeywordCase.ok, false);