prettier-plugin-sql-cst 0.10.1 → 0.11.0

package/README.md

@@ -98,10 +98,25 @@ The plugin provides the following parsers:
 The standard Prettier options [printWidth][], [tabWidth][], [useTabs][] apply.
 There are also some SQL-specific options:
 
-| API Option       | Default | Description                                                               |
-| ---------------- | :-----: | ------------------------------------------------------------------------- |
-| `sqlKeywordCase` | `upper` | Converts SQL keywords to `upper` or `lower` case, or `preserve` existing. |
-| `sqlParamTypes`  |  `[]`   | Array of bound parameter types: `?`, `?nr`, `:name`, `@name`, `$name`.    |
+| API Option           | Default | Description                                                                                                                                                                                                                 |
+| -------------------- | :-----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `sqlKeywordCase`     | `upper` | Converts 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). |
+| `sqlParamTypes`      |  `[]`   | Array of bound parameter types: `?`, `?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)         |
+
+## FAQ
+
+### The SQL dialect I'm using is not supported. Can you add support for it?
+
+Support for new SQL dialects depends on these dialects being supported by [sql-parser-cst][].
+If you really want to, you can open a new issue for that in the parser repo.
+But be aware that implementing parser support for new dialects takes a lot of work.
+As long as the ongoing implementation of PostgreSQL, MySQL and MariaDB is not finished,
+it's unlikely that work on any other dialect will start.
+
+### How can I format SQL strings inside JavaScript files?
+
+Use [prettier-plugin-embed][] together with `prettier-plugin-sql-cst`.
 
 ## Limitations and development status
 
@@ -119,8 +134,8 @@ It also has experimental support for the following dialects:
 The main limitation is that [the parser][sql-parser-cst] does not support full syntax of
 these dialects. One should expect the parser to crash for syntax that's more specific to
 these dialects. But as long as the parsing succeeds, the formatting should also succeed.
-Mainly one can expect the formatting of SELECT statements to work. But beyond that you should
-keep your expectations low. You have been warned.
+Mainly one can expect the formatting of SELECT, INSERT, UPDATE, DELETE statements to work.
+But beyond that you should keep your expectations low. You have been warned.
 
 The specifics of the [SQL formatting style][STYLE_GUIDE] are still very much subject to change.
 Though the general principles should be mostly in place by now.
@@ -132,4 +147,5 @@ Though the general principles should be mostly in place by now.
 [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
+[prettier-plugin-embed]: https://github.com/Sec-ant/prettier-plugin-embed
 [STYLE_GUIDE]: ./STYLE_GUIDE.md

package/dist/PrintFn.d.ts

@@ -8,6 +8,9 @@ export type PrintFn<T, K = PrintableKey<T>> = {
     (path: K[]): Doc[];
     spaced(path: K): Doc[];
     spaced(path: K[]): Doc[];
+    separated(separator: Doc, path: K): Doc[];
+    separated(separator: Doc, path: K[]): Doc[];
+    dynamicLine(): Doc;
 };
 export type PrintableKey<T> = Exclude<keyof T, ReservedKey>;
 type ReservedKey = "type" | "range" | "leading" | "trailing";

package/dist/embedJs.js

@@ -51,7 +51,7 @@ exports.embedJs = void 0;
 var node_utils_1 = require("./node_utils");
 var print_utils_1 = require("./print_utils");
 var embedJs = function (path, options) {
-    var node = path.getValue(); // TODO: Don't use deprecated method
+    var node = path.node;
     var parent = path.getParentNode(0);
     var grandParent = path.getParentNode(1);
     if ((0, node_utils_1.isStringLiteral)(node) &&

package/dist/embedJson.js

@@ -51,7 +51,7 @@ exports.embedJson = void 0;
 var node_utils_1 = require("./node_utils");
 var print_utils_1 = require("./print_utils");
 var embedJson = function (path, options) {
-    var node = path.getValue(); // TODO: Don't use deprecated method
+    var node = path.node;
     var parent = path.getParentNode();
     if ((0, node_utils_1.isStringLiteral)(node) &&
         ((0, node_utils_1.isJsonLiteral)(parent) || (0, node_utils_1.isJsonbLiteral)(parent))) {

package/dist/index.js

@@ -44,7 +44,7 @@ var createParser = function (dialect) { return ({
             includeComments: true,
             filename: options.filepath,
             paramTypes: options.sqlParamTypes,
-        }), text);
+        }), text, options);
     },
     astFormat: "sql-cst",
     locStart: function (node) { var _a; return (_a = node.range) === null || _a === void 0 ? void 0 : _a[0]; },

package/dist/options.d.ts

@@ -3,6 +3,7 @@ import { Node, ParserOptions as CstParserOptions } from "sql-parser-cst";
 export interface SqlPluginOptions {
     sqlKeywordCase: "preserve" | "upper" | "lower";
     sqlParamTypes: NonNullable<CstParserOptions["paramTypes"]>;
+    sqlCanonicalSyntax: boolean;
 }
 export type AllPrettierOptions<T = Node> = ParserOptions<T> & SqlPluginOptions;
 export declare const options: SupportOptions;

package/dist/options.js

@@ -34,4 +34,11 @@ exports.options = {
         // Since 0.7.0
         // Possible values in array: "?" | "?nr" | ":name" | "$name" | "@name"
     },
+    sqlCanonicalSyntax: {
+        type: "boolean",
+        category: "SQL",
+        default: true,
+        description: "Enforces one true style of SQL syntax (adds and removes keywords)",
+        // Since 0.11.0
+    },
 };

package/dist/printComment.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printComment = void 0;
 var printComment = function (path) {
-    var node = path.getValue();
+    var node = path.node;
     if (node.type === "line_comment") {
         if (/^--[^ \t]/.test(node.text)) {
             return node.text.replace(/^--/, "-- ");

package/dist/printSql.js

@@ -5,12 +5,12 @@ var utils_1 = require("./utils");
 var transformMap_1 = require("./syntax/transformMap");
 var print_utils_1 = require("./print_utils");
 function printSql(path, options, oldPrint) {
-    return printNode(path, options, createPrintFn(path, oldPrint));
+    return printNode(path, options, createPrintFn(path, oldPrint, options));
 }
 exports.printSql = printSql;
 var cachedPrintFn;
 var cachedPath;
-function createPrintFn(path, oldPrint) {
+function createPrintFn(path, oldPrint, opts) {
     // The path parameter will reference the same AstPath instance
     // during the whole printing cycle.
     // So we can keep using the same print function as long as
@@ -21,15 +21,15 @@ function createPrintFn(path, oldPrint) {
     cachedPath = path;
     cachedPrintFn = (function (selector) {
         if ((0, utils_1.isArray)(selector)) {
-            var node_1 = path.getValue();
+            var node_1 = path.node;
             return selector.filter(function (sel) { return (0, utils_1.isDefined)(node_1[sel]); }).map(oldPrint);
         }
         else {
             return oldPrint(selector);
         }
     });
-    cachedPrintFn.spaced = function (selector) {
-        var node = path.getValue();
+    cachedPrintFn.separated = function (separator, selector) {
+        var node = path.node;
         var docs = (0, utils_1.arrayWrap)(selector)
             .filter(function (sel) { return (0, utils_1.isDefined)(node[sel]); })
             .map(function (sel) { return [sel, oldPrint(sel)]; })
@@ -43,12 +43,17 @@ function createPrintFn(path, oldPrint) {
             var sel = _a[0], doc = _a[1];
             return ((0, utils_1.isArray)(node[sel]) ? (0, print_utils_1.join)(" ", doc) : doc);
         });
-        return docs.length > 0 ? [(0, print_utils_1.join)(" ", docs)] : [];
+        return docs.length > 0 ? [(0, print_utils_1.join)(separator, docs)] : [];
+    };
+    cachedPrintFn.spaced = function (selector) { return cachedPrintFn.separated(" ", selector); };
+    cachedPrintFn.dynamicLine = function () {
+        var node = path.node;
+        return (0, print_utils_1.containsNewline)(node, opts) ? print_utils_1.hardline : print_utils_1.line;
     };
     return cachedPrintFn;
 }
 function printNode(path, options, print) {
-    var node = path.getValue();
+    var node = path.node;
     if ((0, utils_1.isArray)(node)) {
         return path.map(print);
     }

package/dist/syntax/alter_table.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.alterTableMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.alterTableMap = {
-    alter_table_stmt: function (print) { return [
-        print.spaced(["alterTableKw", "ifExistsKw", "table"]),
-        print_utils_1.hardline,
-        print("actions"),
-    ]; },
+    alter_table_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["alterTableKw", "ifExistsKw", "table"]),
+            print.dynamicLine(),
+            print("actions"),
+        ]);
+    },
     alter_action_rename_table: function (print) { return print.spaced(["renameKw", "newName"]); },
     alter_action_rename_column: function (print) {
         return print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]);
@@ -16,19 +18,45 @@ exports.alterTableMap = {
         return print.spaced(["addKw", "ifNotExistsKw", "column"]);
     },
     alter_action_drop_column: function (print) {
-        return print.spaced(["dropKw", "ifExistsKw", "column"]);
+        return print.spaced(["dropKw", "ifExistsKw", "column", "behaviorKw"]);
     },
     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_add_constraint: function (print) {
+        return print.spaced(["addKw", "constraint"]);
+    },
+    alter_action_drop_constraint: function (print) {
+        return print.spaced([
+            "dropConstraintKw",
+            "ifExistsKw",
+            "constraint",
+            "behaviorKw",
+        ]);
+    },
+    alter_action_alter_constraint: function (print) {
+        return print.spaced(["alterConstraintKw", "constraint", "modifiers"]);
+    },
+    alter_action_rename_constraint: function (print) {
+        return print.spaced(["renameConstraintKw", "oldName", "toKw", "newName"]);
+    },
+    alter_action_validate_constraint: function (print) {
+        return print.spaced(["validateConstraintKw", "constraint"]);
+    },
+    alter_action_set_visible: function (print) { return print.spaced("setVisibleKw"); },
+    alter_action_set_invisible: function (print) { return print.spaced("setInvisibleKw"); },
+    // ALTER COLUMN
+    alter_action_alter_column: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["alterKw", "ifExistsKw", "column"]),
+            print.dynamicLine(),
+            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_set_not_null: function (print) { return print.spaced("setNotNullKw"); },
     alter_action_drop_not_null: function (print) { return print.spaced("dropNotNullKw"); },
     alter_action_set_data_type: function (print) {
         return print.spaced(["setDataTypeKw", "dataType"]);

package/dist/syntax/base.js

@@ -2,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.baseMap = void 0;
 exports.baseMap = {
+    /** cst-ignore: name */
     keyword: function (print, node, path, options) {
         switch (options.sqlKeywordCase) {
             case "preserve":
-                return path.getValue().text;
+                return path.node.text;
             case "upper":
-                return path.getValue().text.toUpperCase();
+                return path.node.text.toUpperCase();
             case "lower":
-                return path.getValue().text.toLowerCase();
+                return path.node.text.toLowerCase();
         }
     },
     all_columns: function () { return "*"; },

package/dist/syntax/constraint.js

@@ -1,8 +1,18 @@
 "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.constraintMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.constraintMap = {
+    /** cst-ignore: constraint, modifiers */
     constraint: function (print, node) {
         if (node.name) {
             return (0, print_utils_1.group)([
@@ -15,26 +25,24 @@ exports.constraintMap = {
         }
     },
     constraint_name: function (print) { return print.spaced(["constraintKw", "name"]); },
-    constraint_deferrable: function (print) {
-        return print.spaced(["deferrableKw", "initiallyKw"]);
-    },
+    constraint_modifier: function (print) { return print.spaced("kw"); },
     constraint_null: function (print) { return print("nullKw"); },
-    constraint_not_null: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["notNullKw", "onConflict"]));
-    },
+    constraint_not_null: function (print) { return (0, print_utils_1.group)(print.spaced(["notNullKw", "clauses"])); },
     constraint_default: function (print) { return (0, print_utils_1.group)(print.spaced(["defaultKw", "expr"])); },
     constraint_primary_key: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["primaryKeyKw", "direction", "columns", "onConflict"]));
+        return (0, print_utils_1.group)(print.spaced(["primaryKeyKw", "direction", "columns", "clauses"]));
     },
     constraint_unique: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "onConflict"]));
+        return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "nullsKw", "clauses"]));
+    },
+    constraint_check: function (print) {
+        return (0, print_utils_1.group)(print.spaced(["checkKw", "expr", "clauses"]));
     },
-    constraint_check: function (print) { return (0, print_utils_1.group)(print.spaced(["checkKw", "expr"])); },
     constraint_collate: function (print) {
         return (0, print_utils_1.group)(print.spaced(["collateKw", "collation"]));
     },
     constraint_foreign_key: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["foreignKeyKw", "columns", "references"]));
+        return (0, print_utils_1.group)(print.spaced(["foreignKeyKw", "indexName", "columns", "references"]));
     },
     references_specification: function (print, node) {
         var baseDoc = print.spaced(["referencesKw", "table", "columns"]);
@@ -48,11 +56,17 @@ exports.constraintMap = {
             return baseDoc;
         }
     },
-    referential_action: function (print) { return print.spaced(["onKw", "eventKw", "actionKw"]); },
+    index_specification: function (print) {
+        return print.spaced(["expr", "opclass", "direction", "nullHandlingKw"]);
+    },
+    referential_action: function (print) {
+        return print.spaced(["onKw", "eventKw", "actionKw", "columns"]);
+    },
     referential_match: function (print) { return print.spaced(["matchKw", "typeKw"]); },
     constraint_generated: function (print) {
         return print.spaced(["generatedKw", "asKw", "expr", "storageKw"]);
     },
+    identity_column: function (print) { return print("identityKw"); },
     constraint_auto_increment: function (print) { return print("autoIncrementKw"); },
     on_conflict_clause: function (print) { return print.spaced(["onConflictKw", "resolutionKw"]); },
     constraint_comment: function (print) { return print.spaced(["commentKw", "value"]); },
@@ -67,12 +81,29 @@ exports.constraintMap = {
     constraint_engine_attribute: function (print, node) {
         return (0, print_utils_1.join)(node.hasEq ? " = " : " ", print(["engineAttributeKw", "value"]));
     },
+    constraint_compression: function (print) { return print.spaced(["compressionKw", "method"]); },
+    constraint_exclude: function (print, node) {
+        return (0, print_utils_1.group)([
+            print("excludeKw"),
+            (0, print_utils_1.indent)([
+                print_utils_1.line,
+                (0, print_utils_1.join)(print_utils_1.line, __spreadArray([
+                    print.separated(print_utils_1.line, ["using", "params"])
+                ], print("clauses"), true)),
+            ]),
+        ]);
+    },
+    exclusion_param: function (print) { return print.spaced(["index", "withKw", "operator"]); },
+    index_include_clause: function (print) { return print.spaced(["includeKw", "columns"]); },
+    index_tablespace_clause: function (print) {
+        return print.spaced(["usingIndexTablespaceKw", "name"]);
+    },
 };
 var printUnnamedConstraint = function (print, node) {
-    if (node.deferrable) {
+    if (node.modifiers.length > 0) {
         return (0, print_utils_1.group)([
             print("constraint"),
-            (0, print_utils_1.indent)([print_utils_1.hardline, print("deferrable")]),
+            (0, print_utils_1.indent)([print_utils_1.line, print.spaced("modifiers")]),
         ]);
     }
     else {

package/dist/syntax/create_table.js

@@ -13,6 +13,7 @@ exports.createTableMap = void 0;
 var node_utils_1 = require("../node_utils");
 var print_utils_1 = require("../print_utils");
 exports.createTableMap = {
+    /** cst-ignore: clauses */
     create_table_stmt: function (print, node) {
         var rest = [];
         for (var _i = 2; _i < arguments.length; _i++) {
@@ -22,21 +23,21 @@ exports.createTableMap = {
             print.spaced([
                 "createKw",
                 "orReplaceKw",
-                "temporaryKw",
-                "externalKw",
-                "snapshotKw",
-                "virtualKw",
+                "kind",
                 "tableKw",
                 "ifNotExistsKw",
                 "name",
+                "partitionOf",
+                "ofType",
                 "columns",
             ]),
             printClauses.apply(void 0, __spreadArray([print, node], rest, false)),
             node.options ? [print_utils_1.line, (0, print_utils_1.group)(print("options"))] : [],
         ];
     },
+    table_kind: function (print) { return print.spaced("kindKw"); },
     column_definition: function (print) {
-        return print.spaced(["name", "dataType", "constraints"]);
+        return print.spaced(["name", "dataType", "withOptionsKw", "constraints"]);
     },
     table_option: function (print, node) {
         if (node.value && node.hasEq) {
@@ -49,13 +50,53 @@ exports.createTableMap = {
             return print.spaced("name");
         }
     },
-    create_table_like_clause: function (print) { return print.spaced(["likeKw", "name"]); },
+    create_table_like_clause: function (print) {
+        return print.spaced(["likeKw", "name", "options"]);
+    },
+    table_like_option: function (print) {
+        return print.spaced(["includingOrExcludingKw", "optionKw"]);
+    },
     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"]);
     },
     create_table_using_clause: function (print) { return print.spaced(["usingKw", "module"]); },
+    create_table_inherits_clause: function (print) {
+        return print.spaced(["inheritsKw", "tables"]);
+    },
+    create_table_partition_by_clause: function (print) {
+        return print.spaced(["partitionByKw", "strategyKw", "columns"]);
+    },
+    create_table_partition_of_clause: function (print) {
+        return print.spaced(["partitionOfKw", "table"]);
+    },
+    create_table_partition_bound_clause: function (print) {
+        return print.spaced(["forValuesKw", "bound"]);
+    },
+    partition_bound_in: function (print) { return print.spaced(["inKw", "values"]); },
+    partition_bound_from_to: function (print) {
+        return print.spaced(["fromKw", "from", "toKw", "to"]);
+    },
+    partition_bound_minvalue: function (print) { return print.spaced("minvalueKw"); },
+    partition_bound_maxvalue: function (print) { return print.spaced("maxvalueKw"); },
+    partition_bound_with: function (print) { return print.spaced(["withKw", "values"]); },
+    partition_bound_modulus: function (print) { return print.spaced(["modulusKw", "value"]); },
+    partition_bound_remainder: function (print) { return print.spaced(["remainderKw", "value"]); },
+    create_table_default_partition_clause: function (print) { return print.spaced("defaultKw"); },
+    create_table_of_type_clause: function (print) { return print.spaced(["ofKw", "typeName"]); },
+    using_access_method_clause: function (print) { return print.spaced(["usingKw", "method"]); },
+    create_table_tablespace_clause: function (print) {
+        return print.spaced(["tablespaceKw", "name"]);
+    },
+    with_storage_parameters_clause: function (print) {
+        return print.spaced(["withKw", "options"]);
+    },
+    create_table_without_oids_clause: function (print) { return print.spaced("withoutOidsKw"); },
+    create_table_on_commit_clause: function (print) {
+        return print.spaced(["onCommitKw", "actionKw"]);
+    },
+    create_table_with_data_clause: function (print) { return print.spaced("withDataKw"); },
 };
 var printClauses = function (print, node) {
     if (node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0])) {

package/dist/syntax/dcl.js

@@ -4,17 +4,17 @@ exports.dclMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.dclMap = {
     grant_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.dynamicLine(), [
             (0, print_utils_1.group)([print("grantKw"), (0, print_utils_1.indent)([print_utils_1.line, print("roles")])]),
             (0, print_utils_1.group)(print.spaced(["onKw", "resourceType", "resourceName"])),
             (0, print_utils_1.group)([print("toKw"), (0, print_utils_1.indent)([print_utils_1.line, print("users")])]),
-        ]);
+        ]));
     },
     revoke_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.dynamicLine(), [
             (0, print_utils_1.group)([print("revokeKw"), (0, print_utils_1.indent)([print_utils_1.line, print("roles")])]),
             (0, print_utils_1.group)(print.spaced(["onKw", "resourceType", "resourceName"])),
             (0, print_utils_1.group)([print("fromKw"), (0, print_utils_1.indent)([print_utils_1.line, print("users")])]),
-        ]);
+        ]));
     },
 };

package/dist/syntax/delete.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.deleteMap = {
-    delete_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")); },
+    delete_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     delete_clause: function (print) {
         return print.spaced(["deleteKw", "modifiers", "fromKw", "tables"]);
     },

package/dist/syntax/dialects/postgresql.d.ts

@@ -1,3 +1,3 @@
 import { AllPostgresqlNodes } from "sql-parser-cst";
 import { CstToDocMap } from "../../CstToDocMap";
-export declare const postgresqlMap: Partial<CstToDocMap<AllPostgresqlNodes>>;
+export declare const postgresqlMap: CstToDocMap<AllPostgresqlNodes>;

package/dist/syntax/dialects/postgresql.js

@@ -4,4 +4,5 @@ exports.postgresqlMap = void 0;
 exports.postgresqlMap = {
     postgresql_operator_expr: function (print) { return print(["operatorKw", "expr"]); },
     postgresql_operator: function (print) { return print("operator"); },
+    postgresql_operator_class: function (print) { return print("name"); },
 };

package/dist/syntax/drop_table.js

@@ -5,11 +5,11 @@ exports.dropTableMap = {
     drop_table_stmt: function (print) {
         return print.spaced([
             "dropKw",
-            "externalKw",
-            "snapshotKw",
+            "kind",
             "tableKw",
             "ifExistsKw",
             "tables",
+            "behaviorKw",
         ]);
     },
 };

package/dist/syntax/explain.js

@@ -5,7 +5,7 @@ var print_utils_1 = require("../print_utils");
 exports.explainMap = {
     explain_stmt: function (print) {
         return (0, print_utils_1.group)([
-            print.spaced(["explainKw", "queryPlanKw"]),
+            print.spaced(["explainKw", "analyzeKw", "queryPlanKw"]),
             (0, print_utils_1.indent)([print_utils_1.line, print("statement")]),
         ]);
     },

package/dist/syntax/expr.js

@@ -115,7 +115,12 @@ exports.exprMap = {
     over_arg: function (print) { return print.spaced(["overKw", "window"]); },
     having_arg: function (print) { return print.spaced(["havingKw", "minMaxKw", "expr"]); },
     named_arg: function (print) {
-        return (0, print_utils_1.group)([print("name"), " ", "=>", (0, print_utils_1.indent)([print_utils_1.line, print("value")])]);
+        return (0, print_utils_1.group)([
+            print("name"),
+            " ",
+            print("operator"),
+            (0, print_utils_1.indent)([print_utils_1.line, print("value")]),
+        ]);
     },
     cast_expr: function (print) { return print(["castKw", "args"]); },
     cast_arg: function (print) { return print.spaced(["expr", "asKw", "dataType", "format"]); },
@@ -145,10 +150,15 @@ exports.exprMap = {
         return print.spaced(["matchKw", "columns", "againstKw", "args"]);
     },
     full_text_match_args: function (print) { return print.spaced(["expr", "modifier"]); },
+    /** cst-ignore: value */
     number_literal: function (print) { return print("text"); },
+    /** cst-ignore: value */
     boolean_literal: function (print) { return print("valueKw"); },
+    /** cst-ignore: value */
     string_literal: function (print) { return print("text"); },
+    /** cst-ignore: value */
     blob_literal: function (print) { return print("text"); },
+    /** cst-ignore: value */
     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"]); },
@@ -158,7 +168,9 @@ exports.exprMap = {
     timestamp_literal: function (print) { return print.spaced(["timestampKw", "string"]); },
     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"); },
+    /** cst-ignore: name */
     variable: function (print) { return print("text"); },
     parameter: function (print) { return print("text"); },
 };

package/dist/syntax/index.js

@@ -12,8 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.indexMap = {
-    create_index_stmt: function (print, node) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
+    create_index_stmt: function (print) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), __spreadArray([
             print.spaced([
                 "createKw",
                 "indexTypeKw",
@@ -24,7 +24,7 @@ exports.indexMap = {
                 "table",
                 "columns",
             ])
-        ], (node.clauses.length > 0 ? [(0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))] : []), true));
+        ], print("clauses"), true)));
     },
     drop_index_stmt: function (print) {
         return print.spaced([

package/dist/syntax/insert.js

@@ -3,33 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.insertMap = {
-    insert_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")); },
+    insert_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     insert_clause: function (print, node) {
         return (0, print_utils_1.group)([
             print.spaced(["insertKw", "modifiers", "orAction", "intoKw", "table"]),
-            node.columns ? (0, print_utils_1.indent)([print_utils_1.hardline, print("columns")]) : [],
+            node.columns ? (0, print_utils_1.indent)([print.dynamicLine(), print("columns")]) : [],
         ]);
     },
     values_clause: function (print) {
-        return (0, print_utils_1.group)([print("valuesKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("values")])]);
+        return (0, print_utils_1.group)([print("valuesKw"), (0, print_utils_1.indent)([print.dynamicLine(), 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"]);
+        return print.spaced(["onConflictKw", "conflictTarget", "where", "doKw", "action"]);
+    },
+    conflict_target_on_constraint: function (print) {
+        return print.spaced(["onConstraintKw", "constraint"]);
     },
     upsert_action_nothing: function (print) { return print("nothingKw"); },
-    upsert_action_update: function (print) { return [
-        print("updateKw"),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print(["set", "where"]))]),
-    ]; },
-    row_alias_clause: function (print, node) { return [
-        print.spaced(["asKw", "rowAlias"]),
-        node.columnAliases ? (0, print_utils_1.indent)([print_utils_1.hardline, print("columnAliases")]) : [],
-    ]; },
-    on_duplicate_key_update_clause: function (print) { return [
-        print.spaced("onDuplicateKeyUpdateKw"),
-        (0, print_utils_1.indent)([print_utils_1.hardline, print("assignments")]),
-    ]; },
+    upsert_action_update: function (print) {
+        return (0, print_utils_1.group)([
+            print("updateKw"),
+            (0, print_utils_1.indent)([
+                print.dynamicLine(),
+                (0, print_utils_1.join)(print.dynamicLine(), print(["set", "where"])),
+            ]),
+        ]);
+    },
+    row_alias_clause: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced(["asKw", "rowAlias"]),
+            node.columnAliases
+                ? (0, print_utils_1.indent)([print.dynamicLine(), print("columnAliases")])
+                : [],
+        ]);
+    },
+    on_duplicate_key_update_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced("onDuplicateKeyUpdateKw"),
+            (0, print_utils_1.indent)([print.dynamicLine(), print("assignments")]),
+        ]);
+    },
+    overriding_clause: function (print) { return print.spaced("overridingKw"); },
 };

package/dist/syntax/merge.js

@@ -1,23 +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.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, __spreadArray([
+    merge_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.line, print("clauses")); },
+    merge_clause: function (print) {
+        return (0, print_utils_1.join)(print_utils_1.line, [
             print.spaced(["mergeKw", "intoKw", "target"]),
             print.spaced(["usingKw", "source"]),
-            (0, print_utils_1.group)([print("onKw"), (0, print_utils_1.indent)([print_utils_1.line, print("condition")])])
-        ], print("clauses").map(function (clause) { return (0, print_utils_1.group)(clause); }), true));
+            (0, print_utils_1.group)([print("onKw"), (0, print_utils_1.indent)([print_utils_1.line, print("condition")])]),
+        ]);
     },
     merge_when_clause: function (print, node) { return [
         (0, print_utils_1.group)([
@@ -35,8 +27,9 @@ exports.mergeMap = {
             node.columns ? (0, print_utils_1.indent)([print_utils_1.hardline, print("columns")]) : [],
         ]),
         print_utils_1.line,
-        (0, print_utils_1.group)(print("values")),
+        (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")),
     ]; },
     merge_action_insert_row_clause: function (print) { return print("rowKw"); },
     merge_action_update: function (print) { return print.spaced(["updateKw", "set"]); },
+    merge_action_do_nothing: function (print) { return print.spaced(["doNothingKw"]); },
 };

package/dist/syntax/other_clauses.d.ts

@@ -0,0 +1,3 @@
+import { AllOtherClauses } from "sql-parser-cst";
+import { CstToDocMap } from "../CstToDocMap";
+export declare const otherClausesMap: CstToDocMap<AllOtherClauses>;

package/dist/syntax/other_clauses.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.otherClausesMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.otherClausesMap = {
+    // CLUSTER BY clause
+    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")])]);
+    },
+    // RETURNING clause
+    returning_clause: function (print) {
+        return (0, print_utils_1.group)([print("returningKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
+    },
+    // WHERE CURRENT OF clause
+    where_current_of_clause: function (print) {
+        return print.spaced(["whereCurrentOfKw", "cursor"]);
+    },
+};

package/dist/syntax/procedural_language.js

@@ -108,7 +108,7 @@ exports.proceduralLanguageMap = {
     // CALL
     call_stmt: function (print) { return print.spaced(["callKw", "func"]); },
     // RETURN
-    return_stmt: function (print) { return print("returnKw"); },
+    return_stmt: function (print) { return print.spaced(["returnKw", "expr"]); },
     // RAISE
     raise_stmt: function (print) { return print.spaced(["raiseKw", "message"]); },
     raise_message: function (print) { return [

package/dist/syntax/rename_table.d.ts

@@ -0,0 +1,3 @@
+import { AllRenameTableNodes } from "sql-parser-cst";
+import { CstToDocMap } from "../CstToDocMap";
+export declare const renameTableMap: CstToDocMap<AllRenameTableNodes>;

package/dist/syntax/rename_table.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameTableMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.renameTableMap = {
+    rename_table_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["renameKw", "tableKw"]),
+            (0, print_utils_1.indent)([print_utils_1.line, print("actions")]),
+        ]);
+    },
+    rename_action: function (print) { return print.spaced(["from", "toKw", "to"]); },
+};

package/dist/syntax/select.js

@@ -1,13 +1,4 @@
 "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.selectMap = void 0;
 var utils_1 = require("../utils");
@@ -16,10 +7,7 @@ exports.selectMap = {
     compound_select_stmt: function (print) {
         return (0, print_utils_1.join)(print_utils_1.hardline, [print("left"), print.spaced("operator"), print("right")]);
     },
-    select_stmt: function (print, node, path, opts) {
-        var lineType = (0, print_utils_1.containsNewline)(node, opts) ? print_utils_1.hardline : print_utils_1.line;
-        return (0, print_utils_1.group)((0, print_utils_1.join)(lineType, print("clauses")));
-    },
+    select_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     // WITH clause
     with_clause: function (print) {
         return (0, print_utils_1.group)([
@@ -33,7 +21,7 @@ exports.selectMap = {
         print.spaced(["asKw", "materializedKw", "expr"]),
         (0, print_utils_1.group)([
             node.search || node.cycle
-                ? (0, print_utils_1.indent)([print_utils_1.line, (0, print_utils_1.join)(print_utils_1.line, print(["search", "cycle"]))])
+                ? (0, print_utils_1.indent)([print_utils_1.line, print.separated(print_utils_1.line, ["search", "cycle"])])
                 : [],
         ]),
     ]; },
@@ -161,12 +149,7 @@ exports.selectMap = {
     order_by_clause: function (print, node) {
         return (0, print_utils_1.group)([
             print.spaced("orderByKw"),
-            (0, print_utils_1.indent)([
-                print_utils_1.line,
-                (0, print_utils_1.join)(print_utils_1.line, __spreadArray([
-                    print("specifications")
-                ], (node.withRollupKw ? print.spaced("withRollupKw") : []), true)),
-            ]),
+            (0, print_utils_1.indent)([print_utils_1.line, print.separated(print_utils_1.line, ["specifications", "withRollupKw"])]),
         ]);
     },
     sort_specification: function (print) {
@@ -181,12 +164,7 @@ exports.selectMap = {
     group_by_clause: function (print, node) {
         return (0, print_utils_1.group)([
             print.spaced(["groupByKw", "distinctKw"]),
-            (0, print_utils_1.indent)([
-                print_utils_1.line,
-                (0, print_utils_1.join)(print_utils_1.line, __spreadArray([
-                    print("columns")
-                ], (node.withRollupKw ? print.spaced("withRollupKw") : []), true)),
-            ]),
+            (0, print_utils_1.indent)([print_utils_1.line, print.separated(print_utils_1.line, ["columns", "withRollupKw"])]),
         ]);
     },
     group_by_rollup: function (print) { return print(["rollupKw", "columns"]); },
@@ -201,10 +179,6 @@ exports.selectMap = {
             (0, print_utils_1.indent)([print_utils_1.line, print("specifications")]),
         ]);
     },
-    // CLUSTER BY clause
-    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
     having_clause: function (print) {
         return (0, print_utils_1.group)([print("havingKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
@@ -213,11 +187,8 @@ exports.selectMap = {
     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
-    returning_clause: function (print) {
-        return (0, print_utils_1.group)([print("returningKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
-    },
     // LIMIT clause
+    /** cst-ignore: count, offsetKw, offset */
     limit_clause: function (print, node) {
         return (0, print_utils_1.group)([
             print("limitKw"),
@@ -262,7 +233,7 @@ exports.selectMap = {
     },
     // INTO clause
     into_table_clause: function (print) {
-        return print.spaced(["intoKw", "temporaryKw", "unloggedKw", "tableKw", "name"]);
+        return print.spaced(["intoKw", "kind", "tableKw", "name"]);
     },
     into_variables_clause: function (print) {
         return (0, print_utils_1.group)([print("intoKw"), (0, print_utils_1.indent)([print_utils_1.line, print("variables")])]);

package/dist/syntax/transformMap.d.ts

@@ -1,3 +1,3 @@
 import { Node } from "sql-parser-cst";
 import { CstToDocMap } from "../CstToDocMap";
-export declare const transformMap: Partial<CstToDocMap<Node>>;
+export declare const transformMap: CstToDocMap<Node>;

package/dist/syntax/transformMap.js

@@ -29,6 +29,8 @@ var function_1 = require("./function");
 var index_1 = require("./index");
 var insert_1 = require("./insert");
 var merge_1 = require("./merge");
+var other_clauses_1 = require("./other_clauses");
+var rename_table_1 = require("./rename_table");
 var prepared_statements_1 = require("./prepared_statements");
 var procedural_language_1 = require("./procedural_language");
 var procedure_1 = require("./procedure");
@@ -45,4 +47,4 @@ var bigquery_1 = require("./dialects/bigquery");
 var mysql_1 = require("./dialects/mysql");
 var sqlite_1 = require("./dialects/sqlite");
 var postgresql_1 = require("./dialects/postgresql");
-exports.transformMap = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__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), analyze_1.analyzeMap), base_1.baseMap), constraint_1.constraintMap), create_table_1.createTableMap), data_type_1.dataTypeMap), dcl_1.dclMap), delete_1.deleteMap), drop_table_1.dropTableMap), explain_1.explainMap), expr_1.exprMap), frame_1.frameMap), function_1.functionMap), index_1.indexMap), insert_1.insertMap), merge_1.mergeMap), prepared_statements_1.preparedStatementsMap), proc_clause_1.procClauseMap), procedural_language_1.proceduralLanguageMap), procedure_1.procedureMap), program_1.programMap), schema_1.schemaMap), select_1.selectMap), transaction_1.transactionMap), trigger_1.triggerMap), truncate_1.truncateMap), update_1.updateMap), view_1.viewMap), bigquery_1.bigqueryMap), mysql_1.mysqlMap), postgresql_1.postgresqlMap), sqlite_1.sqliteMap);
+exports.transformMap = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__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), analyze_1.analyzeMap), base_1.baseMap), constraint_1.constraintMap), create_table_1.createTableMap), data_type_1.dataTypeMap), dcl_1.dclMap), delete_1.deleteMap), drop_table_1.dropTableMap), explain_1.explainMap), expr_1.exprMap), frame_1.frameMap), function_1.functionMap), index_1.indexMap), insert_1.insertMap), merge_1.mergeMap), other_clauses_1.otherClausesMap), prepared_statements_1.preparedStatementsMap), proc_clause_1.procClauseMap), procedural_language_1.proceduralLanguageMap), procedure_1.procedureMap), program_1.programMap), rename_table_1.renameTableMap), schema_1.schemaMap), select_1.selectMap), transaction_1.transactionMap), trigger_1.triggerMap), truncate_1.truncateMap), update_1.updateMap), view_1.viewMap), bigquery_1.bigqueryMap), mysql_1.mysqlMap), postgresql_1.postgresqlMap), sqlite_1.sqliteMap);

package/dist/syntax/trigger.js

@@ -22,7 +22,7 @@ exports.triggerMap = {
                 "name",
             ]),
             print("event")
-        ], (node.forEachRowKw ? [print.spaced(["forEachRowKw"])] : []), true), (node.condition ? [print(["condition"])] : []), true), [
+        ], print.spaced(["forEachRowKw"]), true), print(["condition"]), true), [
             print("body"),
         ], false));
     },

package/dist/syntax/truncate.js

@@ -1,6 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.truncateMap = void 0;
+var print_utils_1 = require("../print_utils");
 exports.truncateMap = {
-    truncate_stmt: function (print) { return print.spaced(["truncateKw", "tableKw", "table"]); },
+    truncate_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["truncateKw", "tableKw"]),
+            (0, print_utils_1.indent)([
+                print_utils_1.line,
+                print.separated(print_utils_1.line, [
+                    "tables",
+                    "restartOrContinueKw",
+                    "cascadeOrRestrictKw",
+                ]),
+            ]),
+        ]);
+    },
 };

package/dist/syntax/update.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.updateMap = {
-    update_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")); },
+    update_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     update_clause: function (print) {
         return print.spaced(["updateKw", "modifiers", "orAction", "tables"]);
     },

package/dist/syntax/view.js

@@ -22,10 +22,24 @@ exports.viewMap = {
         ];
     },
     drop_view_stmt: function (print) {
-        return print.spaced(["dropKw", "materializedKw", "viewKw", "ifExistsKw", "views"]);
+        return print.spaced([
+            "dropKw",
+            "materializedKw",
+            "viewKw",
+            "ifExistsKw",
+            "views",
+            "behaviorKw",
+        ]);
     },
     alter_view_stmt: function (print) { return [
-        print.spaced(["alterKw", "materializedKw", "viewKw", "ifExistsKw", "name"]),
+        print.spaced([
+            "alterKw",
+            "materializedKw",
+            "viewKw",
+            "ifExistsKw",
+            "name",
+            "columns",
+        ]),
         print_utils_1.hardline,
         (0, print_utils_1.join)(print_utils_1.hardline, print("actions")),
     ]; },

package/dist/transform/aliasAs.js

@@ -4,12 +4,11 @@ exports.processAliasAs = void 0;
 var sql_parser_cst_1 = require("sql-parser-cst");
 // Adds AS keyword to aliases if none exists
 var processAliasAs = function (cst) {
-    var mutateAliases = (0, sql_parser_cst_1.cstVisitor)({
+    (0, sql_parser_cst_1.cstVisitor)({
         alias: function (node) {
             node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
         },
-    });
-    mutateAliases(cst);
+    })(cst);
     return cst;
 };
 exports.processAliasAs = processAliasAs;

package/dist/transform/canonicKeywords.d.ts

@@ -0,0 +1,2 @@
+import { Program } from "sql-parser-cst";
+export declare const canonicKeywords: (cst: Program) => Program;

package/dist/transform/canonicKeywords.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicKeywords = void 0;
+var sql_parser_cst_1 = require("sql-parser-cst");
+var transformUtils_1 = require("./transformUtils");
+var canonicKeywords = function (cst) {
+    (0, sql_parser_cst_1.cstVisitor)({
+        // Replaces TEMP with TEMPORARY
+        table_kind: function (node) {
+            if (Array.isArray(node.kindKw)) {
+                // TODO...
+            }
+            else {
+                if (node.kindKw.name === "TEMP") {
+                    node.kindKw.name = "TEMPORARY";
+                    node.kindKw.text = "TEMPORARY";
+                }
+            }
+        },
+        // Replaces MySQL SELECT DISTINCTROW with SELECT DISTINCT
+        select_distinct: function (node) {
+            if (node.distinctKw.name === "DISTINCTROW") {
+                node.distinctKw.name = "DISTINCT";
+                node.distinctKw.text = "DISTINCT";
+            }
+        },
+        // Replaces RENAME & RENAME AS with RENAME TO
+        alter_action_rename_table: function (node) {
+            if (Array.isArray(node.renameKw)) {
+                if (node.renameKw[1].name === "AS") {
+                    node.renameKw[1].name = "TO";
+                    node.renameKw[1].text = "TO";
+                }
+            }
+            else {
+                node.renameKw = [node.renameKw, (0, transformUtils_1.keyword)("TO")];
+            }
+        },
+        // Replaces INSERT with INSERT INTO
+        insert_clause: function (node) {
+            if (!node.intoKw) {
+                node.intoKw = (0, transformUtils_1.keyword)("INTO");
+            }
+        },
+        // Replaces MERGE with MERGE INTO
+        merge_clause: function (node) {
+            if (!node.intoKw) {
+                node.intoKw = (0, transformUtils_1.keyword)("INTO");
+            }
+        },
+        // Replaces DELETE with DELETE FROM
+        delete_clause: function (node) {
+            if (!node.fromKw) {
+                node.fromKw = (0, transformUtils_1.keyword)("FROM");
+            }
+        },
+        // Replaces TRUNCATE with TRUNCATE TABLE
+        truncate_stmt: function (node) {
+            if (!node.tableKw) {
+                node.tableKw = (0, transformUtils_1.keyword)("TABLE");
+            }
+        },
+    })(cst);
+    return cst;
+};
+exports.canonicKeywords = canonicKeywords;

package/dist/transform/canonicOperators.d.ts

@@ -0,0 +1,3 @@
+import { Program } from "sql-parser-cst";
+import { AllPrettierOptions } from "src/options";
+export declare const canonicOperators: (cst: Program, originalText: string, options: AllPrettierOptions) => Program;

package/dist/transform/canonicOperators.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicOperators = void 0;
+var sql_parser_cst_1 = require("sql-parser-cst");
+var transformUtils_1 = require("./transformUtils");
+var canonicOperators = function (cst, originalText, options) {
+    (0, sql_parser_cst_1.cstVisitor)({
+        binary_expr: function (node) {
+            // Replaces <> operator with !=
+            if (node.operator === "<>") {
+                node.operator = "!=";
+            }
+            // Replace MySQL && and || operators with AND and OR
+            if (options.parser === "mysql" || options.parser === "mariadb") {
+                if (node.operator === "&&") {
+                    node.operator = (0, transformUtils_1.keyword)("AND");
+                }
+                if (node.operator === "||") {
+                    node.operator = (0, transformUtils_1.keyword)("OR");
+                }
+            }
+        },
+        // Replaces PostgreSQL deprecated := operator with =>
+        named_arg: function (node) {
+            if (node.operator === ":=") {
+                node.operator = "=>";
+            }
+        },
+    })(cst);
+    return cst;
+};
+exports.canonicOperators = canonicOperators;

package/dist/transform/stripTrailingCommas.js

@@ -7,14 +7,13 @@ 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)({
+    (0, sql_parser_cst_1.cstVisitor)({
         select_clause: function (node) {
             if (node.columns && (0, node_utils_1.isEmpty)((0, utils_1.last)(node.columns.items))) {
                 node.columns.items = node.columns.items.slice(0, -1);
             }
         },
-    });
-    removeLastEmptyColumn(cst);
+    })(cst);
     return cst;
 };
 exports.stripTrailingCommas = stripTrailingCommas;

package/dist/transform/transformCst.d.ts

@@ -1,2 +1,5 @@
 import { Program } from "sql-parser-cst";
-export declare const transformCst: (cst: Program, originalText: string) => Program;
+import { AllPrettierOptions } from "src/options";
+export declare const transformCst: TransformFn;
+type TransformFn = (cst: Program, originalText: string, options: AllPrettierOptions) => Program;
+export {};

package/dist/transform/transformCst.js

@@ -5,9 +5,19 @@ var comments_1 = require("./comments");
 var aliasAs_1 = require("./aliasAs");
 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);
+var canonicKeywords_1 = require("./canonicKeywords");
+var canonicOperators_1 = require("./canonicOperators");
+var transformCst = function (cst, originalText, options) {
+    var transforms = [
+        // Note that we first perform moveCommentsToRoot transform,
+        // so we don't need to worry about comments interfering with other transforms
+        comments_1.moveCommentsToRoot,
+        stripTrailingCommas_1.stripTrailingCommas,
+        addFinalSemicolon_1.addFinalSemicolon,
+    ];
+    if (options.sqlCanonicalSyntax) {
+        transforms.push(aliasAs_1.processAliasAs, canonicOperators_1.canonicOperators, canonicKeywords_1.canonicKeywords);
+    }
+    return transforms.reduce(function (cst, transform) { return transform(cst, originalText, options); }, cst);
 };
 exports.transformCst = transformCst;

package/dist/transform/transformUtils.d.ts

@@ -0,0 +1,2 @@
+import { Keyword } from "sql-parser-cst";
+export declare function keyword<T extends string>(name: T): Keyword<T>;

package/dist/transform/transformUtils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyword = void 0;
+function keyword(name) {
+    return { type: "keyword", name: name, text: name };
+}
+exports.keyword = keyword;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Prettier plugin for SQL",
   "author": "Rene Saarsoo <nene@triin.net>",
   "license": "GPL-3.0-or-later",
@@ -18,12 +18,13 @@
     "dist/"
   ],
   "scripts": {
-    "prepublishOnly": "yarn test && yarn build",
+    "prepublishOnly": "yarn analyze-field-access && yarn test && yarn build",
     "clean": "rm -rf dist",
     "build": "yarn clean && tsc",
     "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
     "pretty": "prettier -w src/ test/",
-    "ts:check": "tsc --noEmit"
+    "ts:check": "tsc --noEmit",
+    "analyze-field-access": "ts-node scripts/analyze-field-access.ts src/index.ts"
   },
   "keywords": [
     "prettier",
@@ -32,13 +33,14 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.21.1"
+    "sql-parser-cst": "^0.23.0"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",
     "dedent-js": "^1.0.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
     "typescript": "^4.9.4"
   }
 }