prettier-plugin-sql-cst 0.16.0 → 0.17.0

package/README.md

@@ -125,16 +125,100 @@ The plugin provides the following parsers:
 ## Configuration
 
 The standard Prettier options [printWidth][], [tabWidth][], [useTabs][] apply.
-There are also some SQL-specific options:
-
-| API Option                    | Default | Description                                                                                                                                                                                                                                                                                                                                          |
-| ----------------------------- | :-----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `sqlKeywordCase`              | `upper` | Convert SQL keywords to `upper` or `lower` case, or `preserve` existing. Note that for now `preserve` is somewhat incompatible with `sqlCanonicalSyntax: true` (e.g. the added `AS` keywords will always be in uppercase). In most dialects this also applies to data types, but not in PostgreSQL where data type names are treated as identifiers. |
-| `sqlLiteralCase`              | `upper` | Convert SQL literals TRUE, FALSE and NULL to `upper` or `lower` case, or `preserve` existing. Also applies to `on` & `off` literals in PostgreSQL SET statements.                                                                                                                                                                                    |
-| `sqlParamTypes`               |  `[]`   | Array of bound parameter types: `?`, `?nr`, `$nr`, `:name`, `@name`, `$name`.                                                                                                                                                                                                                                                                        |
-| `sqlCanonicalSyntax`          | `true`  | When enabled, performs some opinionated changes of keywords and operators, like enforcing the use of `AS` in aliases and replacing `<>` comparisons with `!=`. See [STYLE_GUIDE][] for more details. (Since 0.11.0)                                                                                                                                  |
-| `sqlFinalSemicolon`           | `true`  | When enabled, enforces a semicolon at the end of last statement. When disabled leaves it up to the author whether to add a final semicolon or not. (Since 0.13.0)                                                                                                                                                                                    |
-| `sqlAcceptUnsupportedGrammar` | `false` | Normally when the plugin encounters SQL syntax it doesn't support it will throw an error and won't format anything at all. With this option enabled, it will skip over SQL statements it doesn't recognize, leaving them as-is.                                                                                                                      |
+There are also several SQL-specific options:
+
+- **`sqlKeywordCase`**: `"upper" | "lower" | "preserve"` (default `"upper"`)
+
+  Enforce case of keywords.
+
+  This effects all keywords except literals (see `sqlLiteralCase`) and data types (see `sqlTypeCase`).
+
+  For now `preserve` is somewhat incompatible with `sqlCanonicalSyntax: true` (e.g. the added `AS` keywords will always be in uppercase).
+
+- **`sqlLiteralCase`**: `"upper" | "lower" | "preserve"` (default `"upper"`)
+
+  Enforce case of literals TRUE, FALSE and NULL.
+
+  Also applies to ON & OFF literals in PostgreSQL SET statements.
+
+  _Since 0.14.0_
+
+- **`sqlTypeCase`**: `"upper" | "lower" | "preserve"` (default `"upper"`)
+
+  Enforce case of type names.
+
+  In PostgreSQL this will only effect a limited set of builtin data types, the rest will be formatted as identifiers.
+  It will effect casing of all the keywords in types like `TIMESTAMP WITH TIME ZONE` and `INTERVAL DAY TO SECOND`,
+  but it won't effect the casing of `SETOF` and `TABLE` keywords in `SETOF type` and `TABLE (x int, y int)`.
+  For PostgreSQL the recommended setting of this option is `lower`.
+
+  In BigQuery this also effects the names parametric types,
+  for example `array<struct<x int64>>` will get formatted as `ARRAY<STRUCT<x INT64>>`.
+
+  _Since 0.17.0_
+
+- **`sqlIdentifierCase`**: `"upper" | "lower" | "preserve"` (default `"preserve"`)
+
+  Enforce case of unquoted identifier names.
+
+  This effects all identifiers except function names (see `sqlFunctionCase`).
+
+  Beware that in BigQuery unquoted identifiers are case-sensitive, so use of this option with BigQuery is not recommended.
+
+  **Experimental:** This option is still new and not thoroughly tested. You have been warned.
+
+  _Since 0.17.0_
+
+- **`sqlFunctionCase`**: `"upper" | "lower" | "preserve"` (default `"preserve"`)
+
+  Enforce case of unquoted function names.
+
+  This option also applies to schema-qualified function names,
+  for example `my_schema.foo()` will get formatted as `my_schema.FOO()`
+  when `sqlFunctionCase: "upper"` is configured.
+
+  **Experimental:** This option is still new and not thoroughly tested. You have been warned.
+
+  _Since 0.17.0_
+
+- **`sqlParamTypes`**: `("?", "?nr", "$nr", ":name", "$name", "@name" "@``@name``")[]` (default `[]`)
+
+  Array of bound parameter types to support.
+
+  By default the parser will reject the following SQL:
+
+  ```sql
+  SELECT id, name FROM products WHERE price > ? AND category = ?
+  ```
+
+  Configuring `sqlParamTypes: ["?"]` will make the parser recognize the `?` placeholders.
+
+  _Since 0.7.0_
+
+- **`sqlCanonicalSyntax`**: `boolean` (default `true`)
+
+  When enabled, performs some opinionated changes of keywords and operators,
+  like enforcing the use of `AS` in aliases and replacing `<>` comparisons with `!=`.
+  See [STYLE_GUIDE][] for more details.
+
+  _Since 0.11.0_
+
+- **`sqlFinalSemicolon`**: `boolean` (default `true`)
+
+  When enabled, enforces a semicolon at the end of last statement.
+  When disabled leaves it up to the author whether to add a final semicolon or not.
+
+  _Since 0.13.0_
+
+- **`sqlAcceptUnsupportedGrammar`**: `boolean` (default `false`)
+
+  Normally when the plugin encounters SQL syntax it doesn't support
+  it will throw an error and won't format anything at all.
+  With this option enabled, it will skip over SQL statements it doesn't recognize, leaving them as-is.
+
+  **Deprecated:** This doesn't really work as advertised and will likely be removed.
+
+  _Since 0.12.0_
 
 ## Usage inside VSCode
 

package/dist/node_utils.d.ts

@@ -12,9 +12,24 @@ export declare const isStringLiteral: (node: any) => node is import("sql-parser-
 export declare const isArraySubscript: (node: any) => node is import("sql-parser-cst").ArraySubscript;
 export declare const isAsClause: (node: any) => node is import("sql-parser-cst").AsClause<Node>;
 export declare const isParenExpr: (node: any) => node is import("sql-parser-cst").ParenExpr<Node>;
+export declare const isMemberExpr: (node: any) => node is import("sql-parser-cst").MemberExpr;
 export declare const isSelectStmt: (node: any) => node is import("sql-parser-cst").SelectStmt;
 export declare const isCompoundSelectStmt: (node: any) => node is import("sql-parser-cst").CompoundSelectStmt;
 export declare const isListExpr: (node: any) => node is import("sql-parser-cst").ListExpr<Node>;
 export declare const isCreateFunctionStmt: (node: any) => node is import("sql-parser-cst").CreateFunctionStmt;
+export declare const isAlterFunctionStmt: (node: any) => node is import("sql-parser-cst").AlterFunctionStmt;
+export declare const isDropFunctionStmt: (node: any) => node is import("sql-parser-cst").DropFunctionStmt;
+export declare const isCreateProcedureStmt: (node: any) => node is import("sql-parser-cst").CreateProcedureStmt;
+export declare const isAlterProcedureStmt: (node: any) => node is import("sql-parser-cst").AlterProcedureStmt;
+export declare const isDropProcedureStmt: (node: any) => node is import("sql-parser-cst").DropProcedureStmt;
+export declare const isAlterActionRename: (node: any) => node is import("sql-parser-cst").AlterActionRename;
 export declare const isLanguageClause: (node: any) => node is import("sql-parser-cst").LanguageClause;
 export declare const isDynamicallyLoadedFunction: (node: any) => node is import("sql-parser-cst").DynamicallyLoadedFunction;
+export declare const isBigqueryQuotedMemberExpr: (node: any) => node is import("sql-parser-cst").BigQueryQuotedMemberExpr;
+export declare const isCreateTriggerStmt: (node: any) => node is import("sql-parser-cst").CreateTriggerStmt;
+export declare const isExecuteClause: (node: any) => node is import("sql-parser-cst").ExecuteClause;
+export declare const isDataTypeName: (node: any) => node is import("sql-parser-cst").DataTypeName;
+export declare const isIntervalDataType: (node: any) => node is import("sql-parser-cst").IntervalDataType;
+export declare const isTimeDataType: (node: any) => node is import("sql-parser-cst").TimeDataType;
+export declare const isParametricDataType: (node: any) => node is import("sql-parser-cst").ParametricDataType;
+export declare const isDataType: (node: any) => boolean;

package/dist/node_utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDynamicallyLoadedFunction = exports.isLanguageClause = exports.isCreateFunctionStmt = exports.isListExpr = exports.isCompoundSelectStmt = exports.isSelectStmt = exports.isParenExpr = exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonbLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncArgs = exports.isFuncCall = exports.isValuesClause = exports.isProgram = void 0;
+exports.isDataType = exports.isParametricDataType = exports.isTimeDataType = exports.isIntervalDataType = exports.isDataTypeName = exports.isExecuteClause = exports.isCreateTriggerStmt = exports.isBigqueryQuotedMemberExpr = exports.isDynamicallyLoadedFunction = exports.isLanguageClause = exports.isAlterActionRename = exports.isDropProcedureStmt = exports.isAlterProcedureStmt = exports.isCreateProcedureStmt = exports.isDropFunctionStmt = exports.isAlterFunctionStmt = exports.isCreateFunctionStmt = exports.isListExpr = exports.isCompoundSelectStmt = exports.isSelectStmt = exports.isMemberExpr = exports.isParenExpr = exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonbLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncArgs = exports.isFuncCall = exports.isValuesClause = exports.isProgram = void 0;
 var utils_1 = require("./utils");
 var is = function (type) {
     return function (node) {
@@ -20,9 +20,30 @@ exports.isStringLiteral = is("string_literal");
 exports.isArraySubscript = is("array_subscript");
 exports.isAsClause = is("as_clause");
 exports.isParenExpr = is("paren_expr");
+exports.isMemberExpr = is("member_expr");
 exports.isSelectStmt = is("select_stmt");
 exports.isCompoundSelectStmt = is("compound_select_stmt");
 exports.isListExpr = is("list_expr");
 exports.isCreateFunctionStmt = is("create_function_stmt");
+exports.isAlterFunctionStmt = is("alter_function_stmt");
+exports.isDropFunctionStmt = is("drop_function_stmt");
+exports.isCreateProcedureStmt = is("create_procedure_stmt");
+exports.isAlterProcedureStmt = is("alter_procedure_stmt");
+exports.isDropProcedureStmt = is("drop_procedure_stmt");
+exports.isAlterActionRename = is("alter_action_rename");
 exports.isLanguageClause = is("language_clause");
 exports.isDynamicallyLoadedFunction = is("dynamically_loaded_function");
+exports.isBigqueryQuotedMemberExpr = is("bigquery_quoted_member_expr");
+exports.isCreateTriggerStmt = is("create_trigger_stmt");
+exports.isExecuteClause = is("execute_clause");
+exports.isDataTypeName = is("data_type_name");
+exports.isIntervalDataType = is("interval_data_type");
+exports.isTimeDataType = is("time_data_type");
+exports.isParametricDataType = is("parametric_data_type");
+var isDataType = function (node) {
+    return (0, exports.isDataTypeName)(node) ||
+        (0, exports.isIntervalDataType)(node) ||
+        (0, exports.isTimeDataType)(node) ||
+        (0, exports.isParametricDataType)(node);
+};
+exports.isDataType = isDataType;

package/dist/options.d.ts

@@ -3,6 +3,9 @@ import { Node, ParserOptions as CstParserOptions } from "sql-parser-cst";
 export interface SqlPluginOptions {
     sqlKeywordCase: "preserve" | "upper" | "lower";
     sqlLiteralCase: "preserve" | "upper" | "lower";
+    sqlTypeCase: "preserve" | "upper" | "lower";
+    sqlIdentifierCase: "preserve" | "upper" | "lower";
+    sqlFunctionCase: "preserve" | "upper" | "lower";
     sqlParamTypes: NonNullable<CstParserOptions["paramTypes"]>;
     sqlCanonicalSyntax: boolean;
     sqlFinalSemicolon: boolean;

package/dist/options.js

@@ -38,16 +38,85 @@ exports.options = {
             },
             {
                 value: "upper",
-                description: "forces all keywords to uppercase",
+                description: "forces all literals to uppercase",
                 since: "0.14.0",
             },
             {
                 value: "lower",
-                description: "forces all keywords to lowercase",
+                description: "forces all literals to lowercase",
                 since: "0.14.0",
             },
         ],
     },
+    sqlTypeCase: {
+        type: "choice",
+        category: "SQL",
+        default: "upper",
+        description: "Enforces upper/lower case for SQL types",
+        choices: [
+            {
+                value: "preserve",
+                description: "preserves the existing case",
+                since: "0.17.0",
+            },
+            {
+                value: "upper",
+                description: "forces all type names to uppercase",
+                since: "0.17.0",
+            },
+            {
+                value: "lower",
+                description: "forces all type names to lowercase",
+                since: "0.17.0",
+            },
+        ],
+    },
+    sqlIdentifierCase: {
+        type: "choice",
+        category: "SQL",
+        default: "preserve",
+        description: "Enforces upper/lower case for unquoted SQL identifiers",
+        choices: [
+            {
+                value: "preserve",
+                description: "preserves the existing case",
+                since: "0.17.0",
+            },
+            {
+                value: "upper",
+                description: "forces all unquoted identifier names to uppercase",
+                since: "0.17.0",
+            },
+            {
+                value: "lower",
+                description: "forces all unquoted identifier names to lowercase",
+                since: "0.17.0",
+            },
+        ],
+    },
+    sqlFunctionCase: {
+        type: "choice",
+        category: "SQL",
+        default: "preserve",
+        description: "Enforces upper/lower case for SQL function names",
+        choices: [
+            {
+                value: "preserve",
+                description: "preserves the existing case",
+                since: "0.17.0",
+            },
+            {
+                value: "upper",
+                description: "forces all unquoted function names to uppercase",
+                since: "0.17.0",
+            },
+            {
+                value: "lower",
+                description: "forces all unquoted function names to lowercase",
+                since: "0.17.0",
+            },
+        ],
+    },
     sqlParamTypes: {
         type: "string",
         array: true,
@@ -55,7 +124,7 @@ exports.options = {
         default: [{ value: [] }],
         description: "Syntax for bound parameters",
         // Since 0.7.0
-        // Possible values in array: "?" | "?nr" | "$nr" | ":name" | "$name" | "@name"
+        // Possible values in array: "?" | "?nr" | "$nr" | ":name" | "$name" | "@name" | "@`name`"
     },
     sqlCanonicalSyntax: {
         type: "boolean",

package/dist/syntax/analyze.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeMap = void 0;
+var print_utils_1 = require("../print_utils");
 exports.analyzeMap = {
-    analyze_stmt: function (print) { return print.spaced(["analyzeKw", "tableKw", "tables"]); },
+    analyze_stmt: function (print) {
+        return (0, print_utils_1.group)(print.spaced(["analyzeKw", "tableKw", "tables"]));
+    },
 };

package/dist/syntax/base.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.baseMap = void 0;
+var node_utils_1 = require("../node_utils");
 exports.baseMap = {
     /** cst-ignore: name */
     keyword: function (print, node, path, options) {
-        var _a;
-        // Treat PostgreSQL "WITH TIME ZONE" as part of data type, not keyword,
-        // so skip keyword case conversion for it
-        if (((_a = path.parent) === null || _a === void 0 ? void 0 : _a.type) === "with_time_zone_data_type") {
-            return path.node.text;
-        }
-        switch (options.sqlKeywordCase) {
+        var keywordCase = (0, node_utils_1.isDataType)(path.parent)
+            ? options.sqlTypeCase
+            : options.sqlKeywordCase;
+        switch (keywordCase) {
             case "preserve":
                 return path.node.text;
             case "upper":

package/dist/syntax/create_table.js

@@ -19,7 +19,7 @@ exports.createTableMap = {
         for (var _i = 2; _i < arguments.length; _i++) {
             rest[_i - 2] = arguments[_i];
         }
-        return [
+        return (0, print_utils_1.group)([
             print.spaced([
                 "createKw",
                 "orReplaceKw",
@@ -33,7 +33,7 @@ exports.createTableMap = {
             ]),
             printClauses.apply(void 0, __spreadArray([print, node], rest, false)),
             node.options ? [print_utils_1.line, (0, print_utils_1.group)(print("options"))] : [],
-        ];
+        ]);
     },
     relation_kind: function (print) { return print.spaced("kindKw"); },
     column_definition: function (print) {

package/dist/syntax/data_type.js

@@ -1,20 +1,39 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dataTypeMap = void 0;
 var utils_1 = require("../utils");
 var print_utils_1 = require("../print_utils");
+var node_utils_1 = require("../node_utils");
 exports.dataTypeMap = {
+    data_type_name: function (print) { return print.spaced("name"); },
     // print single-word types as `TYPE(10)` and multi-word types as `MY TYPE (10)`
-    named_data_type: function (print, node) {
-        return (isMultiWordTypeName(node) ? print.spaced : print)(["name", "params"]);
+    modified_data_type: function (print, node) {
+        return (isMultiWordTypeName(node.dataType) ? print.spaced : print)([
+            "dataType",
+            "modifiers",
+        ]);
     },
-    data_type_identifier: function (print) { return print.spaced("name"); },
     setof_data_type: function (print) { return print.spaced(["setofKw", "dataType"]); },
     array_data_type: function (print) { return print(["dataType", "bounds"]); },
     array_bounds: function (print) { return ["[", print("bounds"), "]"]; },
-    with_time_zone_data_type: function (print) {
-        return print.spaced(["dataType", "withTimeZoneKw"]);
+    time_data_type: function (print, node) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(" ", __spreadArray([
+            print(["timeKw", "precision"])
+        ], (node.timeZoneKw ? [print.spaced("timeZoneKw")] : []), true)));
+    },
+    interval_data_type: function (print) {
+        return print.spaced(["intervalKw", "fieldsKw", "precision"]);
     },
+    parametric_data_type: function (print) { return print(["typeKw", "params"]); },
     generic_type_params: function (print) {
         return (0, print_utils_1.group)(["<", (0, print_utils_1.indent)([print_utils_1.softline, print("params")]), print_utils_1.softline, ">"]);
     },
@@ -25,6 +44,5 @@ exports.dataTypeMap = {
     table_data_type: function (print) { return print.spaced(["tableKw", "columns"]); },
 };
 function isMultiWordTypeName(node) {
-    return ((0, utils_1.isArray)(node.name) ||
-        (node.name.type === "data_type_identifier" && (0, utils_1.isArray)(node.name.name)));
+    return (0, node_utils_1.isDataTypeName)(node) && (0, utils_1.isArray)(node.name) && node.name.length > 1;
 }

package/dist/syntax/dialects/bigquery.js

@@ -18,7 +18,7 @@ exports.bigqueryMap = {
     },
     // ROW ACCESS POLICY
     create_row_access_policy_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
             print.spaced([
                 "createKw",
                 "orReplaceKw",
@@ -28,7 +28,7 @@ exports.bigqueryMap = {
                 "onKw",
                 "table",
             ])
-        ], print("clauses"), true));
+        ], print("clauses"), true)));
     },
     row_access_policy_grant_clause: function (print) {
         return print.spaced(["grantToKw", "grantees"]);
@@ -37,7 +37,7 @@ exports.bigqueryMap = {
         return print.spaced(["filterUsingKw", "expr"]);
     },
     drop_row_access_policy_stmt: function (print) {
-        return print.spaced([
+        return (0, print_utils_1.group)(print.spaced([
             "dropKw",
             "allKw",
             "rowAccessPolicyKw",
@@ -45,80 +45,86 @@ exports.bigqueryMap = {
             "name",
             "onKw",
             "table",
-        ]);
+        ]));
     },
     // CAPACITY
-    create_capacity_stmt: function (print) { return [
-        print.spaced(["createKw", "capacityKw", "name"]),
-        print_utils_1.hardline,
-        print("options"),
-    ]; },
+    create_capacity_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["createKw", "capacityKw", "name"]),
+            print_utils_1.hardline,
+            print("options"),
+        ]);
+    },
     drop_capacity_stmt: function (print) {
-        return print.spaced(["dropKw", "capacityKw", "ifExistsKw", "name"]);
+        return (0, print_utils_1.group)(print.spaced(["dropKw", "capacityKw", "ifExistsKw", "name"]));
     },
     // RESERVATION
-    create_reservation_stmt: function (print) { return [
-        print.spaced(["createKw", "reservationKw", "name"]),
-        print_utils_1.hardline,
-        print("options"),
-    ]; },
+    create_reservation_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["createKw", "reservationKw", "name"]),
+            print_utils_1.hardline,
+            print("options"),
+        ]);
+    },
     drop_reservation_stmt: function (print) {
-        return print.spaced(["dropKw", "reservationKw", "ifExistsKw", "name"]);
+        return (0, print_utils_1.group)(print.spaced(["dropKw", "reservationKw", "ifExistsKw", "name"]));
     },
     // ASSIGNMENT
-    create_assignment_stmt: function (print) { return [
-        print.spaced(["createKw", "assignmentKw", "name"]),
-        print_utils_1.hardline,
-        print("options"),
-    ]; },
+    create_assignment_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["createKw", "assignmentKw", "name"]),
+            print_utils_1.hardline,
+            print("options"),
+        ]);
+    },
     drop_assignment_stmt: function (print) {
-        return print.spaced(["dropKw", "assignmentKw", "ifExistsKw", "name"]);
+        return (0, print_utils_1.group)(print.spaced(["dropKw", "assignmentKw", "ifExistsKw", "name"]));
     },
     // ALTER ORGANIZATION
     alter_organization_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [print.spaced("alterOrganizationKw"), print("actions")]);
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [print.spaced("alterOrganizationKw"), print("actions")]));
     },
     // ALTER PROJECT
     alter_project_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [
             print.spaced(["alterProjectKw", "name"]),
             print("actions"),
-        ]);
+        ]));
     },
     alter_bi_capacity_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [
             print.spaced(["alterBiCapacityKw", "name"]),
             print("actions"),
-        ]);
+        ]));
     },
     alter_capacity_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [
             print.spaced(["alterCapacityKw", "name"]),
             print("actions"),
-        ]);
+        ]));
     },
     alter_reservation_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [
             print.spaced(["alterReservationKw", "name"]),
             print("actions"),
-        ]);
+        ]));
     },
     // ASSERT
-    assert_stmt: function (print) { return print.spaced(["assertKw", "expr", "as"]); },
+    assert_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["assertKw", "expr", "as"])); },
     // EXPORT
     export_data_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray(__spreadArray([
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray(__spreadArray([
             print.spaced("exportDataKw")
         ], print.spaced(["withConnection"]), true), [
             print.spaced("options"),
             print.spaced("as"),
-        ], false));
+        ], false)));
     },
     // LOAD
     load_data_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
             print.spaced(["loadDataKw", "intoKw", "table", "columns"])
-        ], print("clauses"), true));
+        ], print("clauses"), true)));
     },
     from_files_options: function (print) { return print.spaced(["fromFilesKw", "options"]); },
 };

package/dist/syntax/dialects/sqlite.js

@@ -4,15 +4,15 @@ exports.sqliteMap = void 0;
 var print_utils_1 = require("../../print_utils");
 exports.sqliteMap = {
     attach_database_stmt: function (print) {
-        return print.spaced(["attachKw", "databaseKw", "file", "asKw", "schema"]);
+        return (0, print_utils_1.group)(print.spaced(["attachKw", "databaseKw", "file", "asKw", "schema"]));
     },
     detach_database_stmt: function (print) {
-        return print.spaced(["detachKw", "databaseKw", "schema"]);
+        return (0, print_utils_1.group)(print.spaced(["detachKw", "databaseKw", "schema"]));
     },
     vacuum_stmt: function (print) {
-        return print.spaced(["vacuumKw", "schema", "intoKw", "file"]);
+        return (0, print_utils_1.group)(print.spaced(["vacuumKw", "schema", "intoKw", "file"]));
     },
-    pragma_stmt: function (print) { return print.spaced(["pragmaKw", "pragma"]); },
+    pragma_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["pragmaKw", "pragma"])); },
     pragma_assignment: function (print) { return (0, print_utils_1.join)(" = ", print(["name", "value"])); },
     pragma_func_call: function (print) { return print(["name", "args"]); },
 };

package/dist/syntax/do.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.doMap = void 0;
+var print_utils_1 = require("../print_utils");
 exports.doMap = {
-    do_stmt: function (print) { return print.spaced(["doKw", "language", "body"]); },
+    do_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["doKw", "language", "body"])); },
 };

package/dist/syntax/drop_table.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropTableMap = void 0;
+var print_utils_1 = require("../print_utils");
 exports.dropTableMap = {
     drop_table_stmt: function (print) {
-        return print.spaced([
+        return (0, print_utils_1.group)(print.spaced([
             "dropKw",
             "kind",
             "tableKw",
             "ifExistsKw",
             "tables",
             "behaviorKw",
-        ]);
+        ]));
     },
 };

package/dist/syntax/expr.d.ts

@@ -1,5 +1,5 @@
 import { AllExprNodes, Keyword } from "sql-parser-cst";
 import { CstToDocMap } from "../CstToDocMap";
-import { AllPrettierOptions } from "src/options";
+import { AllPrettierOptions } from "../options";
 export declare const exprMap: CstToDocMap<AllExprNodes>;
 export declare const printLiteral: <T>(node: Keyword, options: AllPrettierOptions<T>) => string;

package/dist/syntax/expr.js

@@ -182,10 +182,26 @@ exports.exprMap = {
     json_literal: function (print) { return print.spaced(["jsonKw", "string"]); },
     jsonb_literal: function (print) { return print.spaced(["jsonbKw", "string"]); },
     /** cst-ignore: name */
-    identifier: function (print) { return print("text"); },
+    identifier: function (print, node, path, options) {
+        if (isQuotedIdentifier(node) || isInsideBigqueryQuotedMemberExpr(path)) {
+            return print("text");
+        }
+        else {
+            if (isFunctionName(node, path)) {
+                return printFunctionName(node, options);
+            }
+            else {
+                return printIdentifier(node, options);
+            }
+        }
+    },
     /** cst-ignore: name */
-    variable: function (print) { return print("text"); },
-    parameter: function (print) { return print("text"); },
+    variable: function (print, node, path, options) {
+        return isQuotedVariable(node) ? print("text") : printIdentifier(node, options);
+    },
+    parameter: function (print, node, path, options) {
+        return isQuotedParameter(node) ? print("text") : printIdentifier(node, options);
+    },
 };
 var printLiteral = function (node, options) {
     switch (options.sqlLiteralCase) {
@@ -198,6 +214,59 @@ var printLiteral = function (node, options) {
     }
 };
 exports.printLiteral = printLiteral;
+var printIdentifier = function (node, options) {
+    switch (options.sqlIdentifierCase) {
+        case "preserve":
+            return node.text;
+        case "upper":
+            return node.text.toUpperCase();
+        case "lower":
+            return node.text.toLowerCase();
+    }
+};
+var printFunctionName = function (node, options) {
+    switch (options.sqlFunctionCase) {
+        case "preserve":
+            return node.text;
+        case "upper":
+            return node.text.toUpperCase();
+        case "lower":
+            return node.text.toLowerCase();
+    }
+};
+var isQuotedIdentifier = function (node) {
+    return node.name !== node.text;
+};
+var isQuotedVariable = function (node) {
+    return !(node.text === "@" + node.name || node.text === "@@" + node.name);
+};
+var isQuotedParameter = function (node) { return /`$/.test(node.text); };
+var isInsideBigqueryQuotedMemberExpr = function (path) {
+    return path.ancestors.some(node_utils_1.isBigqueryQuotedMemberExpr);
+};
+var isFunctionName = function (node, path) {
+    var parent = path.parent;
+    if (isFunctionContext(parent, path.grandparent)) {
+        return true;
+    }
+    if ((0, node_utils_1.isMemberExpr)(parent) && parent.property === node) {
+        var _a = path.ancestors, _ = _a[0], gp = _a[1], ggp = _a[2];
+        return isFunctionContext(gp, ggp);
+    }
+    return false;
+};
+var isFunctionContext = function (node, parent) {
+    return ((0, node_utils_1.isFuncCall)(node) ||
+        (0, node_utils_1.isCreateFunctionStmt)(node) ||
+        (0, node_utils_1.isCreateProcedureStmt)(node) ||
+        (0, node_utils_1.isAlterFunctionStmt)(node) ||
+        (0, node_utils_1.isAlterProcedureStmt)(node) ||
+        ((0, node_utils_1.isAlterActionRename)(node) &&
+            ((0, node_utils_1.isAlterFunctionStmt)(parent) || (0, node_utils_1.isAlterProcedureStmt)(parent))) ||
+        (0, node_utils_1.isDropFunctionStmt)(node) ||
+        (0, node_utils_1.isDropProcedureStmt)(node) ||
+        ((0, node_utils_1.isExecuteClause)(node) && (0, node_utils_1.isCreateTriggerStmt)(parent)));
+};
 var isBooleanOp = function (_a) {
     var name = _a.name;
     return name === "AND" || name === "OR";

package/dist/syntax/function.d.ts

@@ -1,3 +1,4 @@
-import { AllFunctionNodes } from "sql-parser-cst";
+import { AllFunctionNodes, CreateFunctionStmt, CreateProcedureStmt } from "sql-parser-cst";
 import { CstToDocMap } from "../CstToDocMap";
 export declare const functionMap: CstToDocMap<AllFunctionNodes>;
+export declare const hasOnlyAsClause: (node: CreateFunctionStmt | CreateProcedureStmt) => boolean;

package/dist/syntax/function.js

@@ -1,27 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionMap = void 0;
+exports.hasOnlyAsClause = exports.functionMap = void 0;
 var print_utils_1 = require("../print_utils");
 var node_utils_1 = require("../node_utils");
 exports.functionMap = {
-    create_function_stmt: function (print, node) { return [
-        print.spaced([
-            "createKw",
-            "orReplaceKw",
-            "temporaryKw",
-            "tableKw",
-            "functionKw",
-            "ifNotExistsKw",
-            "name",
-        ]),
-        print("params"),
-        hasOnlyAsClause(node)
-            ? [" ", (0, print_utils_1.group)(print("clauses"))]
-            : [
-                print_utils_1.hardline,
-                (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (cls) { return (0, print_utils_1.group)(cls); })),
-            ],
-    ]; },
+    create_function_stmt: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced([
+                "createKw",
+                "orReplaceKw",
+                "temporaryKw",
+                "tableKw",
+                "functionKw",
+                "ifNotExistsKw",
+                "name",
+            ]),
+            print("params"),
+            (0, exports.hasOnlyAsClause)(node)
+                ? [" ", (0, print_utils_1.group)(print("clauses"))]
+                : [
+                    print_utils_1.hardline,
+                    (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (cls) { return (0, print_utils_1.group)(cls); })),
+                ],
+        ]);
+    },
     function_signature: function (print) { return print(["name", "params"]); },
     function_param: function (print) {
         return print.spaced(["mode", "name", "dataType", "default"]);
@@ -59,6 +61,5 @@ exports.functionMap = {
         ]);
     },
 };
-var hasOnlyAsClause = function (node) {
-    return node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0]);
-};
+var hasOnlyAsClause = function (node) { return node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0]); };
+exports.hasOnlyAsClause = hasOnlyAsClause;

package/dist/syntax/index.js

@@ -71,13 +71,13 @@ exports.indexMap = {
         ]);
     },
     reindex_stmt: function (print) {
-        return print.spaced([
+        return (0, print_utils_1.group)(print.spaced([
             "reindexKw",
             "options",
             "targetKw",
             "concurrentlyKw",
             "name",
-        ]);
+        ]));
     },
     reindex_option_concurrently: function (print) {
         return print.spaced(["concurrentlyKw", "value"]);

package/dist/syntax/merge.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.mergeMap = {
-    merge_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.line, print("clauses")); },
+    merge_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))); },
     merge_clause: function (print) {
         return (0, print_utils_1.join)(print_utils_1.line, [
             print.spaced(["mergeKw", "intoKw", "target"]),

package/dist/syntax/parameter.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parameterMap = void 0;
 var expr_1 = require("./expr");
+var print_utils_1 = require("../print_utils");
 exports.parameterMap = {
     // SET
     set_parameter_stmt: function (print) {
-        return print.spaced(["setKw", "modifierKw", "name", "operator", "value"]);
+        return (0, print_utils_1.group)(print.spaced(["setKw", "modifierKw", "name", "operator", "value"]));
     },
     set_time_zone_parameter_stmt: function (print) {
-        return print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"]);
+        return (0, print_utils_1.group)(print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"]));
     },
     set_parameter_clause: function (print) {
         return print.spaced(["setKw", "name", "operator", "value"]);
@@ -18,11 +19,11 @@ exports.parameterMap = {
         return print.spaced(["setKw", "name", "fromCurrentKw"]);
     },
     // RESET
-    reset_parameter_stmt: function (print) { return print.spaced(["resetKw", "name"]); },
+    reset_parameter_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["resetKw", "name"])); },
     reset_parameter_clause: function (print) { return print.spaced(["resetKw", "name"]); },
     all_parameters: function (print) { return print("allKw"); },
     // SHOW
-    show_parameter_stmt: function (print) { return print.spaced(["showKw", "name"]); },
+    show_parameter_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["showKw", "name"])); },
     /** cst-ignore: value */
     boolean_on_off_literal: function (print, node, path, options) {
         return (0, expr_1.printLiteral)(node.valueKw, options);

package/dist/syntax/prepared_statements.js

@@ -23,12 +23,12 @@ exports.preparedStatementsMap = {
         }
     },
     execute_immediate_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
             (0, print_utils_1.group)([
                 print.spaced(["executeKw", "immediateKw"]),
                 (0, print_utils_1.indent)([print_utils_1.line, print("expr")]),
             ])
-        ], print(["into", "using"]).map(function (clause) { return (0, print_utils_1.group)(clause); }), true));
+        ], print(["into", "using"]).map(function (clause) { return (0, print_utils_1.group)(clause); }), true)));
     },
     execute_into_clause: function (print) { return print.spaced(["intoKw", "variables"]); },
     execute_using_clause: function (print) {
@@ -46,6 +46,6 @@ exports.preparedStatementsMap = {
         return (0, print_utils_1.group)([print("fromKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
     },
     // DEALLOCATE
-    deallocate_stmt: function (print) { return print.spaced(["deallocateKw", "name"]); },
+    deallocate_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["deallocateKw", "name"])); },
     deallocate_all: function (print) { return print("allKw"); },
 };

package/dist/syntax/procedural_language.js

@@ -13,31 +13,35 @@ exports.proceduralLanguageMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.proceduralLanguageMap = {
     // BEGIN .. END
-    block_stmt: function (print, node) { return [
-        print.spaced(["beginKw", "atomicKw"]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("program"))]),
-        node.exception ? [print_utils_1.hardline, print("exception")] : [],
-        print_utils_1.hardline,
-        print("endKw"),
-    ]; },
-    exception_clause: function (print) { return [
-        print.spaced(["exceptionKw", "whenKw", "condition", "thenKw"]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("program"))]),
-    ]; },
+    block_stmt: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced(["beginKw", "atomicKw"]),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("program"))]),
+            node.exception ? [print_utils_1.hardline, print("exception")] : [],
+            print_utils_1.hardline,
+            print("endKw"),
+        ]);
+    },
+    exception_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["exceptionKw", "whenKw", "condition", "thenKw"]),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("program"))]),
+        ]);
+    },
     error_category: function (print) { return print("errorKw"); },
     // DECLARE
     declare_stmt: function (print) {
-        return (0, print_utils_1.join)(" ", __spreadArray([
+        return (0, print_utils_1.group)((0, print_utils_1.join)(" ", __spreadArray([
             print("declareKw"),
             (0, print_utils_1.group)(print("names"))
-        ], print.spaced(["dataType", "default"]), true));
+        ], print.spaced(["dataType", "default"]), true)));
     },
     declare_default: function (print) { return print.spaced(["defaultKw", "expr"]); },
     // SET
-    set_stmt: function (print) { return print.spaced(["setKw", "assignments"]); },
+    set_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["setKw", "assignments"])); },
     // IF
     if_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray(__spreadArray([], print("clauses"), true), [print.spaced("endIfKw")], false));
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray(__spreadArray([], print("clauses"), true), [print.spaced("endIfKw")], false)));
     },
     if_clause: function (print) { return [
         (0, print_utils_1.group)([
@@ -62,55 +66,67 @@ exports.proceduralLanguageMap = {
         (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("consequent"))]),
     ]; },
     // CASE
-    case_stmt: function (print) { return [
-        print.spaced(["caseKw", "expr"]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))]),
-        print_utils_1.hardline,
-        print.spaced("endCaseKw"),
-    ]; },
+    case_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["caseKw", "expr"]),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))]),
+            print_utils_1.hardline,
+            print.spaced("endCaseKw"),
+        ]);
+    },
     // LOOP
-    loop_stmt: function (print) { return [
-        print("loopKw"),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
-        print_utils_1.hardline,
-        print.spaced("endLoopKw"),
-    ]; },
+    loop_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print("loopKw"),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
+            print_utils_1.hardline,
+            print.spaced("endLoopKw"),
+        ]);
+    },
     // REPEAT
-    repeat_stmt: function (print) { return [
-        print("repeatKw"),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
-        print_utils_1.hardline,
-        print.spaced(["untilKw", "condition", "endRepeatKw"]),
-    ]; },
+    repeat_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print("repeatKw"),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
+            print_utils_1.hardline,
+            print.spaced(["untilKw", "condition", "endRepeatKw"]),
+        ]);
+    },
     // WHILE
-    while_stmt: function (print) { return [
-        print.spaced(["whileKw", "condition", "doKw"]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
-        print_utils_1.hardline,
-        print.spaced("endWhileKw"),
-    ]; },
+    while_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["whileKw", "condition", "doKw"]),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
+            print_utils_1.hardline,
+            print.spaced("endWhileKw"),
+        ]);
+    },
     // FOR .. IN
-    for_stmt: function (print) { return [
-        print.spaced(["forKw", "left", "inKw", "right", "doKw"]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
-        print_utils_1.hardline,
-        print.spaced("endForKw"),
-    ]; },
+    for_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["forKw", "left", "inKw", "right", "doKw"]),
+            (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("body"))]),
+            print_utils_1.hardline,
+            print.spaced("endForKw"),
+        ]);
+    },
     // BREAK/CONTINUE
-    break_stmt: function (print) { return print.spaced(["breakKw", "label"]); },
-    continue_stmt: function (print) { return print.spaced(["continueKw", "label"]); },
-    labeled_stmt: function (print, node) { return [
-        print("beginLabel"),
-        ": ",
-        print("statement"),
-        node.endLabel ? [" ", print(["endLabel"])] : [],
-    ]; },
+    break_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["breakKw", "label"])); },
+    continue_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["continueKw", "label"])); },
+    labeled_stmt: function (print, node) {
+        return (0, print_utils_1.group)([
+            print("beginLabel"),
+            ": ",
+            print("statement"),
+            node.endLabel ? [" ", print(["endLabel"])] : [],
+        ]);
+    },
     // CALL
-    call_stmt: function (print) { return print.spaced(["callKw", "func"]); },
+    call_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["callKw", "func"])); },
     // RETURN
-    return_stmt: function (print) { return print.spaced(["returnKw", "expr"]); },
+    return_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["returnKw", "expr"])); },
     // RAISE
-    raise_stmt: function (print) { return print.spaced(["raiseKw", "message"]); },
+    raise_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["raiseKw", "message"])); },
     raise_message: function (print) { return [
         print.spaced("usingMessageKw"),
         " = ",

package/dist/syntax/procedure.js

@@ -2,19 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.procedureMap = void 0;
 var print_utils_1 = require("../print_utils");
+var function_1 = require("./function");
 exports.procedureMap = {
-    create_procedure_stmt: function (print, node) { return [
-        print.spaced([
-            "createKw",
-            "orReplaceKw",
-            "procedureKw",
-            "ifNotExistsKw",
-            "name",
-        ]),
-        print("params"),
-        print_utils_1.hardline,
-        (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (clause) { return (0, print_utils_1.group)(clause); })),
-    ]; },
+    create_procedure_stmt: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced([
+                "createKw",
+                "orReplaceKw",
+                "procedureKw",
+                "ifNotExistsKw",
+                "name",
+            ]),
+            print("params"),
+            (0, function_1.hasOnlyAsClause)(node)
+                ? [" ", (0, print_utils_1.group)(print("clauses"))]
+                : [
+                    print_utils_1.hardline,
+                    (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (clause) { return (0, print_utils_1.group)(clause); })),
+                ],
+        ]);
+    },
     drop_procedure_stmt: function (print) {
         return (0, print_utils_1.group)([
             print.spaced(["dropKw", "procedureKw", "ifExistsKw", "name"]),

package/dist/syntax/schema.js

@@ -26,7 +26,7 @@ exports.schemaMap = {
         return print.spaced(["authorizationKw", "role"]);
     },
     drop_schema_stmt: function (print) {
-        return print.spaced(["dropSchemaKw", "ifExistsKw", "schemas", "behaviorKw"]);
+        return (0, print_utils_1.group)(print.spaced(["dropSchemaKw", "ifExistsKw", "schemas", "behaviorKw"]));
     },
     alter_schema_stmt: function (print) {
         return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), __spreadArray([

package/dist/syntax/select.js

@@ -5,7 +5,7 @@ var utils_1 = require("../utils");
 var print_utils_1 = require("../print_utils");
 exports.selectMap = {
     compound_select_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [print("left"), print.spaced("operator"), print("right")]);
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [print("left"), print.spaced("operator"), print("right")]));
     },
     select_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     // WITH clause

package/dist/syntax/transaction.js

@@ -10,17 +10,17 @@ exports.transactionMap = {
         ]);
     },
     commit_transaction_stmt: function (print) {
-        return print.spaced(["commitKw", "transactionKw", "chain"]);
+        return (0, print_utils_1.group)(print.spaced(["commitKw", "transactionKw", "chain"]));
     },
     rollback_transaction_stmt: function (print) {
-        return print.spaced(["rollbackKw", "transactionKw", "savepoint", "chain"]);
+        return (0, print_utils_1.group)(print.spaced(["rollbackKw", "transactionKw", "savepoint", "chain"]));
     },
     rollback_to_savepoint: function (print) {
         return print.spaced(["toKw", "savepointKw", "savepoint"]);
     },
-    savepoint_stmt: function (print) { return print.spaced(["savepointKw", "savepoint"]); },
+    savepoint_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["savepointKw", "savepoint"])); },
     release_savepoint_stmt: function (print) {
-        return print.spaced(["releaseKw", "savepointKw", "savepoint"]);
+        return (0, print_utils_1.group)(print.spaced(["releaseKw", "savepointKw", "savepoint"]));
     },
     transaction_chain_clause: function (print) { return print.spaced("andChainKw"); },
     transaction_no_chain_clause: function (print) { return print.spaced("andNoChainKw"); },

package/dist/syntax/trigger.js

@@ -13,7 +13,7 @@ exports.triggerMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.triggerMap = {
     create_trigger_stmt: function (print, node) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray(__spreadArray([
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray(__spreadArray([
             print.spaced([
                 "createKw",
                 "orReplaceKw",
@@ -30,7 +30,7 @@ exports.triggerMap = {
             ])
         ], print("clauses"), true), [
             print("body"),
-        ], false));
+        ], false)));
     },
     trigger_event: function (print, node) {
         return (0, print_utils_1.group)([
@@ -65,12 +65,12 @@ exports.triggerMap = {
         ]));
     },
     drop_trigger_stmt: function (print) {
-        return print.spaced([
+        return (0, print_utils_1.group)(print.spaced([
             "dropTriggerKw",
             "ifExistsKw",
             "trigger",
             "target",
             "behaviorKw",
-        ]);
+        ]));
     },
 };

package/dist/syntax/unsupported_grammar.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unsupportedGrammarMap = void 0;
+var print_utils_1 = require("../print_utils");
 exports.unsupportedGrammarMap = {
-    unsupported_grammar_stmt: function (print) { return print("text"); },
+    unsupported_grammar_stmt: function (print) { return (0, print_utils_1.group)(print("text")); },
 };

package/dist/syntax/view.js

@@ -6,7 +6,7 @@ exports.viewMap = {
     create_view_stmt: function (print, node) {
         var hasOnlyAsClause = node.clauses.length === 1;
         var hasManyClauses = node.clauses.length > 1;
-        return [
+        return (0, print_utils_1.group)([
             print.spaced([
                 "createKw",
                 "orReplaceKw",
@@ -18,7 +18,7 @@ exports.viewMap = {
             ]),
             hasOnlyAsClause ? [" ", print("clauses")] : [],
             hasManyClauses ? [print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))] : [],
-        ];
+        ]);
     },
     with_check_option_clause: function (print) {
         return print.spaced(["withKw", "levelKw", "checkOptionKw"]);
@@ -34,18 +34,20 @@ exports.viewMap = {
             "behaviorKw",
         ]));
     },
-    alter_view_stmt: function (print) { return [
-        print.spaced([
-            "alterKw",
-            "kind",
-            "viewKw",
-            "ifExistsKw",
-            "name",
-            "columns",
-        ]),
-        print_utils_1.hardline,
-        print("actions"),
-    ]; },
+    alter_view_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced([
+                "alterKw",
+                "kind",
+                "viewKw",
+                "ifExistsKw",
+                "name",
+                "columns",
+            ]),
+            print_utils_1.hardline,
+            print("actions"),
+        ]);
+    },
     refresh_materialized_view_stmt: function (print, node) {
         return (0, print_utils_1.group)([
             print.spaced(["refreshMaterializedViewKw", "concurrentlyKw", "name"]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Prettier plugin for SQL",
   "contributors": [
     "Barna Magyarkuti <bmagyarkuti@gmail.com>",
@@ -37,7 +37,7 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.36.1"
+    "sql-parser-cst": "^0.37.0"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",