prettier-plugin-sql-cst 0.18.0 → 0.19.1

package/dist/syntax/select.js

@@ -1,293 +1,224 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectMap = void 0;
-var utils_1 = require("../utils");
-var print_utils_1 = require("../print_utils");
-exports.selectMap = {
-    compound_select_stmt: function (print) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, [print("left"), print.spaced("operator"), print("right")]));
-    },
-    select_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
+import { isDefined } from "../utils";
+import { join, line, hardline, indent, group, containsNewline, breakParent, } from "../print_utils";
+export const selectMap = {
+    compound_select_stmt: (print) => group(join(hardline, [print("left"), print.spaced("operator"), print("right")])),
+    select_stmt: (print) => group(join(print.dynamicLine(), 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, node) { return [
+    with_clause: (print) => group([
+        print.spaced(["withKw", "recursiveKw"]),
+        indent([line, print("tables")]),
+    ]),
+    common_table_expr: (print, node) => [
         print(["table", "columns"]),
         " ",
         print.spaced(["asKw", "materializedKw", "expr"]),
-        (0, print_utils_1.group)([
+        group([
             node.search || node.cycle
-                ? (0, print_utils_1.indent)([print_utils_1.line, print.separated(print_utils_1.line, ["search", "cycle"])])
+                ? indent([line, print.separated(line, ["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"]),
-        ]);
-    },
+    ],
+    cte_search_clause: (print) => group(join(line, [
+        [print.spaced("searchKw"), group(indent([line, print("columns")]))],
+        print.spaced(["setKw", "resultColumn"]),
+    ])),
+    cte_cycle_clause: (print, node) => group(join(line, [
+        [print("cycleKw"), group(indent([line, print("columns")]))],
+        print.spaced(["setKw", "resultColumn"]),
+        node.values ? print("values") : undefined,
+        print.spaced(["usingKw", "pathColumn"]),
+    ].filter(isDefined))),
+    cte_cycle_clause_values: (print) => join(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", "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"]); },
+    select_clause: (print, node, path, opts) => group([
+        print.spaced(["selectKw", "modifiers"]),
+        node.columns ? indent([line, print("columns")]) : [],
+        containsNewline(node, opts) ? breakParent : [],
+    ]),
+    select_all: (print) => print.spaced(["allKw"]),
+    select_distinct: (print) => print.spaced(["distinctKw"]),
+    select_distinct_on: (print) => group([print.spaced(["distinctOnKw", "columns"])]),
+    select_as_struct: (print) => print.spaced(["asStructKw"]),
+    select_as_value: (print) => print.spaced(["asValueKw"]),
+    except_columns: (print) => print.spaced(["expr", "exceptKw", "columns"]),
+    replace_columns: (print) => 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")])]);
-    },
-    join_expr: function (print, node) {
+    from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
+    join_expr: (print, node) => {
         if (node.operator === ",") {
-            return (0, print_utils_1.join)([",", print_utils_1.hardline], print(["left", "right"]));
+            return join([",", hardline], print(["left", "right"]));
         }
         else {
             return [
                 print("left"),
-                print_utils_1.hardline,
-                (0, print_utils_1.group)((0, print_utils_1.join)(" ", [
+                hardline,
+                group(join(" ", [
                     print.spaced("operator"),
                     [
                         print("right"),
                         node.specification
-                            ? (0, print_utils_1.indent)([print_utils_1.line, print(["specification"])])
+                            ? indent([line, print(["specification"])])
                             : [],
                     ],
                 ])),
             ];
         }
     },
-    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"]); },
-    unnest_with_offset_expr: function (print) { return print.spaced(["unnest", "withOffsetKw"]); },
-    pivot_expr: function (print) { return [print("left"), print_utils_1.hardline, print(["pivotKw", "args"])]; },
-    pivot_for_in: function (print) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, [
-            (0, print_utils_1.group)(print("aggregations")),
-            print.spaced(["forKw", "inputColumn"]),
-            print.spaced(["inKw", "pivotColumns"]),
-        ]));
-    },
-    unpivot_expr: function (print, node) { return [
+    join_on_specification: (print) => group(print.spaced(["onKw", "expr"])),
+    join_using_specification: (print) => group(print.spaced(["usingKw", "expr"])),
+    table_with_inheritance: (print) => [print("table"), " ", "*"],
+    table_without_inheritance: (print) => print.spaced(["onlyKw", "table"]),
+    indexed_table: (print) => print.spaced(["table", "indexedByKw", "index"]),
+    not_indexed_table: (print) => print.spaced(["table", "notIndexedKw"]),
+    unnest_expr: (print) => print(["unnestKw", "expr"]),
+    unnest_with_offset_expr: (print) => print.spaced(["unnest", "withOffsetKw"]),
+    pivot_expr: (print) => [print("left"), hardline, print(["pivotKw", "args"])],
+    pivot_for_in: (print) => group(join(line, [
+        group(print("aggregations")),
+        print.spaced(["forKw", "inputColumn"]),
+        print.spaced(["inKw", "pivotColumns"]),
+    ])),
+    unpivot_expr: (print, node) => [
         print("left"),
-        print_utils_1.hardline,
+        hardline,
         (node.nullHandlingKw ? print.spaced : print)([
             "unpivotKw",
             "nullHandlingKw",
             "args",
         ]),
-    ]; },
-    unpivot_for_in: function (print) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, [
-            print("valuesColumn"),
-            print.spaced(["forKw", "nameColumn"]),
-            print.spaced(["inKw", "unpivotColumns"]),
-        ]));
-    },
-    tablesample_expr: function (print) {
-        return (0, print_utils_1.group)([
-            print("left"),
-            print_utils_1.line,
-            print.spaced(["tablesampleKw", "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"]);
-    },
+    ],
+    unpivot_for_in: (print) => group(join(line, [
+        print("valuesColumn"),
+        print.spaced(["forKw", "nameColumn"]),
+        print.spaced(["inKw", "unpivotColumns"]),
+    ])),
+    tablesample_expr: (print) => group([
+        print("left"),
+        line,
+        print.spaced(["tablesampleKw", "method", "args", "repeatable"]),
+    ]),
+    tablesample_method: (print) => print.spaced(["methodKw"]),
+    tablesample_percent: (print) => print.spaced(["percent", "percentKw"]),
+    tablesample_repeatable: (print) => print.spaced(["repeatableKw", "seed"]),
+    for_system_time_as_of_expr: (print) => group([print("left"), line, print.spaced(["forSystemTimeAsOfKw", "expr"])]),
+    partitioned_table: (print) => print.spaced(["table", "partitionKw", "partitions"]),
+    dual_table: (print) => print("dualKw"),
+    lateral_derived_table: (print) => print.spaced(["lateralKw", "expr"]),
+    rows_from_expr: (print) => print.spaced(["rowsFromKw", "expr"]),
+    with_ordinality_expr: (print) => print.spaced(["expr", "withOrdinalityKw"]),
+    func_call_with_column_definitions: (print) => 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")])]);
-    },
+    where_clause: (print) => group([print("whereKw"), indent([line, print("expr")])]),
     // 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, print.separated(print_utils_1.line, ["specifications", "withRollupKw"])]),
-        ]);
-    },
-    sort_specification: function (print) {
-        return print.spaced(["expr", "direction", "nullHandlingKw"]);
-    },
-    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"]);
-    },
+    order_by_clause: (print, node) => group([
+        print.spaced("orderByKw"),
+        indent([line, print.separated(line, ["specifications", "withRollupKw"])]),
+    ]),
+    sort_specification: (print) => print.spaced(["expr", "direction", "nullHandlingKw"]),
+    sort_direction_asc: (print) => print("ascKw"),
+    sort_direction_desc: (print) => print("descKw"),
+    sort_direction_using_operator: (print) => 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, print.separated(print_utils_1.line, ["columns", "withRollupKw"])]),
-        ]);
-    },
-    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"]);
-    },
-    group_by_all: function (print) { return print(["allKw"]); },
+    group_by_clause: (print, node) => group([
+        print.spaced(["groupByKw", "distinctKw"]),
+        indent([line, print.separated(line, ["columns", "withRollupKw"])]),
+    ]),
+    group_by_rollup: (print) => print(["rollupKw", "columns"]),
+    group_by_cube: (print) => print(["cubeKw", "columns"]),
+    group_by_grouping_sets: (print) => print.spaced(["groupingSetsKw", "columns"]),
+    group_by_all: (print) => print(["allKw"]),
     // 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")]),
-        ]);
-    },
+    partition_by_clause: (print) => group([
+        print.spaced("partitionByKw"),
+        indent([line, print("specifications")]),
+    ]),
     // 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")])]);
-    },
+    having_clause: (print) => group([print("havingKw"), indent([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")])]);
-    },
+    qualify_clause: (print) => group([print("qualifyKw"), indent([line, print("expr")])]),
     // LIMIT clause
     /** cst-ignore: count, offsetKw, offset */
-    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),
-                node.rowsExamined ? [print_utils_1.line, print("rowsExamined")] : [],
-            ]),
-        ]);
-    },
-    limit_all: function (print) { return print("allKw"); },
-    limit_rows_examined: function (print) { return print.spaced(["rowsExaminedKw", "count"]); },
+    limit_clause: (print, node) => group([
+        print("limitKw"),
+        indent([
+            line,
+            printLimitValues(print, node),
+            node.rowsExamined ? [line, print("rowsExamined")] : [],
+        ]),
+    ]),
+    limit_all: (print) => print("allKw"),
+    limit_rows_examined: (print) => 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"])]),
-        ]);
-    },
+    offset_clause: (print) => group([
+        print("offsetKw"),
+        indent([line, print.spaced(["offset", "rowsKw"])]),
+    ]),
     // FETCH clause
-    fetch_clause: function (print) {
-        return print.spaced(["fetchKw", "count", "rowsKw", "withTiesKw"]);
-    },
+    fetch_clause: (print) => 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)([
+    window_clause: (print, node) => {
+        const lineType = node.namedWindows.items.length > 1 ? hardline : line;
+        return group([
             print("windowKw"),
-            (0, print_utils_1.indent)([lineType, print("namedWindows")]),
+            indent([lineType, print("namedWindows")]),
         ]);
     },
-    named_window: function (print) { return print.spaced(["name", "asKw", "window"]); },
-    window_definition: function (print, node) {
-        var itemCount = [
+    named_window: (print) => print.spaced(["name", "asKw", "window"]),
+    window_definition: (print, node) => {
+        const itemCount = [
             node.baseWindowName,
             node.partitionBy,
             node.orderBy,
             node.frame,
-        ].filter(utils_1.isDefined).length;
-        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"])));
+        ].filter(isDefined).length;
+        const lineType = itemCount > 1 ? hardline : line;
+        return group(join(lineType, print(["baseWindowName", "partitionBy", "orderBy", "frame"])));
     },
     // INTO clause
-    into_table_clause: function (print) {
-        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")])]);
-    },
-    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)([
+    into_table_clause: (print) => print.spaced(["intoKw", "kind", "tableKw", "name"]),
+    into_variables_clause: (print) => group([print("intoKw"), indent([line, print("variables")])]),
+    into_dumpfile_clause: (print) => print.spaced(["intoDumpfileKw", "filename"]),
+    into_outfile_clause: (print, node) => {
+        const hasOptions = node.charset || node.fields || node.lines;
+        return 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"])),
+                ? indent([
+                    hardline,
+                    join(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"]); },
+    outfile_fields: (print) => print.spaced(["fieldsKw", "options"]),
+    outfile_lines: (print) => print.spaced(["linesKw", "options"]),
+    outfile_option_character_set: (print) => print.spaced(["characterSetKw", "value"]),
+    outfile_option_starting_by: (print) => print.spaced(["startingByKw", "value"]),
+    outfile_option_terminated_by: (print) => print.spaced(["terminatedByKw", "value"]),
+    outfile_option_enclosed_by: (print) => print.spaced(["optionallyKw", "enclosedByKw", "value"]),
+    outfile_option_escaped_by: (print) => 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 [
+    for_clause: (print, node) => group([
+        print.spaced(["forKw", "lockStrengthKw", "tables"]),
+        node.waitingKw ? indent([line, print.spaced("waitingKw")]) : [],
+    ]),
+    for_clause_tables: (print) => [
         print("ofKw"),
-        (0, print_utils_1.indent)([print_utils_1.line, print("tables")]),
-    ]; },
-    lock_in_share_mode_clause: function (print) { return print.spaced("lockInShareModeKw"); },
+        indent([line, print("tables")]),
+    ],
+    lock_in_share_mode_clause: (print) => print.spaced("lockInShareModeKw"),
     // TABLE clause
-    table_clause: function (print) { return print.spaced(["tableKw", "table"]); },
+    table_clause: (print) => print.spaced(["tableKw", "table"]),
 };
-var printLimitValues = function (print, node) {
+const printLimitValues = (print, node) => {
     if (node.offsetKw) {
         return print.spaced(["count", "offsetKw", "offset"]);
     }
     else if (node.offset) {
-        return (0, print_utils_1.join)([",", " "], print(["offset", "count"]));
+        return join([",", " "], print(["offset", "count"]));
     }
     else {
         return print("count");

package/dist/syntax/sequence.js

@@ -1,53 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sequenceMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.sequenceMap = {
-    create_sequence_stmt: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced(["createKw", "kind", "sequenceKw", "ifNotExistsKw", "name"]),
-            node.options.length > 0
-                ? (0, print_utils_1.indent)([print.dynamicLine(), (0, print_utils_1.join)(print_utils_1.line, print("options"))])
-                : [],
-        ]);
-    },
-    alter_sequence_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced(["alterKw", "sequenceKw", "ifExistsKw", "sequence"]),
-            (0, print_utils_1.indent)([print.dynamicLine(), (0, print_utils_1.join)(print_utils_1.line, print("actions"))]),
-        ]);
-    },
-    drop_sequence_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced([
-            "dropKw",
-            "sequenceKw",
-            "ifExistsKw",
-            "sequences",
-            "behaviorKw",
-        ]));
-    },
-    sequence_option_sequence_name: function (print) {
-        return print.spaced(["sequenceNameKw", "name"]);
-    },
-    sequence_option_logged: function (print) { return print.spaced("loggedKw"); },
-    sequence_option_unlogged: function (print) { return print.spaced("unloggedKw"); },
-    sequence_option_as_type: function (print) { return print.spaced(["asKw", "dataType"]); },
-    sequence_option_increment: function (print) {
-        return print.spaced(["incrementKw", "byKw", "value"]);
-    },
-    sequence_option_minvalue: function (print) { return print.spaced(["minvalueKw", "value"]); },
-    sequence_option_maxvalue: function (print) { return print.spaced(["maxvalueKw", "value"]); },
-    sequence_option_no_minvalue: function (print) { return print.spaced("noMinvalueKw"); },
-    sequence_option_no_maxvalue: function (print) { return print.spaced("noMaxvalueKw"); },
-    sequence_option_start: function (print) {
-        return print.spaced(["startKw", "withKw", "value"]);
-    },
-    sequence_option_restart: function (print) {
-        return print.spaced(["restartKw", "withKw", "value"]);
-    },
-    sequence_option_cache: function (print) { return print.spaced(["cacheKw", "value"]); },
-    sequence_option_cycle: function (print) { return print.spaced("cycleKw"); },
-    sequence_option_no_cycle: function (print) { return print.spaced("noCycleKw"); },
-    sequence_option_owned_by: function (print) { return print.spaced(["ownedByKw", "owner"]); },
-    sequence_option_list: function (print) { return (0, print_utils_1.join)(print_utils_1.line, print("options")); },
+import { group, indent, join, line } from "../print_utils";
+export const sequenceMap = {
+    create_sequence_stmt: (print, node) => group([
+        print.spaced(["createKw", "kind", "sequenceKw", "ifNotExistsKw", "name"]),
+        node.options.length > 0
+            ? indent([print.dynamicLine(), join(line, print("options"))])
+            : [],
+    ]),
+    alter_sequence_stmt: (print) => group([
+        print.spaced(["alterKw", "sequenceKw", "ifExistsKw", "sequence"]),
+        indent([print.dynamicLine(), join(line, print("actions"))]),
+    ]),
+    drop_sequence_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "sequenceKw",
+        "ifExistsKw",
+        "sequences",
+        "behaviorKw",
+    ])),
+    sequence_option_sequence_name: (print) => print.spaced(["sequenceNameKw", "name"]),
+    sequence_option_logged: (print) => print.spaced("loggedKw"),
+    sequence_option_unlogged: (print) => print.spaced("unloggedKw"),
+    sequence_option_as_type: (print) => print.spaced(["asKw", "dataType"]),
+    sequence_option_increment: (print) => print.spaced(["incrementKw", "byKw", "value"]),
+    sequence_option_minvalue: (print) => print.spaced(["minvalueKw", "value"]),
+    sequence_option_maxvalue: (print) => print.spaced(["maxvalueKw", "value"]),
+    sequence_option_no_minvalue: (print) => print.spaced("noMinvalueKw"),
+    sequence_option_no_maxvalue: (print) => print.spaced("noMaxvalueKw"),
+    sequence_option_start: (print) => print.spaced(["startKw", "withKw", "value"]),
+    sequence_option_restart: (print) => print.spaced(["restartKw", "withKw", "value"]),
+    sequence_option_cache: (print) => print.spaced(["cacheKw", "value"]),
+    sequence_option_cycle: (print) => print.spaced("cycleKw"),
+    sequence_option_no_cycle: (print) => print.spaced("noCycleKw"),
+    sequence_option_owned_by: (print) => print.spaced(["ownedByKw", "owner"]),
+    sequence_option_list: (print) => join(line, print("options")),
 };

package/dist/syntax/subscription.js

@@ -1,25 +1,10 @@
-"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.subscriptionMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.subscriptionMap = {
-    create_subscription_stmt: function (print, node) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, __spreadArray([
-            print.spaced(["createSubscriptionKw", "name"]),
-            print.spaced(["connectionKw", "connectionInfo"]),
-            print.spaced(["publicationKw", "publications"])
-        ], (node.with ? [print.spaced(["with"])] : []), true)));
-    },
-    drop_subscription_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["dropSubscriptionKw", "ifExistsKw", "name", "behaviorKw"]));
-    },
+import { group, line, join } from "../print_utils";
+export const subscriptionMap = {
+    create_subscription_stmt: (print, node) => group(join(line, [
+        print.spaced(["createSubscriptionKw", "name"]),
+        print.spaced(["connectionKw", "connectionInfo"]),
+        print.spaced(["publicationKw", "publications"]),
+        ...(node.with ? [print.spaced(["with"])] : []),
+    ])),
+    drop_subscription_stmt: (print) => group(print.spaced(["dropSubscriptionKw", "ifExistsKw", "name", "behaviorKw"])),
 };