prettier-plugin-sql-cst 0.17.4 → 0.19.0

package/dist/src/syntax/extension.js

@@ -0,0 +1,13 @@
+import { group, indent, line } from "../print_utils";
+export const extensionMap = {
+    create_extension_stmt: (print, node) => group([
+        print.spaced(["createExtensionKw", "ifNotExistsKw", "name"]),
+        node.clauses.length > 0
+            ? indent([line, print.spaced(["withKw", "clauses"])])
+            : [],
+    ]),
+    extension_cascade_clause: (print) => group(print.spaced(["cascadeKw"])),
+    extension_schema_clause: (print) => group(print.spaced(["schemaKw", "name"])),
+    extension_version_clause: (print) => group(print.spaced(["versionKw", "name"])),
+    drop_extension_stmt: (print) => group(print.spaced(["dropExtensionKw", "ifExistsKw", "names", "behaviorKw"])),
+};

package/dist/src/syntax/frame.js

@@ -0,0 +1,13 @@
+import { hardline } from "../print_utils";
+export const frameMap = {
+    frame_clause: (print, node) => [
+        print.spaced(["unitKw", "extent"]),
+        node.exclusion ? [hardline, print("exclusion")] : [],
+    ],
+    frame_bound_current_row: (print) => print.spaced("currentRowKw"),
+    frame_bound_preceding: (print) => print.spaced(["expr", "precedingKw"]),
+    frame_bound_following: (print) => print.spaced(["expr", "followingKw"]),
+    frame_unbounded: (print) => print.spaced("unboundedKw"),
+    frame_between: (print) => print.spaced(["betweenKw", "begin", "andKw", "end"]),
+    frame_exclusion: (print) => print.spaced(["excludeKw", "kindKw"]),
+};

package/dist/src/syntax/function.js

@@ -0,0 +1,55 @@
+import { group, hardline, join } from "../print_utils";
+import { isAsClause } from "../node_utils";
+export const functionMap = {
+    create_function_stmt: (print, node) => group([
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "temporaryKw",
+            "tableKw",
+            "functionKw",
+            "ifNotExistsKw",
+            "name",
+        ]),
+        print("params"),
+        hasOnlyAsClause(node)
+            ? [" ", group(print("clauses"))]
+            : [
+                hardline,
+                join(hardline, print("clauses").map((cls) => group(cls))),
+            ],
+    ]),
+    function_signature: (print) => print(["name", "params"]),
+    function_param: (print) => print.spaced(["mode", "name", "dataType", "default"]),
+    function_param_default: (print) => print.spaced(["operator", "expr"]),
+    return_clause: (print) => print.spaced(["returnKw", "expr"]),
+    function_behavior_clause: (print) => print.spaced(["behaviorKw"]),
+    function_security_clause: (print) => print.spaced(["externalKw", "securityKw"]),
+    function_cost_clause: (print) => print.spaced(["costKw", "cost"]),
+    function_rows_clause: (print) => print.spaced(["rowsKw", "rows"]),
+    function_support_clause: (print) => print.spaced(["supportKw", "name"]),
+    function_window_clause: (print) => print.spaced("windowKw"),
+    function_transform_clause: (print) => print.spaced(["transformKw", "types"]),
+    transform_type: (print) => print.spaced(["forTypeKw", "dataType"]),
+    dynamically_loaded_function: (print) => join(", ", print(["objectFile", "symbol"])),
+    drop_function_stmt: (print) => group([
+        print.spaced([
+            "dropKw",
+            "tableKw",
+            "functionKw",
+            "ifExistsKw",
+            "signatures",
+            "behaviorKw",
+        ]),
+    ]),
+    // almost exact copy of alter_procedure_stmt
+    alter_function_stmt: (print, node) => group([
+        print.spaced(["alterKw", "functionKw"]),
+        " ",
+        print(["signature"]),
+        print.dynamicLine(),
+        join(print.dynamicLine(), print("actions")),
+        node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : [],
+    ]),
+};
+export const hasOnlyAsClause = (node) => node.clauses.length === 1 && isAsClause(node.clauses[0]);

package/dist/src/syntax/index.js

@@ -0,0 +1,60 @@
+import { group, join } from "../print_utils";
+export const indexMap = {
+    create_index_stmt: (print) => group(join(print.dynamicLine(), [
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "indexTypeKw",
+            "indexKw",
+            "concurrentlyKw",
+            "ifNotExistsKw",
+            "name",
+            "onKw",
+            "table",
+            "using",
+            "columns",
+        ]),
+        ...print("clauses"),
+    ])),
+    index_specification: (print) => print.spaced(["expr", "opclass", "direction", "nullHandlingKw"]),
+    index_include_clause: (print) => print.spaced(["includeKw", "columns"]),
+    index_nulls_distinct_clause: (print) => print.spaced(["nullsDistinctKw"]),
+    index_nulls_not_distinct_clause: (print) => print.spaced(["nullsNotDistinctKw"]),
+    drop_index_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "indexTypeKw",
+        "indexKw",
+        "concurrentlyKw",
+        "ifExistsKw",
+        "indexes",
+        "onKw",
+        "table",
+        "behaviorKw",
+    ])),
+    verbose_all_columns: (print) => print.spaced("allColumnsKw"),
+    alter_index_stmt: (print) => group([
+        print.spaced(["alterKw", "indexKw", "ifExistsKw", "index"]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    alter_index_all_in_tablespace_stmt: (print) => group([
+        print.spaced([
+            "alterIndexKw",
+            "allInTablespaceKw",
+            "tablespace",
+            "ownedBy",
+        ]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    reindex_stmt: (print) => group(print.spaced([
+        "reindexKw",
+        "options",
+        "targetKw",
+        "concurrentlyKw",
+        "name",
+    ])),
+    reindex_option_concurrently: (print) => print.spaced(["concurrentlyKw", "value"]),
+    reindex_option_tablespace: (print) => print.spaced(["tablespaceKw", "name"]),
+    reindex_option_verbose: (print) => print.spaced(["verboseKw", "value"]),
+};

package/dist/src/syntax/insert.js

@@ -0,0 +1,33 @@
+import { join, group, indent } from "../print_utils";
+export const insertMap = {
+    insert_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+    insert_clause: (print, node) => group([
+        print.spaced(["insertKw", "modifiers", "orAction", "intoKw", "table"]),
+        node.columns ? indent([print.dynamicLine(), print("columns")]) : [],
+    ]),
+    values_clause: (print) => group([print("valuesKw"), indent([print.dynamicLine(), print("values")])]),
+    or_alternate_action: (print) => print.spaced(["orKw", "actionKw"]),
+    default: (print) => print("defaultKw"),
+    default_values: (print) => print.spaced("defaultValuesKw"),
+    upsert_clause: (print) => print.spaced(["onConflictKw", "conflictTarget", "where", "doKw", "action"]),
+    conflict_target_on_constraint: (print) => print.spaced(["onConstraintKw", "constraint"]),
+    upsert_action_nothing: (print) => print("nothingKw"),
+    upsert_action_update: (print) => group([
+        print("updateKw"),
+        indent([
+            print.dynamicLine(),
+            join(print.dynamicLine(), print(["set", "where"])),
+        ]),
+    ]),
+    row_alias_clause: (print, node) => group([
+        print.spaced(["asKw", "rowAlias"]),
+        node.columnAliases
+            ? indent([print.dynamicLine(), print("columnAliases")])
+            : [],
+    ]),
+    on_duplicate_key_update_clause: (print) => group([
+        print.spaced("onDuplicateKeyUpdateKw"),
+        indent([print.dynamicLine(), print("assignments")]),
+    ]),
+    overriding_clause: (print) => print.spaced("overridingKw"),
+};

package/dist/src/syntax/merge.js

@@ -0,0 +1,30 @@
+import { group, hardline, indent, join, line } from "../print_utils";
+export const mergeMap = {
+    merge_stmt: (print) => group(join(hardline, print("clauses"))),
+    merge_clause: (print) => join(line, [
+        print.spaced(["mergeKw", "intoKw", "target"]),
+        print.spaced(["usingKw", "source"]),
+        group([print("onKw"), indent([line, print("condition")])]),
+    ]),
+    merge_when_clause: (print, node) => [
+        group([
+            print.spaced(["whenKw", "matchedKw", "byKw"]),
+            node.condition ? indent([line, print("condition")]) : [],
+            [line, print("thenKw")],
+        ]),
+        indent([hardline, group(print("action"))]),
+    ],
+    merge_when_condition: (print) => print.spaced(["andKw", "expr"]),
+    merge_action_delete: (print) => print("deleteKw"),
+    merge_action_insert: (print, node) => [
+        group([
+            print("insertKw"),
+            node.columns ? indent([hardline, print("columns")]) : [],
+        ]),
+        line,
+        join(hardline, print("clauses")),
+    ],
+    merge_action_insert_row_clause: (print) => print("rowKw"),
+    merge_action_update: (print) => print.spaced(["updateKw", "set"]),
+    merge_action_do_nothing: (print) => print.spaced(["doNothingKw"]),
+};

package/dist/src/syntax/other_clauses.js

@@ -0,0 +1,9 @@
+import { line, indent, group } from "../print_utils";
+export const otherClausesMap = {
+    // CLUSTER BY clause
+    cluster_by_clause: (print) => group([print.spaced("clusterByKw"), indent([line, print("columns")])]),
+    // RETURNING clause
+    returning_clause: (print) => group([print("returningKw"), indent([line, print("columns")])]),
+    // WHERE CURRENT OF clause
+    where_current_of_clause: (print) => print.spaced(["whereCurrentOfKw", "cursor"]),
+};

package/dist/src/syntax/parameter.js

@@ -0,0 +1,18 @@
+import { printLiteral } from "./expr";
+import { group } from "../print_utils";
+export const parameterMap = {
+    // SET
+    set_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "name", "operator", "value"])),
+    set_time_zone_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"])),
+    set_parameter_clause: (print) => print.spaced(["setKw", "name", "operator", "value"]),
+    local_parameter_value: (print) => print("localKw"),
+    set_parameter_from_current_clause: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
+    // RESET
+    reset_parameter_stmt: (print) => group(print.spaced(["resetKw", "name"])),
+    reset_parameter_clause: (print) => print.spaced(["resetKw", "name"]),
+    all_parameters: (print) => print("allKw"),
+    // SHOW
+    show_parameter_stmt: (print) => group(print.spaced(["showKw", "name"])),
+    /** cst-ignore: value */
+    boolean_on_off_literal: (print, node, path, options) => printLiteral(node.valueKw, options),
+};

package/dist/src/syntax/policy.js

@@ -0,0 +1,27 @@
+import { group, join } from "../print_utils";
+export const policyMap = {
+    create_policy_stmt: (print, node) => group([
+        print.spaced(["createPolicyKw", "name", "onKw", "table"]),
+        node.clauses.length > 0 ? print.dynamicLine() : [],
+        join(print.dynamicLine(), print("clauses")),
+    ]),
+    policy_permissive_clause: (print) => group(print.spaced(["asKw", "permissiveKw"])),
+    policy_restrictive_clause: (print) => group(print.spaced(["asKw", "restrictiveKw"])),
+    policy_command_clause: (print) => group(print.spaced(["forKw", "commandKw"])),
+    policy_roles_clause: (print) => group(print.spaced(["toKw", "roles"])),
+    policy_using_clause: (print) => group(print.spaced(["usingKw", "expr"])),
+    policy_check_clause: (print) => group(print.spaced(["withKw", "checkKw", "expr"])),
+    alter_policy_stmt: (print) => group([
+        print.spaced(["alterPolicyKw", "name", "onKw", "table"]),
+        print.dynamicLine(),
+        join(print.dynamicLine(), print("actions")),
+    ]),
+    drop_policy_stmt: (print) => group(print.spaced([
+        "dropPolicyKw",
+        "ifExistsKw",
+        "name",
+        "onKw",
+        "table",
+        "behaviorKw",
+    ])),
+};

package/dist/src/syntax/prepared_statements.js

@@ -0,0 +1,31 @@
+import { group, hardline, indent, join, line } from "../print_utils";
+export const preparedStatementsMap = {
+    // EXECUTE
+    execute_stmt: (print, node) => {
+        if (node.args?.type === "execute_using_clause") {
+            return group(print.spaced(["executeKw", "name", "args"]));
+        }
+        else {
+            return group([print.spaced(["executeKw", "name"]), print("args")]);
+        }
+    },
+    execute_immediate_stmt: (print) => group(join(hardline, [
+        group([
+            print.spaced(["executeKw", "immediateKw"]),
+            indent([line, print("expr")]),
+        ]),
+        ...print(["into", "using"]).map((clause) => group(clause)),
+    ])),
+    execute_into_clause: (print) => print.spaced(["intoKw", "variables"]),
+    execute_using_clause: (print) => group([print("usingKw"), indent([line, print("values")])]),
+    // PREPARE
+    prepare_stmt: (print) => group(join(" ", [
+        print("prepareKw"),
+        print(["name", "params"]),
+        print("source"),
+    ])),
+    prepare_from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
+    // DEALLOCATE
+    deallocate_stmt: (print) => group(print.spaced(["deallocateKw", "name"])),
+    deallocate_all: (print) => print("allKw"),
+};

package/dist/src/syntax/proc_clause.js

@@ -0,0 +1,14 @@
+import { isDynamicallyLoadedFunction, isStringLiteral } from "../node_utils";
+import { hardline, indent } from "../print_utils";
+export const procClauseMap = {
+    returns_clause: (print) => print.spaced(["returnsKw", "dataType"]),
+    determinism_clause: (print) => print.spaced("deterministicKw"),
+    language_clause: (print) => print.spaced(["languageKw", "name"]),
+    as_clause: (print, node) => {
+        if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
+            return print.spaced(["asKw", "expr"]);
+        }
+        return [print("asKw"), indent([hardline, print("expr")])];
+    },
+    with_connection_clause: (print) => print.spaced(["withConnectionKw", "connection"]),
+};

package/dist/src/syntax/procedural_language.js

@@ -0,0 +1,104 @@
+import { group, hardline, indent, join, line, stripTrailingHardline, } from "../print_utils";
+export const proceduralLanguageMap = {
+    // BEGIN .. END
+    block_stmt: (print, node) => group([
+        print.spaced(["beginKw", "atomicKw"]),
+        indent([hardline, stripTrailingHardline(print("program"))]),
+        node.exception ? [hardline, print("exception")] : [],
+        hardline,
+        print("endKw"),
+    ]),
+    exception_clause: (print) => group([
+        print.spaced(["exceptionKw", "whenKw", "condition", "thenKw"]),
+        indent([hardline, stripTrailingHardline(print("program"))]),
+    ]),
+    error_category: (print) => print("errorKw"),
+    // DECLARE
+    declare_stmt: (print) => group(join(" ", [
+        print("declareKw"),
+        group(print("names")),
+        ...print.spaced(["dataType", "default"]),
+    ])),
+    declare_default: (print) => print.spaced(["defaultKw", "expr"]),
+    // SET
+    set_stmt: (print) => group(print.spaced(["setKw", "assignments"])),
+    // IF
+    if_stmt: (print) => group(join(hardline, [...print("clauses"), print.spaced("endIfKw")])),
+    if_clause: (print) => [
+        group([
+            print("ifKw"),
+            indent([line, print("condition")]),
+            line,
+            print("thenKw"),
+        ]),
+        indent([hardline, stripTrailingHardline(print("consequent"))]),
+    ],
+    elseif_clause: (print) => [
+        group([
+            print("elseifKw"),
+            indent([line, print("condition")]),
+            line,
+            print("thenKw"),
+        ]),
+        indent([hardline, stripTrailingHardline(print("consequent"))]),
+    ],
+    else_clause: (print) => [
+        print("elseKw"),
+        indent([hardline, stripTrailingHardline(print("consequent"))]),
+    ],
+    // CASE
+    case_stmt: (print) => group([
+        print.spaced(["caseKw", "expr"]),
+        indent([hardline, join(hardline, print("clauses"))]),
+        hardline,
+        print.spaced("endCaseKw"),
+    ]),
+    // LOOP
+    loop_stmt: (print) => group([
+        print("loopKw"),
+        indent([hardline, stripTrailingHardline(print("body"))]),
+        hardline,
+        print.spaced("endLoopKw"),
+    ]),
+    // REPEAT
+    repeat_stmt: (print) => group([
+        print("repeatKw"),
+        indent([hardline, stripTrailingHardline(print("body"))]),
+        hardline,
+        print.spaced(["untilKw", "condition", "endRepeatKw"]),
+    ]),
+    // WHILE
+    while_stmt: (print) => group([
+        print.spaced(["whileKw", "condition", "doKw"]),
+        indent([hardline, stripTrailingHardline(print("body"))]),
+        hardline,
+        print.spaced("endWhileKw"),
+    ]),
+    // FOR .. IN
+    for_stmt: (print) => group([
+        print.spaced(["forKw", "left", "inKw", "right", "doKw"]),
+        indent([hardline, stripTrailingHardline(print("body"))]),
+        hardline,
+        print.spaced("endForKw"),
+    ]),
+    // BREAK/CONTINUE
+    break_stmt: (print) => group(print.spaced(["breakKw", "label"])),
+    continue_stmt: (print) => group(print.spaced(["continueKw", "label"])),
+    labeled_stmt: (print, node) => group([
+        print("beginLabel"),
+        ": ",
+        print("statement"),
+        node.endLabel ? [" ", print(["endLabel"])] : [],
+    ]),
+    // CALL
+    call_stmt: (print) => group(print.spaced(["callKw", "func"])),
+    // RETURN
+    return_stmt: (print) => group(print.spaced(["returnKw", "expr"])),
+    // RAISE
+    raise_stmt: (print) => group(print.spaced(["raiseKw", "message"])),
+    raise_message: (print) => [
+        print.spaced("usingMessageKw"),
+        " = ",
+        print("string"),
+    ],
+};

package/dist/src/syntax/procedure.js

@@ -0,0 +1,38 @@
+import { group, hardline, join } from "../print_utils";
+import { hasOnlyAsClause } from "./function";
+export const procedureMap = {
+    create_procedure_stmt: (print, node) => group([
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "procedureKw",
+            "ifNotExistsKw",
+            "name",
+        ]),
+        print("params"),
+        hasOnlyAsClause(node)
+            ? [" ", group(print("clauses"))]
+            : [
+                hardline,
+                join(hardline, print("clauses").map((clause) => group(clause))),
+            ],
+    ]),
+    drop_procedure_stmt: (print) => group([
+        print.spaced([
+            "dropKw",
+            "procedureKw",
+            "ifExistsKw",
+            "signatures",
+            "behaviorKw",
+        ]),
+    ]),
+    // almost exact copy of alter_function_stmt
+    alter_procedure_stmt: (print, node) => group([
+        print.spaced(["alterKw", "procedureKw"]),
+        " ",
+        print(["signature"]),
+        print.dynamicLine(),
+        join(print.dynamicLine(), print("actions")),
+        node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : [],
+    ]),
+};

package/dist/src/syntax/program.js

@@ -0,0 +1,39 @@
+import { hardline, hasEmptyLineBetweenNodes } from "../print_utils";
+export const programMap = {
+    program: (print, node, path, options) => print("statements").map((doc, i) => i === node.statements.length - 1
+        ? printFinalStatement(doc, i, node.statements, options)
+        : printStatement(doc, i, node.statements, options)),
+};
+const printStatement = (doc, i, statements, options) => {
+    const prevNode = statements[i - 1];
+    const node = statements[i];
+    if (i === 0) {
+        return doc;
+    }
+    else if (node.type !== "empty") {
+        if (hasEmptyLineBetweenNodes(prevNode, node, options)) {
+            return [";", hardline, hardline, doc];
+        }
+        else {
+            return [";", hardline, doc];
+        }
+    }
+    else {
+        return [";", hardline, doc];
+    }
+};
+const printFinalStatement = (doc, i, statements, options) => {
+    const stmtDoc = printStatement(doc, i, statements, options);
+    if (statements[i].type === "empty") {
+        // When the final statement is an empty statement,
+        // this means we have inserted a semicolon and newline before it.
+        // So nothing else is needed.
+        return stmtDoc;
+    }
+    else {
+        // If the last statement is not empty,
+        // this means sqlFinalSemicolon option is false,
+        // so we need to add an empty line after it.
+        return [stmtDoc, hardline];
+    }
+};

package/dist/src/syntax/publication.js

@@ -0,0 +1,27 @@
+import { group, indent, line } from "../print_utils";
+export const publicationMap = {
+    create_publication_stmt: (print, node) => group([
+        print.spaced(["createPublicationKw", "name"]),
+        print("clauses").map((printedClause, i) => {
+            if (node.clauses[i].type === "for_publication_objects_clause") {
+                return [" ", printedClause];
+            }
+            else {
+                return [line, printedClause];
+            }
+        }),
+    ]),
+    for_publication_objects_clause: (print) => group([print("forKw"), indent([line, print("publicationObjects")])]),
+    all_publication_object: (print) => group(print.spaced(["allKw", "typesKw"])),
+    publication_object_table: (print) => group(print.spaced(["tableKw", "table", "columns", "where"])),
+    publication_object_tables_in_schema: (print) => group(print.spaced(["tablesInSchemaKw", "schema"])),
+    alter_publication_stmt: (print) => group([
+        print.spaced(["alterPublicationKw", "name"]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    alter_action_add_publication_objects: (print) => group([print("addKw"), indent([line, print("publicationObjects")])]),
+    alter_action_set_publication_objects: (print) => group([print("setKw"), indent([line, print("publicationObjects")])]),
+    alter_action_drop_publication_objects: (print) => group([print("dropKw"), indent([line, print("publicationObjects")])]),
+    drop_publication_stmt: (print) => group(print.spaced(["dropPublicationKw", "ifExistsKw", "names", "behaviorKw"])),
+};

package/dist/src/syntax/rename_table.js

@@ -0,0 +1,8 @@
+import { group, indent, line } from "../print_utils";
+export const renameTableMap = {
+    rename_table_stmt: (print) => group([
+        print.spaced(["renameKw", "tableKw"]),
+        indent([line, print("actions")]),
+    ]),
+    rename_action: (print) => print.spaced(["from", "toKw", "to"]),
+};

package/dist/src/syntax/role.js

@@ -0,0 +1,31 @@
+import { group, indent, join, line } from "../print_utils";
+export const roleMap = {
+    create_role_stmt: (print, node) => group([
+        print.spaced(["createRoleKw", "name", "withKw"]),
+        ...(node.options?.length
+            ? [indent([line, join(print.dynamicLine(), print("options"))])]
+            : []),
+    ]),
+    alter_role_stmt: (print, node) => group([
+        join(print.dynamicLine(), [
+            group([print.spaced("alterRoleKw"), indent([line, print("name")])]),
+            ...(node.database ? print(["database"]) : []),
+        ]),
+        node.action.type === "alter_action_with_role_options" &&
+            !node.action.withKw
+            ? indent([print.dynamicLine(), print("action")])
+            : [print.dynamicLine(), print("action")],
+    ]),
+    drop_role_stmt: (print) => group(print.spaced(["dropRoleKw", "ifExistsKw", "names"])),
+    set_role_stmt: (print) => group(print.spaced(["setKw", "scopeKw", "roleKw", "name"])),
+    reset_role_stmt: (print) => group(print.spaced("resetRoleKw")),
+    role_option_keyword: (print) => print("kw"),
+    role_option_connection_limit: (print) => group(print.spaced(["connectionLimitKw", "limit"])),
+    role_option_password: (print) => group(print.spaced(["encryptedKw", "passwordKw", "password"])),
+    role_option_valid_until: (print) => group(print.spaced(["validUntilKw", "timestamp"])),
+    role_option_in_role: (print) => group(print.spaced(["inRoleKw", "names"])),
+    role_option_role: (print) => group(print.spaced(["roleKw", "names"])),
+    role_option_admin: (print) => group(print.spaced(["adminKw", "names"])),
+    role_option_sysid: (print) => group(print.spaced(["sysIdKw", "sysId"])),
+    in_database_clause: (print) => group(print.spaced(["inDatabaseKw", "name"])),
+};

package/dist/src/syntax/schema.js

@@ -0,0 +1,18 @@
+import { group, hardline, indent, join } from "../print_utils";
+export const schemaMap = {
+    create_schema_stmt: (print, node) => group([
+        group(join(print.dynamicLine(), [
+            print.spaced(["createSchemaKw", "ifNotExistsKw", "name"]),
+            ...print("clauses"),
+        ])),
+        node.statements.length > 0
+            ? indent([hardline, join(hardline, print("statements"))])
+            : [],
+    ]),
+    create_schema_authorization_clause: (print) => print.spaced(["authorizationKw", "role"]),
+    drop_schema_stmt: (print) => group(print.spaced(["dropSchemaKw", "ifExistsKw", "schemas", "behaviorKw"])),
+    alter_schema_stmt: (print) => group(join(print.dynamicLine(), [
+        print.spaced(["alterSchemaKw", "ifExistsKw", "name"]),
+        ...print("actions"),
+    ])),
+};