prettier-plugin-sql-cst 0.9.2 → 0.10.1

package/README.md

@@ -89,6 +89,9 @@ The plugin provides the following parsers:
 
 - `sqlite`
 - `bigquery`
+- `postgresql` (**experimental! expect crashes**)
+- `mysql` (**experimental! expect crashes**)
+- `mariadb` (**experimental! expect crashes**)
 
 ## Configuration
 
@@ -107,6 +110,18 @@ Currently this plugin supports two SQL dialects:
 - **SQLite** - full support.
 - **BigQuery** - full support.
 
+It also has experimental support for the following dialects:
+
+- PostgreSQL
+- MySQL
+- MariaDB
+
+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.
+
 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.
 

package/dist/embedJson.js

@@ -53,7 +53,8 @@ var print_utils_1 = require("./print_utils");
 var embedJson = function (path, options) {
     var node = path.getValue(); // TODO: Don't use deprecated method
     var parent = path.getParentNode();
-    if ((0, node_utils_1.isStringLiteral)(node) && (0, node_utils_1.isJsonLiteral)(parent)) {
+    if ((0, node_utils_1.isStringLiteral)(node) &&
+        ((0, node_utils_1.isJsonLiteral)(parent) || (0, node_utils_1.isJsonbLiteral)(parent))) {
         return function (textToDoc) { return __awaiter(void 0, void 0, void 0, function () {
             var json, inlineQuote;
             return __generator(this, function (_a) {

package/dist/index.js

@@ -20,6 +20,21 @@ exports.languages = [
         name: "BigQuery SQL",
         parsers: ["bigquery"],
     },
+    {
+        extensions: [],
+        name: "Experimental MySQL SQL",
+        parsers: ["mysql"],
+    },
+    {
+        extensions: [],
+        name: "Experimental MariaDB SQL",
+        parsers: ["mariadb"],
+    },
+    {
+        extensions: [],
+        name: "Experimental PostgreSQL SQL",
+        parsers: ["postgresql"],
+    },
 ];
 var createParser = function (dialect) { return ({
     parse: function (text, options) {
@@ -38,6 +53,9 @@ var createParser = function (dialect) { return ({
 exports.parsers = {
     sqlite: createParser("sqlite"),
     bigquery: createParser("bigquery"),
+    mysql: createParser("mysql"),
+    mariadb: createParser("mariadb"),
+    postgresql: createParser("postgresql"),
 };
 exports.printers = {
     "sql-cst": {

package/dist/node_utils.d.ts

@@ -7,6 +7,7 @@ export declare const isCreateTableStmt: (node: any) => node is import("sql-parse
 export declare const isKeyword: (node: any) => node is import("sql-parser-cst").Keyword<string>;
 export declare const isEmpty: (node: any) => node is import("sql-parser-cst").Empty;
 export declare const isJsonLiteral: (node: any) => node is import("sql-parser-cst").JsonLiteral;
+export declare const isJsonbLiteral: (node: any) => node is import("sql-parser-cst").JsonbLiteral;
 export declare const isStringLiteral: (node: any) => node is import("sql-parser-cst").StringLiteral;
 export declare const isArraySubscript: (node: any) => node is import("sql-parser-cst").ArraySubscript;
 export declare const isAsClause: (node: any) => node is import("sql-parser-cst").AsClause<Node>;

package/dist/node_utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLanguageClause = exports.isCreateFunctionStmt = exports.isListExpr = exports.isParenExpr = exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncArgs = exports.isFuncCall = exports.isValuesClause = exports.isProgram = void 0;
+exports.isLanguageClause = exports.isCreateFunctionStmt = exports.isListExpr = exports.isParenExpr = exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonbLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncArgs = exports.isFuncCall = exports.isValuesClause = exports.isProgram = void 0;
 var utils_1 = require("./utils");
 var is = function (type) {
     return function (node) {
@@ -15,6 +15,7 @@ exports.isCreateTableStmt = is("create_table_stmt");
 exports.isKeyword = is("keyword");
 exports.isEmpty = is("empty");
 exports.isJsonLiteral = is("json_literal");
+exports.isJsonbLiteral = is("jsonb_literal");
 exports.isStringLiteral = is("string_literal");
 exports.isArraySubscript = is("array_subscript");
 exports.isAsClause = is("as_clause");

package/dist/syntax/alias.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aliasMap = void 0;
 exports.aliasMap = {
-    alias: function (print) { return print.spaced(["expr", "asKw", "alias"]); },
+    alias: function (print) { return print.spaced(["expr", "asKw", "alias", "columnAliases"]); },
 };

package/dist/syntax/alter_table.d.ts

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

package/dist/syntax/base.d.ts

@@ -1,3 +1,3 @@
 import { AllColumns, Empty, Keyword } from "sql-parser-cst";
 import { CstToDocMap } from "../CstToDocMap";
-export declare const baseMap: Partial<CstToDocMap<Keyword | Empty | AllColumns>>;
+export declare const baseMap: CstToDocMap<Keyword | Empty | AllColumns>;

package/dist/syntax/constraint.d.ts

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

package/dist/syntax/constraint.js

@@ -18,12 +18,13 @@ exports.constraintMap = {
     constraint_deferrable: function (print) {
         return print.spaced(["deferrableKw", "initiallyKw"]);
     },
+    constraint_null: function (print) { return print("nullKw"); },
     constraint_not_null: function (print) {
         return (0, print_utils_1.group)(print.spaced(["notNullKw", "onConflict"]));
     },
     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", "orderKw", "columns", "onConflict"]));
+        return (0, print_utils_1.group)(print.spaced(["primaryKeyKw", "direction", "columns", "onConflict"]));
     },
     constraint_unique: function (print) {
         return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "onConflict"]));
@@ -54,6 +55,18 @@ exports.constraintMap = {
     },
     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"]); },
+    constraint_index: function (print) {
+        return print.spaced(["indexTypeKw", "indexKw", "columns"]);
+    },
+    constraint_visible: function (print) { return print.spaced(["visibleKw"]); },
+    constraint_column_format: function (print) {
+        return print.spaced(["columnFormatKw", "formatKw"]);
+    },
+    constraint_storage: function (print) { return print.spaced(["storageKw", "typeKw"]); },
+    constraint_engine_attribute: function (print, node) {
+        return (0, print_utils_1.join)(node.hasEq ? " = " : " ", print(["engineAttributeKw", "value"]));
+    },
 };
 var printUnnamedConstraint = function (print, node) {
     if (node.deferrable) {

package/dist/syntax/create_table.d.ts

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

package/dist/syntax/create_table.js

@@ -38,7 +38,17 @@ exports.createTableMap = {
     column_definition: function (print) {
         return print.spaced(["name", "dataType", "constraints"]);
     },
-    table_option: function (print) { return print.spaced(["name"]); },
+    table_option: function (print, node) {
+        if (node.value && node.hasEq) {
+            return [print.spaced("name"), " = ", print.spaced("value")];
+        }
+        else if (node.value) {
+            return [print.spaced("name"), " ", print.spaced("value")];
+        }
+        else {
+            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"]); },

package/dist/syntax/data_type.d.ts

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

package/dist/syntax/data_type.js

@@ -8,6 +8,11 @@ exports.dataTypeMap = {
     named_data_type: function (print, node) {
         return ((0, utils_1.isArray)(node.nameKw) ? print.spaced : print)(["nameKw", "params"]);
     },
+    array_data_type: function (print) { return print(["dataType", "bounds"]); },
+    array_bounds: function (print) { return ["[", print("bounds"), "]"]; },
+    with_time_zone_data_type: function (print) {
+        return print.spaced(["dataType", "withTimeZoneKw"]);
+    },
     generic_type_params: function (print) {
         return (0, print_utils_1.group)(["<", (0, print_utils_1.indent)([print_utils_1.softline, print("params")]), print_utils_1.softline, ">"]);
     },

package/dist/syntax/dcl.d.ts

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

package/dist/syntax/delete.js

@@ -4,5 +4,7 @@ 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_clause: function (print) { return print.spaced(["deleteKw", "fromKw", "tables"]); },
+    delete_clause: function (print) {
+        return print.spaced(["deleteKw", "modifiers", "fromKw", "tables"]);
+    },
 };

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

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

package/dist/syntax/{bigquery.js → dialects/bigquery.js}

@@ -10,7 +10,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bigqueryMap = void 0;
-var print_utils_1 = require("../print_utils");
+var print_utils_1 = require("../../print_utils");
 exports.bigqueryMap = {
     bigquery_options: function (print) { return print.spaced(["optionsKw", "options"]); },
     bigquery_option_default_collate: function (print) {

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

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

package/dist/syntax/dialects/mysql.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mysqlMap = void 0;
+exports.mysqlMap = {
+    mysql_modifier: function (print) { return print.spaced("modifierKw"); },
+};

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

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

package/dist/syntax/dialects/postgresql.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postgresqlMap = void 0;
+exports.postgresqlMap = {
+    postgresql_operator_expr: function (print) { return print(["operatorKw", "expr"]); },
+    postgresql_operator: function (print) { return print("operator"); },
+};

package/dist/syntax/{sqlite.d.ts → dialects/sqlite.d.ts}

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

package/dist/syntax/{sqlite.js → dialects/sqlite.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sqliteMap = void 0;
-var print_utils_1 = require("../print_utils");
+var print_utils_1 = require("../../print_utils");
 exports.sqliteMap = {
     attach_database_stmt: function (print) {
         return print.spaced(["attachKw", "databaseKw", "file", "asKw", "schema"]);

package/dist/syntax/expr.d.ts

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

package/dist/syntax/expr.js

@@ -50,6 +50,10 @@ exports.exprMap = {
         if ((0, node_utils_1.isKeyword)(node.operator) && isBooleanOp(node.operator)) {
             return (0, print_utils_1.join)(print_utils_1.line, [print("left"), print.spaced(["operator", "right"])]);
         }
+        if (node.operator === "") {
+            // String concatenation with whitespace (MySQL / MariaDB)
+            return print.spaced(["left", "right"]);
+        }
         return print.spaced(["left", "operator", "right"]);
     },
     prefix_op_expr: function (print, node) {
@@ -93,6 +97,7 @@ exports.exprMap = {
         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"]); },
+    array_slice_specifier: function (print) { return [print("from"), ":", print("to")]; },
     func_call: function (print) {
         var fnCall = print(["name", "args"]);
         var extras = print(["filter", "over"]);
@@ -103,19 +108,27 @@ exports.exprMap = {
             return (0, print_utils_1.group)((0, print_utils_1.join)(" ", __spreadArray([fnCall], extras, true)));
         }
     },
-    func_args: function (print) { return print.spaced(["distinctKw", "args", "having"]); },
+    func_args: function (print, node) {
+        return (0, print_utils_1.join)(print_utils_1.line, __spreadArray(__spreadArray(__spreadArray([], print(["distinctKw", "args"]), true), (node.nullHandlingKw ? print.spaced("nullHandlingKw") : []), true), print(["orderBy", "limit", "having"]), true));
+    },
     filter_arg: function (print) { return print.spaced(["filterKw", "where"]); },
     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")])]);
+    },
     cast_expr: function (print) { return print(["castKw", "args"]); },
     cast_arg: function (print) { return print.spaced(["expr", "asKw", "dataType", "format"]); },
     cast_format: function (print) { return print.spaced(["formatKw", "string", "timezone"]); },
     cast_format_timezone: function (print) { return print.spaced(["atTimeZoneKw", "timezone"]); },
+    cast_operator_expr: function (print) { return [print("expr"), "::", print("dataType")]; },
+    string_with_charset: function (print) { return ["_", print(["charset", "string"])]; },
     raise_expr: function (print) { return print(["raiseKw", "args"]); },
     raise_expr_type: function (print) { return print("typeKw"); },
     extract_expr: function (print) { return print(["extractKw", "args"]); },
     extract_from: function (print) { return print.spaced(["unit", "fromKw", "expr"]); },
     week_expr: function (print) { return print(["weekKw", "args"]); },
+    interval_literal: function (print) { return print.spaced(["intervalKw", "string"]); },
     interval_expr: function (print) { return print.spaced(["intervalKw", "expr", "unit"]); },
     interval_unit_range: function (print) { return print.spaced(["fromUnit", "toKw", "toUnit"]); },
     interval_unit: function (print) { return print("unitKw"); },
@@ -126,9 +139,16 @@ exports.exprMap = {
         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"]); },
+    row_constructor: function (print) { return print(["rowKw", "row"]); },
+    quantifier_expr: function (print) { return print.spaced(["quantifierKw", "expr"]); },
+    full_text_match_expr: function (print) {
+        return print.spaced(["matchKw", "columns", "againstKw", "args"]);
+    },
+    full_text_match_args: function (print) { return print.spaced(["expr", "modifier"]); },
     number_literal: function (print) { return print("text"); },
     boolean_literal: function (print) { return print("valueKw"); },
     string_literal: function (print) { return print("text"); },
+    blob_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"]); },
@@ -137,6 +157,7 @@ exports.exprMap = {
     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"]); },
+    jsonb_literal: function (print) { return print.spaced(["jsonbKw", "string"]); },
     identifier: function (print) { return print("text"); },
     variable: function (print) { return print("text"); },
     parameter: function (print) { return print("text"); },

package/dist/syntax/function.d.ts

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

package/dist/syntax/index.d.ts

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

package/dist/syntax/insert.d.ts

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

package/dist/syntax/insert.js

@@ -3,30 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.insertMap = {
-    insert_stmt: function (print, node) {
-        // When there's a columns clause, we want to indent it,
-        // but that only works when there's a newline inside it.
-        // So we have to avoid adding a newline before columns clause.
-        var columnsClauseIndex = node.clauses.findIndex(function (clause) { return clause.type === "insert_columns_clause"; });
-        if (columnsClauseIndex !== -1) {
-            var printedClauses = print("clauses");
-            var before = printedClauses.slice(0, columnsClauseIndex);
-            var columnsClause = printedClauses[columnsClauseIndex];
-            var after = printedClauses.slice(columnsClauseIndex + 1);
-            return [
-                (0, print_utils_1.join)(print_utils_1.hardline, before),
-                columnsClause,
-                after.length > 0 ? [print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, after)] : [],
-            ];
-        }
-        else {
-            return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"));
-        }
+    insert_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, 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")]) : [],
+        ]);
     },
-    insert_clause: function (print) {
-        return (0, print_utils_1.group)([print.spaced(["insertKw", "orAction", "intoKw", "table"])]);
-    },
-    insert_columns_clause: function (print) { return (0, print_utils_1.indent)([print_utils_1.hardline, 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")])]);
     },
@@ -41,4 +24,12 @@ exports.insertMap = {
         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")]),
+    ]; },
 };

package/dist/syntax/merge.d.ts

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

package/dist/syntax/prepared_statements.d.ts

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

package/dist/syntax/proc_clause.d.ts

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

package/dist/syntax/procedural_language.d.ts

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

package/dist/syntax/procedure.d.ts

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

package/dist/syntax/schema.d.ts

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

package/dist/syntax/select.d.ts

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

package/dist/syntax/select.js

@@ -1,4 +1,13 @@
 "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");
@@ -11,26 +20,61 @@ exports.selectMap = {
         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")));
     },
+    // WITH clause
     with_clause: function (print) {
         return (0, print_utils_1.group)([
             print.spaced(["withKw", "recursiveKw"]),
             (0, print_utils_1.indent)([print_utils_1.line, print("tables")]),
         ]);
     },
-    common_table_expr: function (print) { return [
+    common_table_expr: function (print, node) { return [
         print(["table", "columns"]),
         " ",
         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"]))])
+                : [],
+        ]),
     ]; },
+    cte_search_clause: function (print) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, [
+            [print.spaced("searchKw"), (0, print_utils_1.group)((0, print_utils_1.indent)([print_utils_1.line, print("columns")]))],
+            print.spaced(["setKw", "resultColumn"]),
+        ]));
+    },
+    cte_cycle_clause: function (print, node) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, [
+            [print("cycleKw"), (0, print_utils_1.group)((0, print_utils_1.indent)([print_utils_1.line, print("columns")]))],
+            print.spaced(["setKw", "resultColumn"]),
+            node.values ? print("values") : undefined,
+            print.spaced(["usingKw", "pathColumn"]),
+        ].filter(utils_1.isDefined)));
+    },
+    cte_cycle_clause_values: function (print) {
+        return (0, print_utils_1.join)(print_utils_1.line, [
+            print.spaced(["toKw", "markValue"]),
+            print.spaced(["defaultKw", "defaultValue"]),
+        ]);
+    },
+    // SELECT clause
     select_clause: function (print, node, path, opts) {
         return (0, print_utils_1.group)([
-            print.spaced(["selectKw", "distinctKw", "asStructOrValueKw"]),
-            (0, print_utils_1.indent)([print_utils_1.line, print("columns")]),
+            print.spaced(["selectKw", "modifiers"]),
+            node.columns ? (0, print_utils_1.indent)([print_utils_1.line, print("columns")]) : [],
             (0, print_utils_1.containsNewline)(node, opts) ? print_utils_1.breakParent : [],
         ]);
     },
+    select_all: function (print) { return print.spaced(["allKw"]); },
+    select_distinct: function (print) { return print.spaced(["distinctKw"]); },
+    select_distinct_on: function (print) {
+        return (0, print_utils_1.group)([print.spaced(["distinctOnKw", "columns"])]);
+    },
+    select_as_struct: function (print) { return print.spaced(["asStructKw"]); },
+    select_as_value: function (print) { return print.spaced(["asValueKw"]); },
     except_columns: function (print) { return print.spaced(["expr", "exceptKw", "columns"]); },
     replace_columns: function (print) { return print.spaced(["expr", "replaceKw", "columns"]); },
+    // FROM clause
     from_clause: function (print) {
         return (0, print_utils_1.group)([print("fromKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
     },
@@ -56,6 +100,8 @@ exports.selectMap = {
     },
     join_on_specification: function (print) { return (0, print_utils_1.group)(print.spaced(["onKw", "expr"])); },
     join_using_specification: function (print) { return (0, print_utils_1.group)(print.spaced(["usingKw", "expr"])); },
+    table_with_inheritance: function (print) { return [print("table"), " ", "*"]; },
+    table_without_inheritance: function (print) { return print.spaced(["onlyKw", "table"]); },
     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"]); },
@@ -85,46 +131,117 @@ exports.selectMap = {
         ]));
     },
     tablesample_expr: function (print) {
-        return (0, print_utils_1.group)([print("left"), print_utils_1.line, print.spaced(["tablesampleKw", "args"])]);
+        return (0, print_utils_1.group)([
+            print("left"),
+            print_utils_1.line,
+            print.spaced(["tablesampleKw", "method", "args", "repeatable"]),
+        ]);
     },
+    tablesample_method: function (print) { return print.spaced(["methodKw"]); },
     tablesample_percent: function (print) { return print.spaced(["percent", "percentKw"]); },
+    tablesample_repeatable: function (print) { return print.spaced(["repeatableKw", "seed"]); },
     for_system_time_as_of_expr: function (print) {
         return (0, print_utils_1.group)([print("left"), print_utils_1.line, print.spaced(["forSystemTimeAsOfKw", "expr"])]);
     },
+    partitioned_table: function (print) {
+        return print.spaced(["table", "partitionKw", "partitions"]);
+    },
+    dual_table: function (print) { return print("dualKw"); },
+    lateral_derived_table: function (print) { return print.spaced(["lateralKw", "expr"]); },
+    rows_from_expr: function (print) { return print.spaced(["rowsFromKw", "expr"]); },
+    with_ordinality_expr: function (print) { return print.spaced(["expr", "withOrdinalityKw"]); },
+    func_call_with_column_definitions: function (print) {
+        return print.spaced(["funcCall", "asKw", "columns"]);
+    },
+    // WHERE clause
     where_clause: function (print) {
         return (0, print_utils_1.group)([print("whereKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
     },
-    order_by_clause: function (print) {
-        return (0, print_utils_1.group)([print.spaced("orderByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("specifications")])]);
+    // ORDER BY clause
+    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)),
+            ]),
+        ]);
+    },
+    sort_specification: function (print) {
+        return print.spaced(["expr", "direction", "nullHandlingKw"]);
     },
-    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")])]);
+    sort_direction_asc: function (print) { return print("ascKw"); },
+    sort_direction_desc: function (print) { return print("descKw"); },
+    sort_direction_using_operator: function (print) {
+        return print.spaced(["usingKw", "operator"]);
+    },
+    // GROUP BY clause
+    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)),
+            ]),
+        ]);
     },
     group_by_rollup: function (print) { return print(["rollupKw", "columns"]); },
+    group_by_cube: function (print) { return print(["cubeKw", "columns"]); },
+    group_by_grouping_sets: function (print) {
+        return print.spaced(["groupingSetsKw", "columns"]);
+    },
+    // PARTITION BY clause
     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
     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")])]);
     },
+    // QUALIFY clause
     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
     limit_clause: function (print, node) {
-        return (0, print_utils_1.group)([print("limitKw"), (0, print_utils_1.indent)([print_utils_1.line, printLimitValues(print, node)])]);
+        return (0, print_utils_1.group)([
+            print("limitKw"),
+            (0, print_utils_1.indent)([
+                print_utils_1.line,
+                printLimitValues(print, node),
+                node.rowsExamined ? [print_utils_1.line, print("rowsExamined")] : [],
+            ]),
+        ]);
     },
-    sort_specification: function (print) {
-        return print.spaced(["expr", "orderKw", "nullHandlingKw"]);
+    limit_all: function (print) { return print("allKw"); },
+    limit_rows_examined: function (print) { return print.spaced(["rowsExaminedKw", "count"]); },
+    // OFFSET clause
+    offset_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print("offsetKw"),
+            (0, print_utils_1.indent)([print_utils_1.line, print.spaced(["offset", "rowsKw"])]),
+        ]);
+    },
+    // FETCH clause
+    fetch_clause: function (print) {
+        return print.spaced(["fetchKw", "count", "rowsKw", "withTiesKw"]);
     },
+    // WINDOW clause
     window_clause: function (print, node) {
         var lineType = node.namedWindows.items.length > 1 ? print_utils_1.hardline : print_utils_1.line;
         return (0, print_utils_1.group)([
@@ -143,6 +260,55 @@ exports.selectMap = {
         var lineType = itemCount > 1 ? print_utils_1.hardline : print_utils_1.line;
         return (0, print_utils_1.group)((0, print_utils_1.join)(lineType, print(["baseWindowName", "partitionBy", "orderBy", "frame"])));
     },
+    // INTO clause
+    into_table_clause: function (print) {
+        return print.spaced(["intoKw", "temporaryKw", "unloggedKw", "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")])]);
+    },
+    into_dumpfile_clause: function (print) { return print.spaced(["intoDumpfileKw", "filename"]); },
+    into_outfile_clause: function (print, node) {
+        var hasOptions = node.charset || node.fields || node.lines;
+        return (0, print_utils_1.group)([
+            print.spaced(["intoOutfileKw", "filename"]),
+            hasOptions
+                ? (0, print_utils_1.indent)([
+                    print_utils_1.hardline,
+                    (0, print_utils_1.join)(print_utils_1.hardline, print(["charset", "fields", "lines"])),
+                ])
+                : [],
+        ]);
+    },
+    outfile_fields: function (print) { return print.spaced(["fieldsKw", "options"]); },
+    outfile_lines: function (print) { return print.spaced(["linesKw", "options"]); },
+    outfile_option_character_set: function (print) {
+        return print.spaced(["characterSetKw", "value"]);
+    },
+    outfile_option_starting_by: function (print) {
+        return print.spaced(["startingByKw", "value"]);
+    },
+    outfile_option_terminated_by: function (print) {
+        return print.spaced(["terminatedByKw", "value"]);
+    },
+    outfile_option_enclosed_by: function (print) {
+        return print.spaced(["optionallyKw", "enclosedByKw", "value"]);
+    },
+    outfile_option_escaped_by: function (print) { return print.spaced(["escapedByKw", "value"]); },
+    // FOR clause (locking)
+    for_clause: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced(["forKw", "lockStrengthKw", "tables"]),
+            node.waitingKw ? (0, print_utils_1.indent)([print_utils_1.line, print.spaced("waitingKw")]) : [],
+        ]);
+    },
+    for_clause_tables: function (print) { return [
+        print("ofKw"),
+        (0, print_utils_1.indent)([print_utils_1.line, print("tables")]),
+    ]; },
+    lock_in_share_mode_clause: function (print) { return print.spaced("lockInShareModeKw"); },
+    // TABLE clause
+    table_clause: function (print) { return print.spaced(["tableKw", "table"]); },
 };
 var printLimitValues = function (print, node) {
     if (node.offsetKw) {

package/dist/syntax/transformMap.js

@@ -16,7 +16,6 @@ var alias_1 = require("./alias");
 var alter_table_1 = require("./alter_table");
 var analyze_1 = require("./analyze");
 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");
@@ -37,10 +36,13 @@ var proc_clause_1 = require("./proc_clause");
 var program_1 = require("./program");
 var schema_1 = require("./schema");
 var select_1 = require("./select");
-var sqlite_1 = require("./sqlite");
 var transaction_1 = require("./transaction");
 var trigger_1 = require("./trigger");
 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(__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), bigquery_1.bigqueryMap), 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), sqlite_1.sqliteMap), transaction_1.transactionMap), trigger_1.triggerMap), truncate_1.truncateMap), update_1.updateMap), view_1.viewMap);
+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);

package/dist/syntax/trigger.d.ts

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

package/dist/syntax/update.d.ts

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

package/dist/syntax/update.js

@@ -5,7 +5,7 @@ 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_clause: function (print) {
-        return print.spaced(["updateKw", "hints", "orAction", "tables"]);
+        return print.spaced(["updateKw", "modifiers", "orAction", "tables"]);
     },
     set_clause: function (print, node) {
         if (node.assignments.items.length > 1) {

package/dist/syntax/view.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "Prettier plugin for SQL",
   "author": "Rene Saarsoo <nene@triin.net>",
   "license": "GPL-3.0-or-later",
@@ -22,7 +22,8 @@
     "clean": "rm -rf dist",
     "build": "yarn clean && tsc",
     "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
-    "pretty": "prettier -w src/"
+    "pretty": "prettier -w src/ test/",
+    "ts:check": "tsc --noEmit"
   },
   "keywords": [
     "prettier",
@@ -31,7 +32,7 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.19.0"
+    "sql-parser-cst": "^0.21.1"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",

package/dist/syntax/bigquery.d.ts

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