prettier-plugin-sql-cst 0.2.0 → 0.4.0

package/README.md

@@ -8,7 +8,7 @@ this plugin formats SQL expressions differently depending on their length.
 A short SQL query will be formatted on a single line:
 
 ```sql
-SELECT a, b, c FROM tbl WHERE x > 10
+SELECT a, b, c FROM tbl WHERE x > 10;
 ```
 
 A longer query, will get each clause printed on a separate line:
@@ -16,7 +16,7 @@ A longer query, will get each clause printed on a separate line:
 ```sql
 SELECT id, client.name, client.priority
 FROM client
-WHERE client.id IN (12, 18, 121)
+WHERE client.id IN (12, 18, 121);
 ```
 
 An even longer one gets the contents of each clause indented:
@@ -37,9 +37,22 @@ WHERE
   AND order.status IN ('active', 'pending', 'processing')
 GROUP BY client.id
 ORDER BY client.name
-LIMIT 100
+LIMIT 100;
 ```
 
+## Formatting philosophy
+
+- Adapt formatting based on expression length.
+- Stick to one style and avoid configuration options.
+- Format embedded languages (like JSON data and JavaScript programs).
+- When unsure, preserve existing syntax.
+
+Currently this plugin preserves most of the syntax elements
+and concentrates mainly on the layout of whitespace.
+For example it does not add/remove paratheses.
+
+See [STYLE_GUIDE][] for overview of the SQL formatting style used.
+
 ## Getting started
 
 Install it as any other Prettier plugin:
@@ -51,49 +64,58 @@ npm install --save-dev prettier prettier-plugin-sql-cst
 Then use it on SQL files though Prettier command line tool or Prettier extension
 for your editor of choice.
 
+## Choosing an SQL dialect
+
+By default the plugin will determine SQL dialect based on file extension:
+
+- `.sql` or `.sqlite` - SQLite
+- `.bigquery` - BigQuery
+
+You can override this behavior with a prettier configuration:
+
+```json
+{
+  "overrides": [
+    {
+      "files": ["*.sql"],
+      "options": { "parser": "bigquery" }
+    }
+  ]
+}
+```
+
+The plugin provides the following parsers:
+
+- `sqlite`
+- `bigquery`
+
 ## Configuration
 
 The standard Prettier options [printWidth][], [tabWidth][], [useTabs][] apply.
 There are also some SQL-specific options:
 
-| API Option       |  Default   | Description                                            |
-| ---------------- | :--------: | ------------------------------------------------------ |
-| `sqlKeywordCase` | `preserve` | Converts SQL keywords to `upper` or `lower` case.      |
-| `sqlAliasAs`     | `preserve` | Uses AS keyword in aliases either `always` or `never`. |
+| API Option       | Default | Description                                                               |
+| ---------------- | :-----: | ------------------------------------------------------------------------- |
+| `sqlKeywordCase` | `upper` | Converts SQL keywords to `upper` or `lower` case, or `preserve` existing. |
 
 ## Limitations and development status
 
-Currently this plugin supports most of **SQLite** syntax.
-(It also supports some **BigQuery**, but only the syntax that's subset of SQLite.)
+Currently this plugin supports the most common everyday **SQLite** and **BigQuery** syntax.
 Formatting of the following SQL statements is fully implemented:
 
 - SELECT
 - UPDATE
 - INSERT
 - DELETE
+- TRUNCATE
 - CREATE / DROP / ALTER TABLE
 - CREATE / DROP VIEW
 - CREATE / DROP INDEX
 
-Unlike Prettier for JavaScript, this plugin currently preserves all the syntax elements.
-For example it does not add/remove paratheses or modify the case of keywords (by default).
-It only manipulates whitespace.
-
-This will likely change in the future, with the goal of being more opinionated.
-Some possibilities:
-
-- capitalize all keywords
-- ensure all alias definitions use the `AS` keyword.
-- ensure consistent use of quotes (e.g. always quote keywords)
-- eliminate redundant parenthesis.
-
-The exact formatting style is also very much still in flux.
-The overall goal is to have no options to configure different styles,
-but rather to develop one opinionated style of formatting SQL.
-
 [prettier]: https://prettier.io/
 [printWidth]: https://prettier.io/docs/en/options.html#print-width
 [tabWidth]: https://prettier.io/docs/en/options.html#tab-width
 [useTabs]: https://prettier.io/docs/en/options.html#tabs
 [sql-parser-cst]: https://github.com/nene/sql-parser-cst
 [wadler-prettier]: http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
+[STYLE_GUIDE]: ./STYLE_GUIDE.md

package/dist/embedJson.js

@@ -0,0 +1,43 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embedJson = void 0;
+var node_utils_1 = require("./node_utils");
+var print_utils_1 = require("./print_utils");
+var embedJson = function (path, print, textToDoc, options) {
+    var node = path.getValue();
+    var parent = path.getParentNode();
+    if ((0, node_utils_1.isStringLiteral)(node) && (0, node_utils_1.isJsonLiteral)(parent)) {
+        if (containsTripleQuote(node.value) ||
+            containsBackslash(node.value) ||
+            isRawString(node)) {
+            // Give up for now. Don't format JSON inside the string.
+            // Tackle these corner-case in the future.
+            return null;
+        }
+        var json = textToDoc(node.value, __assign(__assign({}, options), { parser: "json" }));
+        var inlineQuote = containsSingleQuote(node.value) ? "'''" : "'";
+        return [
+            (0, print_utils_1.ifBreak)("'''", inlineQuote),
+            (0, print_utils_1.indent)([print_utils_1.softline, (0, print_utils_1.stripTrailingHardline)(json)]),
+            print_utils_1.softline,
+            (0, print_utils_1.ifBreak)("'''", inlineQuote),
+        ];
+    }
+    return null;
+};
+exports.embedJson = embedJson;
+var containsSingleQuote = function (json) { return /'/.test(json); };
+var containsTripleQuote = function (json) { return /'''/.test(json); };
+var containsBackslash = function (json) { return /\\/.test(json); };
+var isRawString = function (node) { return /^R/i.test(node.text); };

package/dist/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.printers = exports.parsers = exports.languages = exports.options = void 0;
 var sql_parser_cst_1 = require("sql-parser-cst");
 var printSql_1 = require("./printSql");
+var embedJson_1 = require("./embedJson");
 var utils_1 = require("./utils");
 var transformCst_1 = require("./transform/transformCst");
 var options_1 = require("./options");
@@ -11,12 +12,12 @@ exports.languages = [
     {
         extensions: [".sql", ".sqlite"],
         name: "SQLite SQL",
-        parsers: ["sql-parser-cst-sqlite"],
+        parsers: ["sqlite"],
     },
     {
         extensions: [".bigquery"],
         name: "BigQuery SQL",
-        parsers: ["sql-parser-cst-bigquery"],
+        parsers: ["bigquery"],
     },
 ];
 var createParser = function (dialect) { return ({
@@ -26,19 +27,20 @@ var createParser = function (dialect) { return ({
             includeRange: true,
             includeComments: true,
             filename: options.filepath,
-        }), options);
+        }), text);
     },
     astFormat: "sql-cst",
     locStart: function (node) { var _a; return (_a = node.range) === null || _a === void 0 ? void 0 : _a[0]; },
     locEnd: function (node) { var _a; return (_a = node.range) === null || _a === void 0 ? void 0 : _a[1]; },
 }); };
 exports.parsers = {
-    "sql-parser-cst-sqlite": createParser("sqlite"),
-    "sql-parser-cst-bigquery": createParser("bigquery"),
+    sqlite: createParser("sqlite"),
+    bigquery: createParser("bigquery"),
 };
 exports.printers = {
     "sql-cst": {
         print: printSql_1.printSql,
+        embed: embedJson_1.embedJson,
         printComment: function (path) {
             return path.getValue().text;
         },

package/dist/node_utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isKeyword = exports.isCreateTableStmt = exports.isFuncCall = exports.isValuesClause = void 0;
+exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncCall = exports.isValuesClause = void 0;
 var utils_1 = require("./utils");
 var is = function (type) {
     return function (node) {
@@ -11,3 +11,8 @@ exports.isValuesClause = is("values_clause");
 exports.isFuncCall = is("func_call");
 exports.isCreateTableStmt = is("create_table_stmt");
 exports.isKeyword = is("keyword");
+exports.isEmpty = is("empty");
+exports.isJsonLiteral = is("json_literal");
+exports.isStringLiteral = is("string_literal");
+exports.isArraySubscript = is("array_subscript");
+exports.isAsClause = is("as_clause");

package/dist/options.js

@@ -6,7 +6,7 @@ exports.options = {
         type: "choice",
         category: "SQL",
         since: "0.1.0",
-        default: "preserve",
+        default: "upper",
         description: "Enforces upper/lower case for SQL keywords",
         choices: [
             {
@@ -17,16 +17,4 @@ exports.options = {
             { value: "lower", description: "forces all keywords to lowercase" },
         ],
     },
-    sqlAliasAs: {
-        type: "choice",
-        category: "SQL",
-        since: "0.1.1",
-        default: "preserve",
-        description: "Enforce or forbid use of AS keyword in aliases",
-        choices: [
-            { value: "preserve", description: "keeps existing style" },
-            { value: "always", description: "always includes AS keyword" },
-            { value: "never", description: "never include AS keyword" },
-        ],
-    },
 };

package/dist/print_utils.js

@@ -1,11 +1,12 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.containsNewline = exports.join = exports.lineSuffix = exports.group = exports.indent = exports.softline = exports.hardline = exports.line = void 0;
+exports.containsNewline = exports.join = exports.stripTrailingHardline = exports.breakParent = exports.ifBreak = exports.lineSuffix = exports.group = exports.indent = exports.softline = exports.hardline = exports.line = void 0;
 var prettier_1 = require("prettier");
 var utils_1 = require("./utils");
-exports.line = (_a = prettier_1.doc.builders, _a.line), exports.hardline = _a.hardline, exports.softline = _a.softline, exports.indent = _a.indent, exports.group = _a.group, exports.lineSuffix = _a.lineSuffix;
+exports.line = (_a = prettier_1.doc.builders, _a.line), exports.hardline = _a.hardline, exports.softline = _a.softline, exports.indent = _a.indent, exports.group = _a.group, exports.lineSuffix = _a.lineSuffix, exports.ifBreak = _a.ifBreak, exports.breakParent = _a.breakParent;
 var origJoin = prettier_1.doc.builders.join;
+exports.stripTrailingHardline = prettier_1.doc.utils.stripTrailingHardline;
 /** Improved join() that also accepts a non-array docs parameter */
 var join = function (sep, docs) {
     return (0, utils_1.isArray)(docs) ? origJoin(sep, docs) : docs;

package/dist/syntax/alter_table.js

@@ -4,14 +4,33 @@ exports.alterTableMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.alterTableMap = {
     alter_table_stmt: function (print) { return [
-        print.spaced(["alterTableKw", "table"]),
+        print.spaced(["alterTableKw", "ifExistsKw", "table"]),
         print_utils_1.hardline,
         print("actions"),
     ]; },
     alter_action_rename_table: function (print) { return print.spaced(["renameKw", "newName"]); },
     alter_action_rename_column: function (print) {
-        return print.spaced(["renameKw", "oldName", "toKw", "newName"]);
+        return print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]);
+    },
+    alter_action_add_column: function (print) {
+        return print.spaced(["addKw", "ifNotExistsKw", "column"]);
+    },
+    alter_action_drop_column: function (print) {
+        return print.spaced(["dropKw", "ifExistsKw", "column"]);
+    },
+    alter_action_set_options: function (print) { return print.spaced(["setKw", "options"]); },
+    alter_action_set_default_collate: function (print) {
+        return print.spaced(["setDefaultCollateKw", "collation"]);
+    },
+    alter_action_alter_column: function (print) { return [
+        print.spaced(["alterKw", "ifExistsKw", "column"]),
+        print_utils_1.hardline,
+        print("action"),
+    ]; },
+    alter_action_set_default: function (print) { return print.spaced(["setDefaultKw", "expr"]); },
+    alter_action_drop_default: function (print) { return print.spaced("dropDefaultKw"); },
+    alter_action_drop_not_null: function (print) { return print.spaced("dropNotNullKw"); },
+    alter_action_set_data_type: function (print) {
+        return print.spaced(["setDataTypeKw", "dataType"]);
     },
-    alter_action_add_column: function (print) { return print.spaced(["addKw", "column"]); },
-    alter_action_drop_column: function (print) { return print.spaced(["dropKw", "column"]); },
 };

package/dist/syntax/bigquery.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigqueryMap = void 0;
+exports.bigqueryMap = {
+    bigquery_options: function (print) { return print(["optionsKw", "options"]); },
+    bigquery_option_default_collate: function (print) {
+        return print.spaced(["defaultCollateKw", "collation"]);
+    },
+};

package/dist/syntax/create_table.js

@@ -1,22 +1,58 @@
 "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.createTableMap = void 0;
+var node_utils_1 = require("../node_utils");
 var print_utils_1 = require("../print_utils");
 exports.createTableMap = {
-    create_table_stmt: function (print, node) { return [
-        print.spaced([
-            "createKw",
-            "temporaryKw",
-            "tableKw",
-            "ifNotExistsKw",
-            "name",
-            "columns",
-            "clauses",
-        ]),
-        node.options ? [" ", (0, print_utils_1.group)(print("options"))] : [],
-    ]; },
+    create_table_stmt: function (print, node) {
+        var rest = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            rest[_i - 2] = arguments[_i];
+        }
+        return [
+            print.spaced([
+                "createKw",
+                "orReplaceKw",
+                "temporaryKw",
+                "externalKw",
+                "snapshotKw",
+                "tableKw",
+                "ifNotExistsKw",
+                "name",
+                "columns",
+            ]),
+            printClauses.apply(void 0, __spreadArray([print, node], rest, false)),
+            node.options ? [print_utils_1.line, (0, print_utils_1.group)(print("options"))] : [],
+        ];
+    },
     column_definition: function (print) {
         return print.spaced(["name", "dataType", "constraints"]);
     },
     table_option: function (print) { return print.spaced(["name"]); },
+    create_table_like_clause: function (print) { return print.spaced(["likeKw", "name"]); },
+    create_table_copy_clause: function (print) { return print.spaced(["copyKw", "name"]); },
+    create_table_clone_clause: function (print) { return print.spaced(["cloneKw", "table"]); },
+    with_partition_columns_clause: function (print) {
+        return print.spaced(["withPartitionColumnsKw", "columns"]);
+    },
+};
+var printClauses = function (print, node) {
+    if (node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0])) {
+        return [" ", print("clauses")];
+    }
+    else if (node.clauses.length > 0) {
+        return [print_utils_1.line, (0, print_utils_1.join)(print_utils_1.line, print("clauses"))];
+    }
+    else {
+        return [];
+    }
 };

package/dist/syntax/data_type.js

@@ -1,15 +1,15 @@
 "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");
 exports.dataTypeMap = {
-    data_type: function (print) { return __spreadArray([print.spaced("nameKw")], print(["params"]), true); },
+    // print single-word types as `TYPE(10)` and multi-word types as `MY TYPE (10)`
+    data_type: function (print, node) {
+        return ((0, utils_1.isArray)(node.nameKw) ? print.spaced : print)(["nameKw", "params"]);
+    },
+    generic_type_params: function (print) { return ["<", print("params"), ">"]; },
+    array_type_param: function (print) { return print.spaced(["dataType", "constraints"]); },
+    struct_type_param: function (print) {
+        return print.spaced(["name", "dataType", "constraints"]);
+    },
 };

package/dist/syntax/drop_table.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropTableMap = void 0;
 exports.dropTableMap = {
     drop_table_stmt: function (print) {
-        return print.spaced(["dropKw", "tableKw", "ifExistsKw", "tables"]);
+        return print.spaced([
+            "dropKw",
+            "externalKw",
+            "snapshotKw",
+            "tableKw",
+            "ifExistsKw",
+            "tables",
+        ]);
     },
 };

package/dist/syntax/expr.js

@@ -12,10 +12,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.exprMap = void 0;
 var print_utils_1 = require("../print_utils");
 var node_utils_1 = require("../node_utils");
+var utils_1 = require("../utils");
 exports.exprMap = {
     list_expr: function (print, node, path) {
         var parent = path.getParentNode();
-        return (0, print_utils_1.join)([",", (0, node_utils_1.isValuesClause)(parent) ? print_utils_1.hardline : print_utils_1.line], print("items").map(function (it) { return (0, print_utils_1.group)(it); }));
+        var children = print("items").map(function (it) { return (0, print_utils_1.group)(it); });
+        var lineType = (0, node_utils_1.isValuesClause)(parent) ? print_utils_1.hardline : print_utils_1.line;
+        // When last item is type:empty, we're dealing with a trailing comma.
+        // Don't add a space (or newline) after it.
+        // We still want to print it though, as it might have comments attached.
+        if ((0, node_utils_1.isEmpty)((0, utils_1.last)(node.items))) {
+            return [
+                (0, print_utils_1.join)([",", lineType], children.slice(0, -1)),
+                ",",
+                (0, utils_1.last)(children),
+            ];
+        }
+        else {
+            return (0, print_utils_1.join)([",", lineType], children);
+        }
     },
     paren_expr: function (print, node, path) {
         var parent = path.getParentNode();
@@ -28,7 +43,9 @@ exports.exprMap = {
         }
         return print.spaced(["left", "operator", "right"]);
     },
-    prefix_op_expr: function (print) { return print.spaced(["operator", "expr"]); },
+    prefix_op_expr: function (print, node) {
+        return ((0, utils_1.isString)(node.operator) ? print : print.spaced)(["operator", "expr"]);
+    },
     postfix_op_expr: function (print) { return print.spaced(["expr", "operator"]); },
     between_expr: function (print) {
         return print.spaced(["left", "betweenKw", "begin", "andKw", "end"]);
@@ -43,8 +60,16 @@ exports.exprMap = {
         return print.spaced(["whenKw", "condition", "thenKw", "result"]);
     },
     case_else: function (print) { return print.spaced(["elseKw", "result"]); },
-    member_expr: function (print) { return [print("object"), ".", print("property")]; },
+    member_expr: function (print, node) {
+        return (0, node_utils_1.isArraySubscript)(node.property)
+            ? print(["object", "property"])
+            : [print("object"), ".", print("property")];
+    },
     bigquery_quoted_member_expr: function (print) { return ["`", print("expr"), "`"]; },
+    array_subscript: function (print) {
+        return (0, print_utils_1.group)(["[", (0, print_utils_1.indent)([print_utils_1.softline, print("expr")]), print_utils_1.softline, "]"]);
+    },
+    array_subscript_specifier: function (print) { return print(["specifierKw", "args"]); },
     func_call: function (print) {
         var fnCall = print(["name", "args"]);
         var extras = print(["filter", "over"]);
@@ -61,10 +86,28 @@ exports.exprMap = {
     cast_expr: function (print) { return print(["castKw", "args"]); },
     cast_arg: function (print) { return print.spaced(["expr", "asKw", "dataType"]); },
     raise_expr: function (print) { return print(["raiseKw", "args"]); },
+    interval_expr: function (print) { return print.spaced(["intervalKw", "expr", "unit"]); },
+    interval_unit_range: function (print) {
+        return print.spaced(["fromUnitKw", "toKw", "toUnitKw"]);
+    },
+    array_expr: function (print) {
+        return (0, print_utils_1.group)(["[", (0, print_utils_1.indent)([print_utils_1.softline, print("expr")]), print_utils_1.softline, "]"]);
+    },
+    struct_expr: function (print) {
+        return (0, print_utils_1.group)(["(", (0, print_utils_1.indent)([print_utils_1.softline, print("expr")]), print_utils_1.softline, ")"]);
+    },
+    typed_expr: function (print) { return print(["dataType", "expr"]); },
     number_literal: function (print) { return print("text"); },
     boolean_literal: function (print) { return print("valueKw"); },
     string_literal: function (print) { return print("text"); },
     null_literal: function (print) { return print("nullKw"); },
+    numeric_literal: function (print) { return print.spaced(["numericKw", "string"]); },
+    bignumeric_literal: function (print) { return print.spaced(["bignumericKw", "string"]); },
+    date_literal: function (print) { return print.spaced(["dateKw", "string"]); },
+    time_literal: function (print) { return print.spaced(["timeKw", "string"]); },
+    datetime_literal: function (print) { return print.spaced(["datetimeKw", "string"]); },
+    timestamp_literal: function (print) { return print.spaced(["timestampKw", "string"]); },
+    json_literal: function (print) { return print.spaced(["jsonKw", "string"]); },
     identifier: function (print) { return print("text"); },
 };
 var isBooleanOp = function (_a) {

package/dist/syntax/insert.js

@@ -14,6 +14,7 @@ exports.insertMap = {
         return (0, print_utils_1.group)([print("valuesKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("values")])]);
     },
     or_alternate_action: function (print) { return print.spaced(["orKw", "actionKw"]); },
+    default: function (print) { return print("defaultKw"); },
     default_values: function (print) { return print.spaced("defaultValuesKw"); },
     upsert_clause: function (print) {
         return print.spaced(["onConflictKw", "columns", "where", "doKw", "action"]);

package/dist/syntax/proc_clause.js

@@ -4,4 +4,7 @@ exports.procClauseMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.procClauseMap = {
     as_clause: function (print) { return [print("asKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("expr")])]; },
+    with_connection_clause: function (print) {
+        return print.spaced(["withConnectionKw", "connection"]);
+    },
 };

package/dist/syntax/program.js

@@ -3,19 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.programMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.programMap = {
-    program: function (print, node, path) { return path.map(printLineWith(print), "statements"); },
+    program: function (print, node) {
+        return print("statements").map(function (doc, i) {
+            return printStatement(doc, i, node.statements);
+        });
+    },
 };
-var printLineWith = function (print) {
-    return function (childPath, i, all) {
-        var node = childPath.getValue();
-        if (i === 0) {
-            return print(childPath);
-        }
-        else if (i < all.length - 1 || node.type !== "empty") {
-            return [";", print_utils_1.hardline, print_utils_1.hardline, print(childPath)];
-        }
-        else {
-            return [";", print(childPath)];
-        }
-    };
+var printStatement = function (doc, i, statements) {
+    var node = statements[i];
+    if (i === 0) {
+        return doc;
+    }
+    else if (node.type !== "empty") {
+        return [";", print_utils_1.hardline, print_utils_1.hardline, doc];
+    }
+    else {
+        return [";", print_utils_1.hardline, doc];
+    }
 };

package/dist/syntax/select.js

@@ -22,10 +22,11 @@ exports.selectMap = {
         " ",
         print.spaced(["asKw", "materializedKw", "expr"]),
     ]; },
-    select_clause: function (print) {
+    select_clause: function (print, node, path, opts) {
         return (0, print_utils_1.group)([
-            print.spaced(["selectKw", "distinctKw"]),
+            print.spaced(["selectKw", "distinctKw", "asStructOrValueKw"]),
             (0, print_utils_1.indent)([print_utils_1.line, print("columns")]),
+            (0, print_utils_1.containsNewline)(node, opts) ? print_utils_1.breakParent : [],
         ]);
     },
     except_columns: function (print) { return print.spaced(["expr", "exceptKw", "columns"]); },
@@ -57,6 +58,39 @@ exports.selectMap = {
     join_using_specification: function (print) { return (0, print_utils_1.group)(print.spaced(["usingKw", "expr"])); },
     indexed_table: function (print) { return print.spaced(["table", "indexedByKw", "index"]); },
     not_indexed_table: function (print) { return print.spaced(["table", "notIndexedKw"]); },
+    unnest_expr: function (print) { return print(["unnestKw", "expr"]); },
+    unnest_with_offset_expr: function (print) { return print.spaced(["unnest", "withOffsetKw"]); },
+    pivot_expr: function (print) { return [print("left"), print_utils_1.hardline, print(["pivotKw", "args"])]; },
+    pivot_for_in: function (print) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, [
+            (0, print_utils_1.group)(print("aggregations")),
+            print.spaced(["forKw", "inputColumn"]),
+            print.spaced(["inKw", "pivotColumns"]),
+        ]));
+    },
+    unpivot_expr: function (print, node) { return [
+        print("left"),
+        print_utils_1.hardline,
+        (node.nullHandlingKw ? print.spaced : print)([
+            "unpivotKw",
+            "nullHandlingKw",
+            "args",
+        ]),
+    ]; },
+    unpivot_for_in: function (print) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, [
+            print("valuesColumn"),
+            print.spaced(["forKw", "nameColumn"]),
+            print.spaced(["inKw", "unpivotColumns"]),
+        ]));
+    },
+    tablesample_expr: function (print) {
+        return (0, print_utils_1.group)([print("left"), print_utils_1.line, print.spaced(["tablesampleKw", "args"])]);
+    },
+    tablesample_percent: function (print) { return print.spaced(["percent", "percentKw"]); },
+    for_system_time_as_of_expr: function (print) {
+        return (0, print_utils_1.group)([print("left"), print_utils_1.line, print.spaced(["forSystemTimeAsOfKw", "expr"])]);
+    },
     where_clause: function (print) {
         return (0, print_utils_1.group)([print("whereKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
     },
@@ -66,15 +100,22 @@ exports.selectMap = {
     group_by_clause: function (print) {
         return (0, print_utils_1.group)([print.spaced("groupByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
     },
+    group_by_rollup: function (print) { return print(["rollupKw", "columns"]); },
     partition_by_clause: function (print) {
         return (0, print_utils_1.group)([
             print.spaced("partitionByKw"),
             (0, print_utils_1.indent)([print_utils_1.line, print("specifications")]),
         ]);
     },
+    cluster_by_clause: function (print) {
+        return (0, print_utils_1.group)([print.spaced("clusterByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
+    },
     having_clause: function (print) {
         return (0, print_utils_1.group)([print("havingKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
     },
+    qualify_clause: function (print) {
+        return (0, print_utils_1.group)([print("qualifyKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
+    },
     returning_clause: function (print) {
         return (0, print_utils_1.group)([print("returningKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
     },

package/dist/syntax/transformMap.js

@@ -15,6 +15,7 @@ exports.transformMap = void 0;
 var alias_1 = require("./alias");
 var alter_table_1 = require("./alter_table");
 var base_1 = require("./base");
+var bigquery_1 = require("./bigquery");
 var constraint_1 = require("./constraint");
 var create_table_1 = require("./create_table");
 var data_type_1 = require("./data_type");
@@ -27,6 +28,7 @@ var insert_1 = require("./insert");
 var proc_clause_1 = require("./proc_clause");
 var program_1 = require("./program");
 var select_1 = require("./select");
+var truncate_1 = require("./truncate");
 var update_1 = require("./update");
 var view_1 = require("./view");
-exports.transformMap = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, alias_1.aliasMap), alter_table_1.alterTableMap), base_1.baseMap), constraint_1.constraintMap), create_table_1.createTableMap), data_type_1.dataTypeMap), delete_1.deleteMap), drop_table_1.dropTableMap), expr_1.exprMap), frame_1.frameMap), index_1.indexMap), insert_1.insertMap), proc_clause_1.procClauseMap), program_1.programMap), select_1.selectMap), update_1.updateMap), view_1.viewMap);
+exports.transformMap = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, alias_1.aliasMap), alter_table_1.alterTableMap), base_1.baseMap), bigquery_1.bigqueryMap), constraint_1.constraintMap), create_table_1.createTableMap), data_type_1.dataTypeMap), delete_1.deleteMap), drop_table_1.dropTableMap), expr_1.exprMap), frame_1.frameMap), index_1.indexMap), insert_1.insertMap), proc_clause_1.procClauseMap), program_1.programMap), select_1.selectMap), truncate_1.truncateMap), update_1.updateMap), view_1.viewMap);

package/dist/syntax/truncate.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateMap = void 0;
+exports.truncateMap = {
+    truncate_stmt: function (print) { return print.spaced(["truncateTableKw", "table"]); },
+};

package/dist/syntax/view.js

@@ -3,19 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.viewMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.viewMap = {
-    create_view_stmt: function (print) { return [
-        print.spaced([
-            "createKw",
-            "temporaryKw",
-            "viewKw",
-            "ifNotExistsKw",
-            "name",
-            "columns",
-            "asKw",
-        ]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.group)(print("expr"))]),
-    ]; },
+    create_view_stmt: function (print, node) {
+        var hasOnlyAsClause = node.clauses.length === 1;
+        var hasManyClauses = node.clauses.length > 1;
+        return [
+            print.spaced([
+                "createKw",
+                "orReplaceKw",
+                "temporaryKw",
+                "materializedKw",
+                "viewKw",
+                "ifNotExistsKw",
+                "name",
+                "columns",
+            ]),
+            hasOnlyAsClause ? [" ", print("clauses")] : [],
+            hasManyClauses ? [print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))] : [],
+        ];
+    },
     drop_view_stmt: function (print) {
-        return print.spaced(["dropKw", "viewKw", "ifExistsKw", "views"]);
+        return print.spaced(["dropKw", "materializedKw", "viewKw", "ifExistsKw", "views"]);
     },
 };

package/dist/transform/addFinalSemicolon.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFinalSemicolon = void 0;
+var node_utils_1 = require("../node_utils");
+var utils_1 = require("../utils");
+var addFinalSemicolon = function (program, originalText) {
+    if (!(0, node_utils_1.isEmpty)((0, utils_1.last)(program.statements))) {
+        var end = originalText.length;
+        program.statements.push({ type: "empty", range: [end, end] });
+    }
+    return program;
+};
+exports.addFinalSemicolon = addFinalSemicolon;

package/dist/transform/aliasAs.js

@@ -1,36 +1,12 @@
 "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.processAliasAs = void 0;
 var sql_parser_cst_1 = require("sql-parser-cst");
-var processAliasAs = function (cst, options) {
+// Adds AS keyword to aliases if none exists
+var processAliasAs = function (cst) {
     var mutateAliases = (0, sql_parser_cst_1.cstVisitor)({
         alias: function (node) {
-            var _a, _b;
-            switch (options.sqlAliasAs) {
-                case "preserve":
-                    // do nothing
-                    break;
-                case "always":
-                    // Add AS keyword if none exists
-                    node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
-                    break;
-                case "never":
-                    // Remove AS keyword and ensure comments attached to it don't get lost
-                    if (node.asKw && (((_a = node.leading) === null || _a === void 0 ? void 0 : _a.length) || ((_b = node.trailing) === null || _b === void 0 ? void 0 : _b.length))) {
-                        var comments = __spreadArray(__spreadArray([], (node.leading || []), true), (node.trailing || []), true);
-                        node.alias.leading = __spreadArray(__spreadArray([], comments, true), (node.alias.leading || []), true);
-                    }
-                    node.asKw = undefined;
-            }
+            node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
         },
     });
     mutateAliases(cst);

package/dist/transform/stripTrailingCommas.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripTrailingCommas = void 0;
+var sql_parser_cst_1 = require("sql-parser-cst");
+var node_utils_1 = require("../node_utils");
+var utils_1 = require("../utils");
+// Removes trailing comma from SELECT clauses
+var stripTrailingCommas = function (cst) {
+    // Trailing comma is represented as an empty element at the end of column list
+    var removeLastEmptyColumn = (0, sql_parser_cst_1.cstVisitor)({
+        select_clause: function (node) {
+            if ((0, node_utils_1.isEmpty)((0, utils_1.last)(node.columns.items))) {
+                node.columns.items = node.columns.items.slice(0, -1);
+            }
+        },
+    });
+    removeLastEmptyColumn(cst);
+    return cst;
+};
+exports.stripTrailingCommas = stripTrailingCommas;

package/dist/transform/transformCst.js

@@ -3,5 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformCst = void 0;
 var comments_1 = require("./comments");
 var aliasAs_1 = require("./aliasAs");
-var transformCst = function (cst, options) { return (0, comments_1.moveCommentsToRoot)((0, aliasAs_1.processAliasAs)(cst, options)); };
+var stripTrailingCommas_1 = require("./stripTrailingCommas");
+var addFinalSemicolon_1 = require("./addFinalSemicolon");
+// Note that we first perform moveCommentsToRoot transform,
+// so we don't need to worry about comments interfering with other transforms
+var transformCst = function (cst, originalText) {
+    return (0, addFinalSemicolon_1.addFinalSemicolon)((0, stripTrailingCommas_1.stripTrailingCommas)((0, aliasAs_1.processAliasAs)((0, comments_1.moveCommentsToRoot)(cst))), originalText);
+};
 exports.transformCst = transformCst;

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayWrap = exports.isNode = exports.isEmptyArray = exports.isArray = exports.isObject = exports.isString = exports.isDefined = void 0;
+exports.last = exports.arrayWrap = exports.isNode = exports.isEmptyArray = exports.isArray = exports.isObject = exports.isString = exports.isDefined = void 0;
 var isDefined = function (value) {
     return value !== undefined;
 };
@@ -26,3 +26,5 @@ var isCommentType = function (type) {
 };
 var arrayWrap = function (x) { return ((0, exports.isArray)(x) ? x : [x]); };
 exports.arrayWrap = arrayWrap;
+var last = function (arr) { return arr[arr.length - 1]; };
+exports.last = last;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Prettier plugin for SQL",
   "author": "Rene Saarsoo <nene@triin.net>",
   "license": "GPL-3.0-or-later",
@@ -29,7 +29,7 @@
   ],
   "dependencies": {
     "prettier": "^2.8.2",
-    "sql-parser-cst": "^0.11.0"
+    "sql-parser-cst": "^0.12.0"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",