prettier-plugin-sql-cst 0.18.0 → 0.19.0

package/dist/{syntax → src/syntax}/constraint.d.ts

@@ -3,4 +3,4 @@ import { AllConstraintNodes, AlterActionAddConstraint, Constraint } from "sql-pa
 import { CstToDocMap } from "../CstToDocMap";
 import { PrintFn } from "../PrintFn";
 export declare const constraintMap: CstToDocMap<AllConstraintNodes>;
-export declare const printUnnamedConstraint: <T>(print: PrintFn<Constraint<T>, "name" | "modifiers" | "constraint"> | PrintFn<AlterActionAddConstraint, "name" | "modifiers" | "constraint" | "addKw">, node: AlterActionAddConstraint | Constraint<T>) => Doc;
+export declare const printUnnamedConstraint: <T>(print: PrintFn<Constraint<T>> | PrintFn<AlterActionAddConstraint>, node: Constraint<T> | AlterActionAddConstraint) => Doc;

package/dist/src/syntax/constraint.js

@@ -0,0 +1,80 @@
+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/src/syntax/create_table.js

@@ -0,0 +1,69 @@
+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/src/syntax/data_type.js

@@ -0,0 +1,29 @@
+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/src/syntax/dcl.js

@@ -0,0 +1,83 @@
+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/src/syntax/delete.js

@@ -0,0 +1,5 @@
+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/src/syntax/dialects/bigquery.js

@@ -0,0 +1,84 @@
+import { group, hardline, join } from "../../print_utils";
+export const bigqueryMap = {
+    bigquery_options: (print) => print.spaced(["optionsKw", "options"]),
+    bigquery_option_default_collate: (print) => print.spaced(["defaultCollateKw", "collation"]),
+    // ROW ACCESS POLICY
+    create_row_access_policy_stmt: (print) => group(join(hardline, [
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "rowAccessPolicyKw",
+            "ifNotExistsKw",
+            "name",
+            "onKw",
+            "table",
+        ]),
+        ...print("clauses"),
+    ])),
+    row_access_policy_grant_clause: (print) => print.spaced(["grantToKw", "grantees"]),
+    row_access_policy_filter_clause: (print) => print.spaced(["filterUsingKw", "expr"]),
+    drop_row_access_policy_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "allKw",
+        "rowAccessPolicyKw",
+        "ifExistsKw",
+        "name",
+        "onKw",
+        "table",
+    ])),
+    // CAPACITY
+    create_capacity_stmt: (print) => group([
+        print.spaced(["createKw", "capacityKw", "name"]),
+        hardline,
+        print("options"),
+    ]),
+    drop_capacity_stmt: (print) => group(print.spaced(["dropKw", "capacityKw", "ifExistsKw", "name"])),
+    // RESERVATION
+    create_reservation_stmt: (print) => group([
+        print.spaced(["createKw", "reservationKw", "name"]),
+        hardline,
+        print("options"),
+    ]),
+    drop_reservation_stmt: (print) => group(print.spaced(["dropKw", "reservationKw", "ifExistsKw", "name"])),
+    // ASSIGNMENT
+    create_assignment_stmt: (print) => group([
+        print.spaced(["createKw", "assignmentKw", "name"]),
+        hardline,
+        print("options"),
+    ]),
+    drop_assignment_stmt: (print) => group(print.spaced(["dropKw", "assignmentKw", "ifExistsKw", "name"])),
+    // ALTER ORGANIZATION
+    alter_organization_stmt: (print) => group(join(hardline, [print.spaced("alterOrganizationKw"), print("actions")])),
+    // ALTER PROJECT
+    alter_project_stmt: (print) => group(join(hardline, [
+        print.spaced(["alterProjectKw", "name"]),
+        print("actions"),
+    ])),
+    alter_bi_capacity_stmt: (print) => group(join(hardline, [
+        print.spaced(["alterBiCapacityKw", "name"]),
+        print("actions"),
+    ])),
+    alter_capacity_stmt: (print) => group(join(hardline, [
+        print.spaced(["alterCapacityKw", "name"]),
+        print("actions"),
+    ])),
+    alter_reservation_stmt: (print) => group(join(hardline, [
+        print.spaced(["alterReservationKw", "name"]),
+        print("actions"),
+    ])),
+    // ASSERT
+    assert_stmt: (print) => group(print.spaced(["assertKw", "expr", "as"])),
+    // EXPORT
+    export_data_stmt: (print) => group(join(hardline, [
+        print.spaced("exportDataKw"),
+        ...print.spaced(["withConnection"]),
+        print.spaced("options"),
+        print.spaced("as"),
+    ])),
+    // LOAD
+    load_data_stmt: (print) => group(join(hardline, [
+        print.spaced(["loadDataKw", "intoKw", "table", "columns"]),
+        ...print("clauses"),
+    ])),
+    from_files_options: (print) => print.spaced(["fromFilesKw", "options"]),
+};

package/dist/src/syntax/dialects/mysql.js

@@ -0,0 +1,3 @@
+export const mysqlMap = {
+    mysql_modifier: (print) => print.spaced("modifierKw"),
+};

package/dist/src/syntax/dialects/postgresql.js

@@ -0,0 +1,9 @@
+import { group } from "../../print_utils";
+export const postgresqlMap = {
+    postgresql_operator_expr: (print) => print(["operatorKw", "expr"]),
+    postgresql_operator: (print) => print("operator"),
+    postgresql_operator_class: (print) => print.spaced(["name", "options"]),
+    postgresql_with_options: (print) => group(print.spaced(["withKw", "options"])),
+    postgresql_options: (print) => print.spaced(["optionsKw", "options"]),
+    postgresql_option_element: (print) => print.spaced(["name", "value"]),
+};

package/dist/src/syntax/dialects/sqlite.js

@@ -0,0 +1,9 @@
+import { group, join } from "../../print_utils";
+export const sqliteMap = {
+    attach_database_stmt: (print) => group(print.spaced(["attachKw", "databaseKw", "file", "asKw", "schema"])),
+    detach_database_stmt: (print) => group(print.spaced(["detachKw", "databaseKw", "schema"])),
+    vacuum_stmt: (print) => group(print.spaced(["vacuumKw", "schema", "intoKw", "file"])),
+    pragma_stmt: (print) => group(print.spaced(["pragmaKw", "pragma"])),
+    pragma_assignment: (print) => join(" = ", print(["name", "value"])),
+    pragma_func_call: (print) => print(["name", "args"]),
+};

package/dist/src/syntax/do.js

@@ -0,0 +1,4 @@
+import { group } from "../print_utils";
+export const doMap = {
+    do_stmt: (print) => group(print.spaced(["doKw", "language", "body"])),
+};

package/dist/src/syntax/domain.js

@@ -0,0 +1,11 @@
+import { group, line, indent, join } from "../print_utils";
+export const domainMap = {
+    create_domain_stmt: (print, node) => group([
+        print.spaced(["createDomainKw", "name", "asKw", "dataType"]),
+        node.constraints.length > 0
+            ? indent([print.dynamicLine(), join(line, print("constraints"))])
+            : [],
+    ]),
+    alter_domain_stmt: (print) => group(print.spaced(["alterDomainKw", "name", "action"])),
+    drop_domain_stmt: (print) => group(print.spaced(["dropDomainKw", "ifExistsKw", "domains", "behaviorKw"])),
+};

package/dist/src/syntax/drop_table.js

@@ -0,0 +1,11 @@
+import { group } from "../print_utils";
+export const dropTableMap = {
+    drop_table_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "kind",
+        "tableKw",
+        "ifExistsKw",
+        "tables",
+        "behaviorKw",
+    ])),
+};

package/dist/src/syntax/explain.js

@@ -0,0 +1,7 @@
+import { group, indent, line } from "../print_utils";
+export const explainMap = {
+    explain_stmt: (print) => group([
+        print.spaced(["explainKw", "analyzeKw", "queryPlanKw"]),
+        indent([line, print("statement")]),
+    ]),
+};

package/dist/src/syntax/expr.js

@@ -0,0 +1,224 @@
+import { join, line, softline, hardline, indent, group, stripTrailingHardline, } from "../print_utils";
+import { isCreateTableStmt, isKeyword, isValuesClause, isEmpty, isArraySubscript, isParenExpr, isFuncArgs, isListExpr, isProgram, isSelectStmt, isCompoundSelectStmt, isBigqueryQuotedMemberExpr, isFuncCall, isMemberExpr, isCreateFunctionStmt, isAlterFunctionStmt, isAlterActionRename, isCreateProcedureStmt, isAlterProcedureStmt, isCreateTriggerStmt, isExecuteClause, isFunctionSignature, } from "../node_utils";
+import { isString, last } from "../utils";
+export const exprMap = {
+    list_expr: (print, node, path) => {
+        const parent = path.getParentNode();
+        const children = print("items").map((it) => group(it));
+        const lineType = isValuesClause(parent) ? hardline : line;
+        // When last item is type:empty, we're dealing with a trailing comma.
+        // Don't add a space (or newline) after it.
+        // We still want to print it though, as it might have comments attached.
+        if (isEmpty(last(node.items))) {
+            return [
+                join([",", lineType], children.slice(0, -1)),
+                ",",
+                last(children),
+            ];
+        }
+        else {
+            return join([",", lineType], children);
+        }
+    },
+    paren_expr: (print, node, path) => {
+        // discard unnecessary nested ((parentheses))
+        if (isParenExpr(node.expr)) {
+            return print("expr");
+        }
+        // Discard unnecessary parenthesis around function arguments
+        if (isListExpr(path.getParentNode(0)) &&
+            isFuncArgs(path.getParentNode(1)) &&
+            !isSelectStmt(node.expr) &&
+            !isCompoundSelectStmt(node.expr)) {
+            return print("expr");
+        }
+        const parent = path.getParentNode();
+        const lineStyle = isCreateTableStmt(parent) && print.dynamicLine() === hardline
+            ? hardline
+            : softline;
+        return group(["(", indent([lineStyle, print("expr")]), lineStyle, ")"]);
+    },
+    binary_expr: (print, node) => {
+        if (isKeyword(node.operator) && isBooleanOp(node.operator)) {
+            return join(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: (print, node) => (isString(node.operator) ? print : print.spaced)(["operator", "expr"]),
+    postfix_op_expr: (print) => print.spaced(["expr", "operator"]),
+    between_expr: (print) => print.spaced(["left", "betweenKw", "begin", "andKw", "end"]),
+    case_expr: (print) => [
+        print.spaced(["caseKw", "expr"]),
+        indent([hardline, join(hardline, print("clauses"))]),
+        hardline,
+        print("endKw"),
+    ],
+    case_when: (print, node) => {
+        if (isProgram(node.result)) {
+            return [
+                print.spaced(["whenKw", "condition", "thenKw"]),
+                indent([hardline, stripTrailingHardline(print("result"))]),
+            ];
+        }
+        return print.spaced(["whenKw", "condition", "thenKw", "result"]);
+    },
+    case_else: (print, node) => {
+        if (isProgram(node.result)) {
+            return [
+                print("elseKw"),
+                indent([hardline, stripTrailingHardline(print("result"))]),
+            ];
+        }
+        return print.spaced(["elseKw", "result"]);
+    },
+    member_expr: (print, node) => isArraySubscript(node.property)
+        ? print(["object", "property"])
+        : [print("object"), ".", print("property")],
+    bigquery_quoted_member_expr: (print) => ["`", print("expr"), "`"],
+    array_subscript: (print) => group(["[", indent([softline, print("expr")]), softline, "]"]),
+    array_subscript_specifier: (print) => print(["specifierKw", "args"]),
+    array_slice_specifier: (print) => [print("from"), ":", print("to")],
+    func_call: (print) => {
+        const fnCall = print(["name", "args"]);
+        const extras = print(["filter", "over"]);
+        if (extras.length > 1) {
+            return group([fnCall, indent([line, join(line, extras)])]);
+        }
+        else {
+            return group(join(" ", [fnCall, ...extras]));
+        }
+    },
+    func_args: (print, node) => join(line, [
+        ...print(["distinctKw", "args"]),
+        ...(node.nullHandlingKw ? print.spaced("nullHandlingKw") : []),
+        ...print(["orderBy", "limit", "having"]),
+    ]),
+    filter_arg: (print) => print.spaced(["filterKw", "where"]),
+    over_arg: (print) => print.spaced(["overKw", "window"]),
+    having_arg: (print) => print.spaced(["havingKw", "minMaxKw", "expr"]),
+    named_arg: (print) => group([
+        print("name"),
+        " ",
+        print("operator"),
+        indent([line, print("value")]),
+    ]),
+    cast_expr: (print) => print(["castKw", "args"]),
+    cast_arg: (print) => print.spaced(["expr", "asKw", "dataType", "format"]),
+    cast_format: (print) => print.spaced(["formatKw", "string", "timezone"]),
+    cast_format_timezone: (print) => print.spaced(["atTimeZoneKw", "timezone"]),
+    cast_operator_expr: (print) => [
+        print("left"),
+        print("operator"),
+        print("right"),
+    ],
+    string_with_charset: (print) => ["_", print(["charset", "string"])],
+    raise_expr: (print) => print(["raiseKw", "args"]),
+    raise_expr_type: (print) => print("typeKw"),
+    extract_expr: (print) => print(["extractKw", "args"]),
+    extract_from: (print) => print.spaced(["unit", "fromKw", "expr"]),
+    week_expr: (print) => print(["weekKw", "args"]),
+    interval_literal: (print) => print.spaced(["intervalKw", "precision", "value", "unit"]),
+    array_literal_expr: (print) => print(["arrayKw", "expr"]),
+    array_expr: (print) => group(["[", indent([softline, print("expr")]), softline, "]"]),
+    struct_expr: (print) => group(["(", indent([softline, print("expr")]), softline, ")"]),
+    typed_expr: (print) => print(["dataType", "expr"]),
+    row_constructor: (print) => print(["rowKw", "row"]),
+    array_constructor: (print) => print(["arrayKw", "expr"]),
+    quantifier_expr: (print) => print.spaced(["quantifierKw", "expr"]),
+    full_text_match_expr: (print) => print.spaced(["matchKw", "columns", "againstKw", "args"]),
+    full_text_match_args: (print) => print.spaced(["expr", "modifier"]),
+    /** cst-ignore: value */
+    number_literal: (print) => print("text"),
+    /** cst-ignore: value */
+    boolean_literal: (print, node, path, options) => printLiteral(node.valueKw, options),
+    /** cst-ignore: value */
+    string_literal: (print) => print("text"),
+    /** cst-ignore: value */
+    blob_literal: (print) => print("text"),
+    /** cst-ignore: value */
+    null_literal: (print, node, path, options) => printLiteral(node.nullKw, options),
+    numeric_literal: (print) => print.spaced(["numericKw", "string"]),
+    bignumeric_literal: (print) => print.spaced(["bignumericKw", "string"]),
+    date_literal: (print) => print.spaced(["dateKw", "string"]),
+    time_literal: (print) => print.spaced(["timeKw", "string"]),
+    datetime_literal: (print) => print.spaced(["datetimeKw", "string"]),
+    timestamp_literal: (print) => print.spaced(["timestampKw", "string"]),
+    json_literal: (print) => print.spaced(["jsonKw", "string"]),
+    jsonb_literal: (print) => print.spaced(["jsonbKw", "string"]),
+    /** cst-ignore: name */
+    identifier: (print, node, path, options) => {
+        if (isQuotedIdentifier(node) || isInsideBigqueryQuotedMemberExpr(path)) {
+            return print("text");
+        }
+        else {
+            if (isFunctionName(node, path)) {
+                return printFunctionName(node, options);
+            }
+            else {
+                return printIdentifier(node, options);
+            }
+        }
+    },
+    /** cst-ignore: name */
+    variable: (print, node, path, options) => isQuotedVariable(node) ? print("text") : printIdentifier(node, options),
+    parameter: (print, node, path, options) => isQuotedParameter(node) ? print("text") : printIdentifier(node, options),
+};
+export const printLiteral = (node, options) => {
+    switch (options.sqlLiteralCase) {
+        case "preserve":
+            return node.text;
+        case "upper":
+            return node.text.toUpperCase();
+        case "lower":
+            return node.text.toLowerCase();
+    }
+};
+const printIdentifier = (node, options) => {
+    switch (options.sqlIdentifierCase) {
+        case "preserve":
+            return node.text;
+        case "upper":
+            return node.text.toUpperCase();
+        case "lower":
+            return node.text.toLowerCase();
+    }
+};
+const printFunctionName = (node, options) => {
+    switch (options.sqlFunctionCase) {
+        case "preserve":
+            return node.text;
+        case "upper":
+            return node.text.toUpperCase();
+        case "lower":
+            return node.text.toLowerCase();
+    }
+};
+const isQuotedIdentifier = (node) => node.name !== node.text;
+const isQuotedVariable = (node) => !(node.text === "@" + node.name || node.text === "@@" + node.name);
+const isQuotedParameter = (node) => /`$/.test(node.text);
+const isInsideBigqueryQuotedMemberExpr = (path) => path.ancestors.some(isBigqueryQuotedMemberExpr);
+const isFunctionName = (node, path) => {
+    const parent = path.parent;
+    if (isFunctionContext(parent, path.grandparent)) {
+        return true;
+    }
+    if (isMemberExpr(parent) && parent.property === node) {
+        const [_, gp, ggp] = path.ancestors;
+        return isFunctionContext(gp, ggp);
+    }
+    return false;
+};
+const isFunctionContext = (node, parent) => {
+    return (isFuncCall(node) ||
+        isFunctionSignature(node) ||
+        isCreateFunctionStmt(node) ||
+        isCreateProcedureStmt(node) ||
+        (isAlterActionRename(node) &&
+            (isAlterFunctionStmt(parent) || isAlterProcedureStmt(parent))) ||
+        (isExecuteClause(node) && isCreateTriggerStmt(parent)));
+};
+const isBooleanOp = ({ name }) => name === "AND" || name === "OR";