prettier-plugin-sql-cst 0.19.1 → 0.19.3

package/dist/syntax/alter_action.js

@@ -1,120 +0,0 @@
-import { group, indent, join, line } from "../print_utils";
-import { printUnnamedConstraint } from "./constraint";
-export const alterActionMap = {
-    alter_action_rename: (print) => print.spaced(["renameKw", "newName"]),
-    alter_action_rename_column: (print) => print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]),
-    alter_action_add_column: (print) => print.spaced(["addKw", "ifNotExistsKw", "column"]),
-    alter_action_drop_column: (print) => print.spaced(["dropKw", "ifExistsKw", "column", "behaviorKw"]),
-    alter_action_set_bigquery_options: (print) => print.spaced(["setKw", "options"]),
-    alter_action_set_default_collate: (print) => print.spaced(["setDefaultCollateKw", "collation"]),
-    /** cst-ignore: constraint, modifiers */
-    alter_action_add_constraint: (print, node) => group([
-        print.spaced(["addKw", "name"]),
-        indent([line, printUnnamedConstraint(print, node)]),
-    ]),
-    alter_action_add_constraint_constraint_name: (print) => print.spaced(["constraintKw", "ifNotExistsKw", "name"]),
-    alter_action_drop_constraint: (print) => print.spaced([
-        "dropConstraintKw",
-        "ifExistsKw",
-        "constraint",
-        "behaviorKw",
-    ]),
-    alter_action_drop_primary_key: (print) => print.spaced(["dropPrimaryKeyKw", "ifExistsKw"]),
-    alter_action_alter_constraint: (print) => print.spaced(["alterConstraintKw", "constraint", "modifiers"]),
-    alter_action_rename_constraint: (print) => print.spaced(["renameConstraintKw", "oldName", "toKw", "newName"]),
-    alter_action_validate_constraint: (print) => print.spaced(["validateConstraintKw", "constraint"]),
-    alter_action_set_visible: (print) => print.spaced("setVisibleKw"),
-    alter_action_set_invisible: (print) => print.spaced("setInvisibleKw"),
-    alter_action_set_tablespace: (print) => print.spaced(["setTablespaceKw", "tablespace", "nowaitKw"]),
-    alter_action_set_schema: (print) => print.spaced(["setSchemaKw", "schema"]),
-    alter_action_enable: (print) => print.spaced(["enableKw", "modeKw", "item"]),
-    alter_action_disable: (print) => print.spaced(["disableKw", "item"]),
-    alter_action_force: (print) => print.spaced(["forceKw", "item"]),
-    alter_action_no_force: (print) => print.spaced(["noForceKw", "item"]),
-    alter_action_cluster_on: (print) => print.spaced(["clusterOnKw", "index"]),
-    alter_action_set_without_cluster: (print) => print.spaced("setWithoutClusterKw"),
-    alter_action_set_without_oids: (print) => print.spaced("setWithoutOidsKw"),
-    alter_action_set_access_method: (print) => print.spaced(["setAccessMethodKw", "method"]),
-    alter_action_set_logged: (print) => print.spaced("setLoggedKw"),
-    alter_action_set_unlogged: (print) => print.spaced("setUnloggedKw"),
-    alter_action_inherit: (print) => print.spaced(["inheritKw", "table"]),
-    alter_action_no_inherit: (print) => print.spaced(["noInheritKw", "table"]),
-    alter_action_of_type: (print) => print.spaced(["ofKw", "typeName"]),
-    alter_action_not_of_type: (print) => print.spaced("notOfKw"),
-    alter_action_owner_to: (print) => print.spaced(["ownerToKw", "owner"]),
-    alter_action_replica_identity: (print) => print.spaced(["replicaIdentityKw", "identity"]),
-    replica_identity_using_index: (print) => print.spaced(["usingIndexKw", "index"]),
-    alter_action_set_postgresql_options: (print) => print.spaced(["setKw", "options"]),
-    alter_action_reset_postgresql_options: (print) => print.spaced(["resetKw", "options"]),
-    alter_action_depends_on_extension: (print) => print.spaced(["dependsOnExtensionKw", "extension"]),
-    alter_action_no_depends_on_extension: (print) => print.spaced(["noDependsOnExtensionKw", "extension"]),
-    alter_action_attach_partition: (print) => print.spaced(["attachPartitionKw", "index"]),
-    alter_action_add_enum_value: (print) => print.spaced(["addValueKw", "ifNotExistsKw", "value", "position"]),
-    alter_action_add_enum_value_position: (print) => print.spaced(["positionKw", "value"]),
-    alter_action_rename_enum_value: (print) => print.spaced(["renameValueKw", "oldValue", "toKw", "newValue"]),
-    alter_action_add_attribute: (print) => print.spaced([
-        "addAttributeKw",
-        "name",
-        "dataType",
-        "constraint",
-        "behaviorKw",
-    ]),
-    alter_action_drop_attribute: (print) => print.spaced(["dropAttributeKw", "ifExistsKw", "name", "behaviorKw"]),
-    alter_action_alter_attribute: (print) => print.spaced([
-        "alterAttributeKw",
-        "name",
-        "setDataTypeKw",
-        "dataType",
-        "constraint",
-        "behaviorKw",
-    ]),
-    alter_action_rename_attribute: (print) => print.spaced([
-        "renameAttributeKw",
-        "oldName",
-        "toKw",
-        "newName",
-        "behaviorKw",
-    ]),
-    // ALTER COLUMN
-    alter_action_alter_column: (print) => group([
-        print.spaced(["alterKw", "ifExistsKw", "column"]),
-        print.dynamicLine(),
-        print("action"),
-    ]),
-    alter_action_set_default: (print) => print.spaced(["setDefaultKw", "expr"]),
-    alter_action_drop_default: (print) => print.spaced("dropDefaultKw"),
-    alter_action_set_not_null: (print) => print.spaced("setNotNullKw"),
-    alter_action_drop_not_null: (print) => print.spaced("dropNotNullKw"),
-    alter_action_set_data_type: (print) => print.spaced(["setDataTypeKw", "dataType", "clauses"]),
-    alter_action_set_statistics: (print) => print.spaced(["setStatisticsKw", "value"]),
-    alter_action_set_compression: (print) => print.spaced(["setCompressionKw", "method"]),
-    alter_action_set_storage: (print) => print.spaced(["setStorageKw", "typeKw"]),
-    alter_action_drop_expression: (print) => print.spaced(["dropExpressionKw", "ifExistsKw"]),
-    alter_action_drop_identity: (print) => print.spaced(["dropIdentityKw", "ifExistsKw"]),
-    alter_action_add_identity: (print) => print.spaced([
-        "addGeneratedKw",
-        "whenKw",
-        "asIdentityKw",
-        "sequenceOptions",
-    ]),
-    alter_action_alter_identity: (print) => group(join(line, print("actions"))),
-    alter_action_set_generated: (print) => print.spaced(["setGeneratedKw", "whenKw"]),
-    alter_action_restart: (print) => print.spaced(["restartKw", "withKw", "value"]),
-    alter_action_set_sequence_option: (print) => print.spaced(["setKw", "option"]),
-    alter_action_with_role_options: (print, node) => node.withKw
-        ? group([print("withKw"), indent([line, join(line, print("options"))])])
-        : // This works in tandem with the logic inside alter_role_stmt
-            group(join(line, print("options"))),
-    alter_action_set_postgresql_option: (print) => print.spaced(["setKw", "name", "operator", "value"]),
-    alter_action_set_postgresql_option_from_current: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
-    alter_action_reset_postgresql_option: (print) => print.spaced(["resetKw", "name"]),
-    alter_action_add_user: (print) => group(print.spaced(["addUserKw", "users"])),
-    alter_action_drop_user: (print) => group(print.spaced(["dropUserKw", "users"])),
-    // ENABLE/DISABLE ..
-    toggle_trigger: (print) => print.spaced(["triggerKw", "name"]),
-    toggle_rule: (print) => print.spaced(["ruleKw", "name"]),
-    toggle_row_level_security: (print) => print.spaced("rowLevelSecurityKw"),
-    // SET DATA TYPE ...
-    set_data_type_collate_clause: (print) => print.spaced(["collateKw", "collation"]),
-    set_data_type_using_clause: (print) => print.spaced(["usingKw", "expr"]),
-};

package/dist/syntax/alter_table.d.ts

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

package/dist/syntax/alter_table.js

@@ -1,19 +0,0 @@
-import { group, indent, line } from "../print_utils";
-export const alterTableMap = {
-    alter_table_stmt: (print) => group([
-        print.spaced(["alterTableKw", "ifExistsKw", "table"]),
-        print.dynamicLine(),
-        print("actions"),
-    ]),
-    alter_table_all_in_tablespace_stmt: (print) => group([
-        print.spaced([
-            "alterTableKw",
-            "allInTablespaceKw",
-            "tablespace",
-            "ownedBy",
-        ]),
-        print.dynamicLine(),
-        print("action"),
-    ]),
-    owned_by_clause: (print) => group([print.spaced("ownedByKw"), indent([line, print("owners")])]),
-};

package/dist/syntax/analyze.d.ts

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

package/dist/syntax/analyze.js

@@ -1,4 +0,0 @@
-import { group } from "../print_utils";
-export const analyzeMap = {
-    analyze_stmt: (print) => group(print.spaced(["analyzeKw", "tableKw", "tables"])),
-};

package/dist/syntax/base.d.ts

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

package/dist/syntax/base.js

@@ -1,19 +0,0 @@
-import { isDataType } from "../node_utils";
-export const baseMap = {
-    /** cst-ignore: name */
-    keyword: (print, node, path, options) => {
-        const keywordCase = isDataType(path.ancestors)
-            ? options.sqlTypeCase
-            : options.sqlKeywordCase;
-        switch (keywordCase) {
-            case "preserve":
-                return path.node.text;
-            case "upper":
-                return path.node.text.toUpperCase();
-            case "lower":
-                return path.node.text.toLowerCase();
-        }
-    },
-    all_columns: () => "*",
-    empty: () => [],
-};

package/dist/syntax/cast.d.ts

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

package/dist/syntax/cast.js

@@ -1,4 +0,0 @@
-import { group } from "../print_utils";
-export const castMap = {
-    cast_definition: (print) => group(print.spaced(["from", "asKw", "to"])),
-};

package/dist/syntax/comment.d.ts

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

package/dist/syntax/comment.js

@@ -1,54 +0,0 @@
-import { group, indent, line } from "../print_utils";
-export const commentMap = {
-    comment_stmt: (print) => group([
-        print.spaced(["commentKw", "onKw", "target", "isKw"]),
-        indent([line, print("message")]),
-    ]),
-    comment_target_aggregate: (print) => group([print.spaced(["aggregateKw", "name"]), print(["params"])]),
-    comment_target_function: (print) => group([print.spaced(["functionKw", "name"]), print(["params"])]),
-    comment_target_procedure: (print) => group([print.spaced(["procedureKw", "name"]), print(["params"])]),
-    comment_target_routine: (print) => group([print.spaced(["routineKw", "name"]), print(["params"])]),
-    comment_target_access_method: (print) => group(print.spaced(["accessMethodKw", "name"])),
-    comment_target_cast: (print) => group(print.spaced(["castKw", "args"])),
-    comment_target_collation: (print) => group(print.spaced(["collationKw", "name"])),
-    comment_target_column: (print) => group(print.spaced(["columnKw", "name"])),
-    comment_target_table_constraint: (print) => group(print.spaced(["constraintKw", "name", "onKw", "tableName"])),
-    comment_target_domain_constraint: (print) => group(print.spaced(["constraintKw", "name", "onKw", "domainKw", "domainName"])),
-    comment_target_conversion: (print) => group(print.spaced(["conversionKw", "name"])),
-    comment_target_database: (print) => group(print.spaced(["databaseKw", "name"])),
-    comment_target_domain: (print) => group(print.spaced(["domainKw", "name"])),
-    comment_target_extension: (print) => group(print.spaced(["extensionKw", "name"])),
-    comment_target_event_trigger: (print) => group(print.spaced(["eventTriggerKw", "name"])),
-    comment_target_foreign_data_wrapper: (print) => group(print.spaced(["foreignDataWrapperKw", "name"])),
-    comment_target_foreign_table: (print) => group(print.spaced(["foreignTableKw", "name"])),
-    comment_target_index: (print) => group(print.spaced(["indexKw", "name"])),
-    comment_target_language: (print) => group(print.spaced(["languageKw", "name"])),
-    comment_target_large_object: (print) => group(print.spaced(["largeObjectKw", "oid"])),
-    comment_target_materialized_view: (print) => group(print.spaced(["materializedViewKw", "name"])),
-    comment_target_operator_class: (print) => group(print.spaced(["operatorClassKw", "name", "usingKw", "methodName"])),
-    comment_target_operator_family: (print) => group(print.spaced(["operatorFamilyKw", "name", "usingKw", "methodName"])),
-    comment_target_policy: (print) => group(print.spaced(["policyKw", "name", "onKw", "tableName"])),
-    comment_target_publication: (print) => group(print.spaced(["publicationKw", "name"])),
-    comment_target_role: (print) => group(print.spaced(["roleKw", "name"])),
-    comment_target_rule: (print) => group(print.spaced(["ruleKw", "name", "onKw", "tableName"])),
-    comment_target_schema: (print) => group(print.spaced(["schemaKw", "name"])),
-    comment_target_sequence: (print) => group(print.spaced(["sequenceKw", "name"])),
-    comment_target_server: (print) => group(print.spaced(["serverKw", "name"])),
-    comment_target_statistics: (print) => group(print.spaced(["statisticsKw", "name"])),
-    comment_target_subscription: (print) => group(print.spaced(["subscriptionKw", "name"])),
-    comment_target_table: (print) => group(print.spaced(["tableKw", "name"])),
-    comment_target_tablespace: (print) => group(print.spaced(["tablespaceKw", "name"])),
-    comment_target_text_search_configuration: (print) => group(print.spaced(["textSearchConfigurationKw", "name"])),
-    comment_target_text_search_dictionary: (print) => group(print.spaced(["textSearchDictionaryKw", "name"])),
-    comment_target_text_search_parser: (print) => group(print.spaced(["textSearchParserKw", "name"])),
-    comment_target_text_search_template: (print) => group(print.spaced(["textSearchTemplateKw", "name"])),
-    comment_target_transform: (print) => group(print.spaced([
-        "transformForKw",
-        "typeName",
-        "languageKw",
-        "languageName",
-    ])),
-    comment_target_trigger: (print) => group(print.spaced(["triggerKw", "name", "onKw", "tableName"])),
-    comment_target_type: (print) => group(print.spaced(["typeKw", "name"])),
-    comment_target_view: (print) => group(print.spaced(["viewKw", "name"])),
-};

package/dist/syntax/constraint.d.ts

@@ -1,6 +0,0 @@
-import { Doc } from "prettier";
-import { AllConstraintNodes, AlterActionAddConstraint, Constraint } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-import { PrintFn } from "../PrintFn";
-export declare const constraintMap: CstToDocMap<AllConstraintNodes>;
-export declare const printUnnamedConstraint: <T>(print: PrintFn<Constraint<T>> | PrintFn<AlterActionAddConstraint>, node: Constraint<T> | AlterActionAddConstraint) => Doc;

package/dist/syntax/constraint.js

@@ -1,80 +0,0 @@
-import { group, indent, line, hardline, join } from "../print_utils";
-export const constraintMap = {
-    /** cst-ignore: constraint, modifiers */
-    constraint: (print, node) => {
-        if (node.name) {
-            return group([
-                print("name"),
-                indent([line, printUnnamedConstraint(print, node)]),
-            ]);
-        }
-        else {
-            return printUnnamedConstraint(print, node);
-        }
-    },
-    constraint_name: (print) => print.spaced(["constraintKw", "name"]),
-    constraint_modifier: (print) => print.spaced("kw"),
-    constraint_null: (print) => print("nullKw"),
-    constraint_not_null: (print) => group(print.spaced(["notNullKw", "clauses"])),
-    constraint_default: (print) => group(print.spaced(["defaultKw", "expr"])),
-    constraint_primary_key: (print) => group(print.spaced(["primaryKeyKw", "direction", "columns", "clauses"])),
-    constraint_unique: (print) => group(print.spaced(["uniqueKw", "columns", "nullsKw", "clauses"])),
-    existing_index: (print) => print.spaced(["usingIndexKw", "index"]),
-    constraint_check: (print) => group(print.spaced(["checkKw", "expr", "clauses"])),
-    constraint_collate: (print) => group(print.spaced(["collateKw", "collation"])),
-    constraint_foreign_key: (print) => group(print.spaced(["foreignKeyKw", "indexName", "columns", "references"])),
-    references_specification: (print, node) => {
-        const baseDoc = print.spaced(["referencesKw", "table", "columns"]);
-        if (node.options.length > 0) {
-            return group([
-                baseDoc,
-                indent([hardline, join(hardline, print("options"))]),
-            ]);
-        }
-        else {
-            return baseDoc;
-        }
-    },
-    referential_action: (print) => print.spaced(["onKw", "eventKw", "actionKw", "columns"]),
-    referential_match: (print) => print.spaced(["matchKw", "typeKw"]),
-    constraint_generated: (print) => print.spaced([
-        "generatedKw",
-        "asKw",
-        "expr",
-        "storageKw",
-        "sequenceOptions",
-    ]),
-    identity_column: (print) => print("identityKw"),
-    constraint_auto_increment: (print) => print("autoIncrementKw"),
-    on_conflict_clause: (print) => print.spaced(["onConflictKw", "resolutionKw"]),
-    constraint_comment: (print) => print.spaced(["commentKw", "value"]),
-    constraint_index: (print) => print.spaced(["indexTypeKw", "indexKw", "columns"]),
-    constraint_visible: (print) => print.spaced(["visibleKw"]),
-    constraint_column_format: (print) => print.spaced(["columnFormatKw", "formatKw"]),
-    constraint_storage: (print) => print.spaced(["storageKw", "typeKw"]),
-    constraint_engine_attribute: (print, node) => join(node.hasEq ? " = " : " ", print(["engineAttributeKw", "value"])),
-    constraint_compression: (print) => print.spaced(["compressionKw", "method"]),
-    constraint_exclude: (print, node) => group([
-        print("excludeKw"),
-        indent([
-            line,
-            join(line, [
-                print.separated(line, ["using", "params"]),
-                ...print("clauses"),
-            ]),
-        ]),
-    ]),
-    exclusion_param: (print) => print.spaced(["index", "withKw", "operator"]),
-    index_tablespace_clause: (print) => print.spaced(["usingIndexTablespaceKw", "name"]),
-};
-export const printUnnamedConstraint = (print, node) => {
-    if (node.modifiers.length > 0) {
-        return group([
-            print("constraint"),
-            indent([line, print.spaced("modifiers")]),
-        ]);
-    }
-    else {
-        return print("constraint");
-    }
-};

package/dist/syntax/create_table.d.ts

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

package/dist/syntax/create_table.js

@@ -1,69 +0,0 @@
-import { isAsClause } from "../node_utils";
-import { group, join, line } from "../print_utils";
-export const createTableMap = {
-    /** cst-ignore: clauses */
-    create_table_stmt: (print, node, ...rest) => group([
-        print.spaced([
-            "createKw",
-            "orReplaceKw",
-            "kind",
-            "tableKw",
-            "ifNotExistsKw",
-            "name",
-            "partitionOf",
-            "ofType",
-            "columns",
-        ]),
-        printClauses(print, node, ...rest),
-        node.options ? [line, group(print("options"))] : [],
-    ]),
-    relation_kind: (print) => print.spaced("kindKw"),
-    column_definition: (print) => print.spaced(["name", "dataType", "withOptionsKw", "constraints"]),
-    table_option: (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: (print) => print.spaced(["likeKw", "name", "options"]),
-    table_like_option: (print) => print.spaced(["includingOrExcludingKw", "optionKw"]),
-    create_table_copy_clause: (print) => print.spaced(["copyKw", "name"]),
-    create_table_clone_clause: (print) => print.spaced(["cloneKw", "table"]),
-    with_partition_columns_clause: (print) => print.spaced(["withPartitionColumnsKw", "columns"]),
-    create_table_using_clause: (print) => print.spaced(["usingKw", "module"]),
-    create_table_inherits_clause: (print) => print.spaced(["inheritsKw", "tables"]),
-    create_table_partition_by_clause: (print) => print.spaced(["partitionByKw", "strategyKw", "columns"]),
-    create_table_partition_of_clause: (print) => print.spaced(["partitionOfKw", "table"]),
-    create_table_partition_bound_clause: (print) => print.spaced(["forValuesKw", "bound"]),
-    partition_bound_in: (print) => print.spaced(["inKw", "values"]),
-    partition_bound_from_to: (print) => print.spaced(["fromKw", "from", "toKw", "to"]),
-    partition_bound_minvalue: (print) => print.spaced("minvalueKw"),
-    partition_bound_maxvalue: (print) => print.spaced("maxvalueKw"),
-    partition_bound_with: (print) => print.spaced(["withKw", "values"]),
-    partition_bound_modulus: (print) => print.spaced(["modulusKw", "value"]),
-    partition_bound_remainder: (print) => print.spaced(["remainderKw", "value"]),
-    create_table_default_partition_clause: (print) => print.spaced("defaultKw"),
-    create_table_of_type_clause: (print) => print.spaced(["ofKw", "typeName"]),
-    using_access_method_clause: (print) => print.spaced(["usingKw", "method"]),
-    tablespace_clause: (print) => print.spaced(["tablespaceKw", "name"]),
-    create_table_without_oids_clause: (print) => print.spaced("withoutOidsKw"),
-    create_table_on_commit_clause: (print) => print.spaced(["onCommitKw", "actionKw"]),
-    with_data_clause: (print) => print.spaced("withDataKw"),
-    create_table_server_clause: (print) => print.spaced(["serverKw", "name"]),
-};
-const printClauses = (print, node) => {
-    if (node.clauses.length === 1 && isAsClause(node.clauses[0])) {
-        return [" ", print("clauses")];
-    }
-    else if (node.clauses.length > 0) {
-        return [line, join(line, print("clauses"))];
-    }
-    else {
-        return [];
-    }
-};

package/dist/syntax/data_type.d.ts

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

package/dist/syntax/data_type.js

@@ -1,29 +0,0 @@
-import { isArray } from "../utils";
-import { group, indent, join, softline } from "../print_utils";
-import { isDataTypeName } from "../node_utils";
-export const dataTypeMap = {
-    data_type_name: (print) => print.spaced("name"),
-    // print single-word types as `TYPE(10)` and multi-word types as `MY TYPE (10)`
-    modified_data_type: (print, node) => (isMultiWordTypeName(node.dataType) ? print.spaced : print)([
-        "dataType",
-        "modifiers",
-    ]),
-    setof_data_type: (print) => print.spaced(["setofKw", "dataType"]),
-    array_data_type: (print) => print(["dataType", "bounds"]),
-    array_bounds: (print) => ["[", print("bounds"), "]"],
-    time_data_type: (print, node) => group(join(" ", [
-        print(["timeKw", "precision"]),
-        ...(node.timeZoneKw ? [print.spaced("timeZoneKw")] : []),
-    ])),
-    interval_data_type: (print) => print.spaced(["intervalKw", "unit"]),
-    interval_unit_range: (print) => print.spaced(["fromUnit", "toKw", "toUnit"]),
-    interval_unit: (print) => print.spaced(["unitKw", "precision"]),
-    parametric_data_type: (print) => print(["typeKw", "params"]),
-    generic_type_params: (print) => group(["<", indent([softline, print("params")]), softline, ">"]),
-    array_type_param: (print) => print.spaced(["dataType", "constraints"]),
-    struct_type_param: (print) => print.spaced(["name", "dataType", "constraints"]),
-    table_data_type: (print) => print.spaced(["tableKw", "columns"]),
-};
-function isMultiWordTypeName(node) {
-    return isDataTypeName(node) && isArray(node.name) && node.name.length > 1;
-}

package/dist/syntax/dcl.d.ts

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

package/dist/syntax/dcl.js

@@ -1,83 +0,0 @@
-import { group, indent, join, line } from "../print_utils";
-export const dclMap = {
-    grant_privilege_stmt: (print) => group(join(print.dynamicLine(), [
-        group([print("grantKw"), indent([line, print("privileges")])]),
-        group(print.spaced(["onKw", "resource"])),
-        group([print("toKw"), indent([line, print("roles")])]),
-        ...print("clauses"),
-    ])),
-    grant_role_stmt: (print) => group(join(print.dynamicLine(), [
-        group(join(line, [
-            group([print("grantKw"), indent([line, print("grantedRoles")])]),
-            group([print("toKw"), indent([line, print("granteeRoles")])]),
-        ])),
-        ...print("clauses"),
-    ])),
-    revoke_privilege_stmt: (print) => group(join(print.dynamicLine(), [
-        group([
-            print.spaced(["revokeKw", "option"]),
-            indent([line, print("privileges")]),
-        ]),
-        group(print.spaced(["onKw", "resource"])),
-        group([print("fromKw"), indent([line, print("roles")])]),
-        ...print(["grantedBy", "behaviorKw"]),
-    ])),
-    revoke_role_stmt: (print) => group(join(print.dynamicLine(), [
-        group(join(line, [
-            group([
-                print.spaced(["revokeKw", "option"]),
-                indent([line, print("grantedRoles")]),
-            ]),
-            group([print("fromKw"), indent([line, print("granteeRoles")])]),
-        ])),
-        ...print(["grantedBy", "behaviorKw"]),
-    ])),
-    privilege: (print) => print.spaced(["privilegeKw", "columns"]),
-    all_privileges: (print) => print.spaced(["allKw", "privilegesKw", "columns"]),
-    grant_resource_table: (print) => group(print.spaced(["tableKw", "tables"])),
-    grant_resource_view: (print) => group(print.spaced(["viewKw", "views"])),
-    grant_resource_schema: (print) => group(print.spaced(["schemaKw", "schemas"])),
-    grant_resource_sequence: (print) => group(print.spaced(["sequenceKw", "sequences"])),
-    grant_resource_database: (print) => group(print.spaced(["databaseKw", "databases"])),
-    grant_resource_domain: (print) => group(print.spaced(["domainKw", "domains"])),
-    grant_resource_foreign_data_wrapper: (print) => group(print.spaced(["foreignDataWrapperKw", "dataWrappers"])),
-    grant_resource_foreign_server: (print) => group(print.spaced(["foreignServerKw", "servers"])),
-    grant_resource_function: (print) => group(print.spaced(["functionKw", "functions"])),
-    grant_resource_language: (print) => group(print.spaced(["languageKw", "languages"])),
-    grant_resource_large_object: (print) => group(print.spaced(["largeObjectKw", "oids"])),
-    grant_resource_postgresql_option: (print) => group(print.spaced(["parameterKw", "options"])),
-    grant_resource_tablespace: (print) => group(print.spaced(["tablespaceKw", "tablespaces"])),
-    grant_resource_type: (print) => group(print.spaced(["typeKw", "types"])),
-    grant_resource_all_tables_in_schema: (print) => group(print.spaced(["allTablesInSchemaKw", "schemas"])),
-    grant_resource_all_sequences_in_schema: (print) => group(print.spaced(["allSequencesInSchemaKw", "schemas"])),
-    grant_resource_all_functions_in_schema: (print) => group(print.spaced(["allFunctionsInSchemaKw", "schemas"])),
-    with_grant_option_clause: (print) => group(print.spaced(["withKw", "nameKw", "value"])),
-    grant_option_for_clause: (print) => group(print.spaced(["nameKw", "optionForKw"])),
-    granted_by_clause: (print) => group(print.spaced(["grantedByKw", "role"])),
-    grantee_public: (print) => print("publicKw"),
-    grantee_group: (print) => group(print.spaced(["groupKw", "name"])),
-    alter_default_privileges_stmt: (print) => group(join(print.dynamicLine(), [
-        print.spaced("alterDefaultPrivilegesKw"),
-        ...print("clauses"),
-        print("action"),
-    ])),
-    default_acl_for_role_clause: (print) => group(print.spaced(["forKw", "roleKw", "roles"])),
-    default_acl_in_schema_clause: (print) => group(print.spaced(["inKw", "schemaKw", "schemas"])),
-    grant_default_privileges_action: (print) => group(join(line, [
-        group(print.spaced(["grantKw", "privileges", "onKw", "resourcesKw"])),
-        group(print.spaced(["toKw", "roles", "withGrantOption"])),
-    ])),
-    revoke_default_privileges_action: (print) => group(join(line, [
-        group([
-            print.spaced(["revokeKw", "grantOptionFor"]),
-            indent([
-                line,
-                join(line, [
-                    group(print("privileges")),
-                    print.spaced(["onKw", "resourcesKw"]),
-                ]),
-            ]),
-        ]),
-        group(print.spaced(["fromKw", "roles", "behaviorKw"])),
-    ])),
-};

package/dist/syntax/delete.d.ts

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

package/dist/syntax/delete.js

@@ -1,5 +0,0 @@
-import { group, join } from "../print_utils";
-export const deleteMap = {
-    delete_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
-    delete_clause: (print) => print.spaced(["deleteKw", "modifiers", "fromKw", "tables"]),
-};

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

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