prettier-plugin-sql-cst 0.19.1 → 0.19.3

package/dist/syntax/dialects/bigquery.js

@@ -1,84 +0,0 @@
-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/syntax/dialects/mysql.d.ts

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

package/dist/syntax/dialects/mysql.js

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

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

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

package/dist/syntax/dialects/postgresql.js

@@ -1,9 +0,0 @@
-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/syntax/dialects/sqlite.d.ts

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

package/dist/syntax/dialects/sqlite.js

@@ -1,9 +0,0 @@
-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/syntax/do.d.ts

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

package/dist/syntax/do.js

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

package/dist/syntax/domain.d.ts

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

package/dist/syntax/domain.js

@@ -1,11 +0,0 @@
-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/syntax/drop_table.d.ts

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

package/dist/syntax/drop_table.js

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

package/dist/syntax/explain.d.ts

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

package/dist/syntax/explain.js

@@ -1,7 +0,0 @@
-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/syntax/expr.d.ts

@@ -1,5 +0,0 @@
-import { AllExprNodes, Keyword } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-import { AllPrettierOptions } from "../options";
-export declare const exprMap: CstToDocMap<AllExprNodes>;
-export declare const printLiteral: <T>(node: Keyword, options: AllPrettierOptions<T>) => string;

package/dist/syntax/expr.js

@@ -1,224 +0,0 @@
-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";

package/dist/syntax/extension.d.ts

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

package/dist/syntax/extension.js

@@ -1,13 +0,0 @@
-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/syntax/frame.d.ts

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

package/dist/syntax/frame.js

@@ -1,13 +0,0 @@
-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/syntax/function.d.ts

@@ -1,4 +0,0 @@
-import { AllFunctionNodes, CreateFunctionStmt, CreateProcedureStmt } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const functionMap: CstToDocMap<AllFunctionNodes>;
-export declare const hasOnlyAsClause: (node: CreateFunctionStmt | CreateProcedureStmt) => boolean;

package/dist/syntax/function.js

@@ -1,55 +0,0 @@
-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/syntax/index.d.ts

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

package/dist/syntax/index.js

@@ -1,60 +0,0 @@
-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/syntax/insert.d.ts

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

package/dist/syntax/insert.js

@@ -1,33 +0,0 @@
-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/syntax/merge.d.ts

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