Merge branch 'plpgsql'

Author: nene

README.md

@@ -221,6 +221,13 @@ There are also several SQL-specific options:
 
   _Since 0.12.0_
 
+- **`sqlExperimentalPlpgsql`**: `boolean` (default `false`)
+
+  When enabled, the plugin will attempt to format PL/pgSQL function bodies.
+  This might fail, as the underlying parser support for PL/pgSQL is incomplete.
+
+  _Since 0.21.0_
+
 ## Usage inside VSCode
 
 To use this plugin inside VSCode,

package.json

@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.41.0"
+    "sql-parser-cst": "^0.41.2"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

src/embedSql.ts

@@ -13,6 +13,7 @@ import {
   isStringLiteral,
 } from "./node_utils";
 import { hardline, indent, stripTrailingHardline } from "./print_utils";
+import { AllPrettierOptions } from "./options";
 
 export const embedSql: NonNullable<Printer<Node>["embed"]> = (
   path,
@@ -21,28 +22,48 @@ export const embedSql: NonNullable<Printer<Node>["embed"]> = (
   const node = path.node;
   const parent = path.getParentNode(0);
   const grandParent = path.getParentNode(1);
+  const pluginOptions: Partial<AllPrettierOptions> = options;
 
   if (
     isStringLiteral(node) &&
     isAsClause(parent) &&
-    (isCreateFunctionStmt(grandParent) || isCreateProcedureStmt(grandParent)) &&
-    grandParent.clauses.some(isSqlLanguageClause)
+    (isCreateFunctionStmt(grandParent) || isCreateProcedureStmt(grandParent))
   ) {
-    return async (textToDoc) => {
-      const quote = detectQuote(node);
-      if (!quote) {
-        return undefined;
-      }
+    if (grandParent.clauses.some(isSqlLanguageClause)) {
+      return async (textToDoc) => {
+        const quote = detectQuote(node);
+        if (!quote) {
+          return undefined;
+        }
 
-      const sql = await textToDoc(node.value, options);
+        const sql = await textToDoc(node.value, pluginOptions);
 
-      return [
-        quote,
-        indent([hardline, stripTrailingHardline(sql)]),
-        hardline,
-        quote,
-      ];
-    };
+        return [
+          quote,
+          indent([hardline, stripTrailingHardline(sql)]),
+          hardline,
+          quote,
+        ];
+      };
+    }
+    if (
+      grandParent.clauses.some(isPlpgsqlLanguageClause) &&
+      pluginOptions.sqlExperimentalPlpgsql
+    ) {
+      return async (textToDoc) => {
+        const quote = detectQuote(node);
+        if (!quote) {
+          return undefined;
+        }
+
+        const sql = await textToDoc(node.value, {
+          ...pluginOptions,
+          parser: "plpgsql",
+        });
+
+        return [quote, [hardline, stripTrailingHardline(sql)], hardline, quote];
+      };
+    }
   }
 
   return null;
@@ -53,6 +74,11 @@ const isSqlLanguageClause = (
 ): boolean =>
   isLanguageClause(clause) && clause.name.name.toLowerCase() === "sql";
 
+const isPlpgsqlLanguageClause = (
+  clause: CreateFunctionStmt["clauses"][0] | CreateProcedureStmt["clauses"][0],
+): boolean =>
+  isLanguageClause(clause) && clause.name.name.toLowerCase() === "plpgsql";
+
 const detectQuote = (node: StringLiteral): string | undefined => {
   const match = node.text.match(/^('|\$[^$]*\$)/);
   const quote = match?.[1];

src/index.ts

@@ -36,6 +36,11 @@ export const languages: SupportLanguage[] = [
     name: "Experimental PostgreSQL SQL",
     parsers: ["postgresql"],
   },
+  {
+    extensions: [],
+    name: "Experimental PL/pgSQL",
+    parsers: ["plpgsql"],
+  },
 ];
 
 const createParser = (dialect: DialectName): Parser<Node> => ({
@@ -64,6 +69,7 @@ export const parsers: Record<string, Parser<Node>> = {
   mysql: createParser("mysql"),
   mariadb: createParser("mariadb"),
   postgresql: createParser("postgresql"),
+  plpgsql: createParser("plpgsql"),
 };
 
 export const printers: Record<string, Printer> = {

src/options.ts

@@ -11,6 +11,7 @@ export interface SqlPluginOptions {
   sqlCanonicalSyntax: boolean;
   sqlFinalSemicolon: boolean;
   sqlAcceptUnsupportedGrammar: boolean;
+  sqlExperimentalPlpgsql: boolean;
 }
 
 // Prettier builtin options + options of this plugin
@@ -165,4 +166,12 @@ export const options: SupportOptions = {
       "Skips formatting unsupported SQL statements instead of exiting with an error",
     // Since 0.12.0
   },
+  sqlExperimentalPlpgsql: {
+    type: "boolean",
+    category: "SQL",
+    default: false,
+    description:
+      "Enables formatting for PL/pgSQL in PostgreSQL function bodies",
+    // Since 0.21.0
+  },
 };

src/syntax/other_clauses.ts

@@ -14,14 +14,14 @@ export const otherClausesMap: CstToDocMap<AllOtherClauses> = {
 
   as_clause: (print, node) => {
     if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
-      return print.spaced(["asKw", "expr"]);
+      return group(print.spaced(["asKw", "expr"]));
     }
-    return [print("asKw"), indent([hardline, print("expr")])];
+    return group([print("asKw"), indent([hardline, print("expr")])]);
   },
 
-  comma_clause: (print) => [",", print("expr")],
+  comma_clause: (print) => group([",", indent([line, print("expr")])]),
 
   // WHERE CURRENT OF clause
   where_current_of_clause: (print) =>
-    print.spaced(["whereCurrentOfKw", "cursor"]),
+    group(print.spaced(["whereCurrentOfKw", "cursor"])),
 };

src/syntax/prepared_statements.ts

@@ -2,9 +2,7 @@ import { AllPreparedStatementNodes } from "sql-parser-cst";
 import { group, hardline, indent, join, line } from "../print_utils";
 import { CstToDocMap } from "../CstToDocMap";
 
-export const preparedStatementsMap: Partial<
-  CstToDocMap<AllPreparedStatementNodes>
-> = {
+export const preparedStatementsMap: CstToDocMap<AllPreparedStatementNodes> = {
   // EXECUTE
   execute_stmt: (print, node) => {
     if (node.args?.type === "execute_using_clause") {
@@ -23,6 +21,11 @@ export const preparedStatementsMap: Partial<
         ...print(["into", "using"]).map((clause) => group(clause)),
       ]),
     ),
+  execute_expr: (print) =>
+    group([
+      print("executeKw"),
+      indent([line, print.separated(line, ["expr", "using"])]),
+    ]),
   execute_into_clause: (print) => print.spaced(["intoKw", "variables"]),
   execute_using_clause: (print) =>
     group([print("usingKw"), indent([line, print("values")])]),

src/syntax/procedural_language.ts

@@ -9,46 +9,79 @@ import {
 } from "../print_utils";
 import { CstToDocMap } from "../CstToDocMap";
 
-export const proceduralLanguageMap: Partial<CstToDocMap<AllProceduralNodes>> = {
+export const proceduralLanguageMap: CstToDocMap<AllProceduralNodes> = {
+  // labels
+  labeled_stmt: (print, node) =>
+    group([
+      print.spaced(["beginLabel", "statement"]),
+      node.endLabel ? [" ", print(["endLabel"])] : [],
+    ]),
+  colon_label: (print) => [print("label"), ":"],
+  chevron_label: (print) => ["<<", print("label"), ">>"],
+
   // BEGIN .. END
   block_stmt: (print, node) =>
     group([
-      print.spaced(["beginKw", "atomicKw"]),
-      indent([hardline, stripTrailingHardline(print("program"))]),
+      stripTrailingHardline(print("declareClause")),
+      [
+        node.declareClause ? hardline : [],
+        print.spaced(["beginKw", "atomicKw"]),
+      ],
+      node.program.statements.length > 0
+        ? indent([hardline, stripTrailingHardline(print("program"))])
+        : print("program"),
       node.exception ? [hardline, print("exception")] : [],
       hardline,
       print("endKw"),
     ]),
+
+  // DECLARE
+  declare_clause: (print, node) =>
+    group([print("declareKw"), indent([hardline, print("program")])]),
+  declare_stmt: (print) =>
+    group(
+      join(" ", [
+        ...print.spaced(["declareKw"]),
+        group(print("names")),
+        ...print.spaced(["constantKw", "dataType", "constraints", "init"]),
+      ]),
+    ),
+  declare_init: (print) => print.spaced(["operator", "expr"]),
+
+  // EXCEPTION
   exception_clause: (print, node) => {
     if (node.clauses.length === 1) {
       // Keep single exception clause on the same line as EXCEPTION keyword
       return group(print.spaced(["exceptionKw", "clauses"]));
     } else {
-      return group([print("exceptionKw"), indent([line, print("clauses")])]);
+      return group([
+        print("exceptionKw"),
+        indent([
+          hardline,
+          stripTrailingHardline(print("clauses").map((doc) => [doc, hardline])),
+        ]),
+      ]);
     }
   },
-  exception_when_clause: (print) =>
+  exception_when_clause: (print, node) =>
     group([
-      print.spaced(["whenKw", "condition", "thenKw"]),
-      indent([hardline, stripTrailingHardline(print("program"))]),
+      join(" ", [print("whenKw"), group(print("condition")), print("thenKw")]),
+      node.program.statements.length > 0
+        ? indent([hardline, stripTrailingHardline(print("program"))])
+        : print("program"),
     ]),
 
   error_bigquery: (print) => print("errorKw"),
-
-  // DECLARE
-  declare_stmt: (print) =>
-    group(
-      join(" ", [
-        print("declareKw"),
-        group(print("names")),
-        ...print.spaced(["dataType", "init"]),
-      ]),
-    ),
-  declare_init: (print) => print.spaced(["operator", "expr"]),
-
+  error_name: (print) => print("name"),
+  error_sqlstate: (print) => group(print.spaced(["sqlstateKw", "code"])),
+  error_format_string: (print, node) => group(print(["format", "args"])),
   // SET
   set_stmt: (print) => group(print.spaced(["setKw", "assignments"])),
 
+  // assignment
+  assignment_stmt: (print) =>
+    group(print.spaced(["target", "operator", "expr"])),
+
   // IF
   if_stmt: (print) =>
     group(join(hardline, [...print("clauses"), print.spaced("endIfKw")])),
@@ -108,6 +141,9 @@ export const proceduralLanguageMap: Partial<CstToDocMap<AllProceduralNodes>> = {
       hardline,
       print.spaced("endWhileKw"),
     ]),
+  // WHILE .. LOOP .. END LOOP
+  while_loop_stmt: (print) =>
+    group(print.spaced(["whileKw", "condition", "loop"])),
   // FOR .. IN
   for_stmt: (print) =>
     group([
@@ -116,26 +152,60 @@ export const proceduralLanguageMap: Partial<CstToDocMap<AllProceduralNodes>> = {
       hardline,
       print.spaced("endForKw"),
     ]),
-  // BREAK/CONTINUE
-  break_stmt: (print) => group(print.spaced(["breakKw", "label"])),
-  continue_stmt: (print) => group(print.spaced(["continueKw", "label"])),
-  // labels
-  labeled_stmt: (print, node) =>
+  // FOR .. IN range LOOP .. END LOOP
+  for_loop_stmt: (print) =>
+    group(print.spaced(["forKw", "left", "inKw", "right", "loop"])),
+  for_range: (print) =>
     group([
-      print.spaced(["beginLabel", "statement"]),
-      node.endLabel ? [" ", print(["endLabel"])] : [],
+      print.spaced(["reverseKw", "from"]),
+      "..",
+      print.spaced(["to", "by"]),
     ]),
-  colon_label: (print) => [print("label"), ":"],
+  for_by_clause: (print) => group(print.spaced(["byKw", "expr"])),
+  // FOREACH
+  foreach_stmt: (print) =>
+    group([
+      print.spaced([
+        "foreachKw",
+        "left",
+        "slice",
+        "inArrayKw",
+        "right",
+        "loop",
+      ]),
+    ]),
+  foreach_slice: (print) => group(print.spaced(["sliceKw", "count"])),
+  // BREAK/CONTINUE
+  break_stmt: (print) => group(print.spaced(["breakKw", "label", "when"])),
+  continue_stmt: (print) =>
+    group(print.spaced(["continueKw", "label", "when"])),
 
   // CALL
   call_stmt: (print) => group(print.spaced(["callKw", "func"])),
   // RETURN
   return_stmt: (print) => group(print.spaced(["returnKw", "expr"])),
+  return_next_stmt: (print) => group(print.spaced(["returnNextKw", "expr"])),
+  return_query_stmt: (print, node) => {
+    if (node.expr.type === "execute_expr") {
+      return group([print.spaced("returnQueryKw"), " ", print("expr")]);
+    } else {
+      return group([print.spaced("returnQueryKw"), " ", indent(print("expr"))]);
+    }
+  },
   // RAISE
-  raise_stmt: (print) => group(print.spaced(["raiseKw", "using"])),
-  raise_using_clause: (print) => group(print.spaced(["usingKw", "options"])),
-  raise_option_element: (print) => [print("nameKw"), " = ", print("value")],
+  raise_stmt: (print, node) =>
+    group([
+      print.spaced(["raiseKw", "level", "error"]),
+      node.using ? indent([line, print("using")]) : [],
+    ]),
+  raise_level: (print) => print("levelKw"),
+  raise_using_clause: (print) =>
+    group([print("usingKw"), indent([line, print("options")])]),
+  raise_option_element: (print) =>
+    group(print.spaced(["nameKw", "operator", "value"])),
   // ASSERT
   assert_stmt: (print) =>
     group(print.spaced(["assertKw", "condition", "message"])),
+  // NULL
+  null_stmt: (print) => group(print.spaced(["nullKw"])),
 };

src/syntax/transformMap.ts

@@ -51,7 +51,7 @@ import { mysqlMap } from "./dialects/mysql";
 import { sqliteMap } from "./dialects/sqlite";
 import { postgresqlMap } from "./dialects/postgresql";
 
-export const transformMap: Partial<CstToDocMap<Node>> = {
+export const transformMap: CstToDocMap<Node> = {
   ...aliasMap,
   ...alterActionMap,
   ...alterTableMap,