prettier-plugin-sql-cst 0.19.2 → 0.20.0

package/dist/syntax/select.js

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

package/dist/syntax/sequence.d.ts

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

package/dist/syntax/sequence.js

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

package/dist/syntax/subscription.d.ts

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

package/dist/syntax/subscription.js

@@ -1,10 +0,0 @@
-import { group, line, join } from "../print_utils";
-export const subscriptionMap = {
-    create_subscription_stmt: (print, node) => group(join(line, [
-        print.spaced(["createSubscriptionKw", "name"]),
-        print.spaced(["connectionKw", "connectionInfo"]),
-        print.spaced(["publicationKw", "publications"]),
-        ...(node.with ? [print.spaced(["with"])] : []),
-    ])),
-    drop_subscription_stmt: (print) => group(print.spaced(["dropSubscriptionKw", "ifExistsKw", "name", "behaviorKw"])),
-};

package/dist/syntax/transaction.d.ts

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

package/dist/syntax/transaction.js

@@ -1,19 +0,0 @@
-import { group, indent, line } from "../print_utils";
-export const transactionMap = {
-    start_transaction_stmt: (print, node) => group([
-        print.spaced(["startKw", "behaviorKw", "transactionKw"]),
-        node.modes ? indent([line, print("modes")]) : [],
-    ]),
-    commit_transaction_stmt: (print) => group(print.spaced(["commitKw", "transactionKw", "chain"])),
-    rollback_transaction_stmt: (print) => group(print.spaced(["rollbackKw", "transactionKw", "savepoint", "chain"])),
-    rollback_to_savepoint: (print) => print.spaced(["toKw", "savepointKw", "savepoint"]),
-    savepoint_stmt: (print) => group(print.spaced(["savepointKw", "savepoint"])),
-    release_savepoint_stmt: (print) => group(print.spaced(["releaseKw", "savepointKw", "savepoint"])),
-    transaction_chain_clause: (print) => print.spaced("andChainKw"),
-    transaction_no_chain_clause: (print) => print.spaced("andNoChainKw"),
-    transaction_mode_isolation_level: (print) => print.spaced(["isolationLevelKw", "levelKw"]),
-    transaction_mode_deferrable: (print) => print.spaced("deferrableKw"),
-    transaction_mode_not_deferrable: (print) => print.spaced("notDeferrableKw"),
-    transaction_mode_read_only: (print) => print.spaced("readOnlyKw"),
-    transaction_mode_read_write: (print) => print.spaced("readWriteKw"),
-};

package/dist/syntax/transformMap.d.ts

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

package/dist/syntax/transformMap.js

@@ -1,100 +0,0 @@
-import { aliasMap } from "./alias";
-import { alterActionMap } from "./alter_action";
-import { alterTableMap } from "./alter_table";
-import { analyzeMap } from "./analyze";
-import { baseMap } from "./base";
-import { castMap } from "./cast";
-import { commentMap } from "./comment";
-import { constraintMap } from "./constraint";
-import { createTableMap } from "./create_table";
-import { dataTypeMap } from "./data_type";
-import { dclMap } from "./dcl";
-import { deleteMap } from "./delete";
-import { doMap } from "./do";
-import { domainMap } from "./domain";
-import { dropTableMap } from "./drop_table";
-import { explainMap } from "./explain";
-import { exprMap } from "./expr";
-import { extensionMap } from "./extension";
-import { frameMap } from "./frame";
-import { functionMap } from "./function";
-import { indexMap } from "./index";
-import { insertMap } from "./insert";
-import { mergeMap } from "./merge";
-import { otherClausesMap } from "./other_clauses";
-import { renameTableMap } from "./rename_table";
-import { roleMap } from "./role";
-import { parameterMap } from "./parameter";
-import { policyMap } from "./policy";
-import { preparedStatementsMap } from "./prepared_statements";
-import { proceduralLanguageMap } from "./procedural_language";
-import { procedureMap } from "./procedure";
-import { procClauseMap } from "./proc_clause";
-import { programMap } from "./program";
-import { publicationMap } from "./publication";
-import { schemaMap } from "./schema";
-import { selectMap } from "./select";
-import { sequenceMap } from "./sequence";
-import { subscriptionMap } from "./subscription";
-import { transactionMap } from "./transaction";
-import { triggerMap } from "./trigger";
-import { truncateMap } from "./truncate";
-import { typeMap } from "./type";
-import { unsupportedGrammarMap } from "./unsupported_grammar";
-import { updateMap } from "./update";
-import { viewMap } from "./view";
-import { bigqueryMap } from "./dialects/bigquery";
-import { mysqlMap } from "./dialects/mysql";
-import { sqliteMap } from "./dialects/sqlite";
-import { postgresqlMap } from "./dialects/postgresql";
-export const transformMap = {
-    ...aliasMap,
-    ...alterActionMap,
-    ...alterTableMap,
-    ...analyzeMap,
-    ...baseMap,
-    ...castMap,
-    ...commentMap,
-    ...constraintMap,
-    ...createTableMap,
-    ...dataTypeMap,
-    ...dclMap,
-    ...deleteMap,
-    ...doMap,
-    ...domainMap,
-    ...dropTableMap,
-    ...explainMap,
-    ...exprMap,
-    ...extensionMap,
-    ...frameMap,
-    ...functionMap,
-    ...indexMap,
-    ...insertMap,
-    ...mergeMap,
-    ...otherClausesMap,
-    ...parameterMap,
-    ...policyMap,
-    ...preparedStatementsMap,
-    ...procClauseMap,
-    ...proceduralLanguageMap,
-    ...procedureMap,
-    ...programMap,
-    ...publicationMap,
-    ...renameTableMap,
-    ...roleMap,
-    ...schemaMap,
-    ...selectMap,
-    ...sequenceMap,
-    ...subscriptionMap,
-    ...transactionMap,
-    ...triggerMap,
-    ...truncateMap,
-    ...typeMap,
-    ...unsupportedGrammarMap,
-    ...updateMap,
-    ...viewMap,
-    ...bigqueryMap,
-    ...mysqlMap,
-    ...postgresqlMap,
-    ...sqliteMap,
-};

package/dist/syntax/trigger.d.ts

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

package/dist/syntax/trigger.js

@@ -1,52 +0,0 @@
-import { group, hardline, indent, join, line } from "../print_utils";
-export const triggerMap = {
-    create_trigger_stmt: (print, node) => group(join(hardline, [
-        print.spaced([
-            "createKw",
-            "orReplaceKw",
-            "kind",
-            "triggerKw",
-            "ifNotExistsKw",
-            "name",
-        ]),
-        group([
-            node.timeKw ? [print.spaced("timeKw"), " "] : [],
-            print("event"),
-            line,
-            print("target"),
-        ]),
-        ...print("clauses"),
-        print("body"),
-    ])),
-    trigger_event: (print, node) => group([
-        print.spaced(["eventKw", "ofKw"]),
-        node.columns ? indent([line, print("columns")]) : [],
-    ]),
-    trigger_target: (print) => print.spaced(["onKw", "table"]),
-    when_clause: (print) => group([print("whenKw"), indent([line, print("expr")])]),
-    for_each_clause: (print) => print.spaced(["forEachKw", "itemKw"]),
-    execute_clause: (print) => [
-        print.spaced(["executeKw", "functionKw", "name"]),
-        print("args"),
-    ],
-    from_referenced_table_clause: (print) => print.spaced(["fromKw", "table"]),
-    trigger_timing_clause: (print) => print.spaced(["timingKw"]),
-    trigger_referencing_clause: (print) => group([
-        print.spaced(["referencingKw"]),
-        indent([line, print("transitions")]),
-    ]),
-    trigger_transition: (print) => [
-        print.spaced(["oldOrNewKw", "rowOrTableKw", "asKw", "name"]),
-    ],
-    alter_trigger_stmt: (print) => group(join(print.dynamicLine(), [
-        print.spaced(["alterTriggerKw", "trigger", "target"]),
-        print("action"),
-    ])),
-    drop_trigger_stmt: (print) => group(print.spaced([
-        "dropTriggerKw",
-        "ifExistsKw",
-        "trigger",
-        "target",
-        "behaviorKw",
-    ])),
-};

package/dist/syntax/truncate.d.ts

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

package/dist/syntax/truncate.js

@@ -1,10 +0,0 @@
-import { group, indent, line } from "../print_utils";
-export const truncateMap = {
-    truncate_stmt: (print) => group([
-        print.spaced(["truncateKw", "tableKw"]),
-        indent([
-            line,
-            print.separated(line, ["tables", "restartOrContinueKw", "behaviorKw"]),
-        ]),
-    ]),
-};

package/dist/syntax/type.d.ts

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

package/dist/syntax/type.js

@@ -1,12 +0,0 @@
-import { group } from "../print_utils";
-export const typeMap = {
-    create_type_stmt: (print) => group([print.spaced(["createTypeKw", "name", "definition"])]),
-    composite_type_definition: (print) => group(print.spaced(["asKw", "columns"])),
-    enum_type_definition: (print) => group(print.spaced(["asEnumKw", "values"])),
-    alter_type_stmt: (print, node) => group([
-        print.spaced(["alterTypeKw", "name"]),
-        print.dynamicLine(),
-        print("actions"),
-    ]),
-    drop_type_stmt: (print) => group(print.spaced(["dropTypeKw", "ifExistsKw", "types", "behaviorKw"])),
-};

package/dist/syntax/unsupported_grammar.d.ts

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

package/dist/syntax/unsupported_grammar.js

@@ -1,4 +0,0 @@
-import { group } from "../print_utils";
-export const unsupportedGrammarMap = {
-    unsupported_grammar_stmt: (print) => group(print("text")),
-};

package/dist/syntax/update.d.ts

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

package/dist/syntax/update.js

@@ -1,14 +0,0 @@
-import { join, hardline, indent, group } from "../print_utils";
-export const updateMap = {
-    update_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
-    update_clause: (print) => print.spaced(["updateKw", "modifiers", "orAction", "tables"]),
-    set_clause: (print, node) => {
-        if (node.assignments.items.length > 1) {
-            return [print("setKw"), indent([hardline, print("assignments")])];
-        }
-        else {
-            return print.spaced(["setKw", "assignments"]);
-        }
-    },
-    column_assignment: (print) => join([" ", "=", " "], print(["column", "expr"])),
-};

package/dist/syntax/view.d.ts

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

package/dist/syntax/view.js

@@ -1,48 +0,0 @@
-import { group, hardline, join, line } from "../print_utils";
-export const viewMap = {
-    create_view_stmt: (print, node) => {
-        const hasOnlyAsClause = node.clauses.length === 1;
-        const hasManyClauses = node.clauses.length > 1;
-        return group([
-            print.spaced([
-                "createKw",
-                "orReplaceKw",
-                "kinds",
-                "viewKw",
-                "ifNotExistsKw",
-                "name",
-                "columns",
-            ]),
-            hasOnlyAsClause ? [" ", print("clauses")] : [],
-            hasManyClauses ? [hardline, join(hardline, print("clauses"))] : [],
-        ]);
-    },
-    with_check_option_clause: (print) => print.spaced(["withKw", "levelKw", "checkOptionKw"]),
-    as_replica_of_clause: (print) => print.spaced(["asReplicaOfKw", "view"]),
-    drop_view_stmt: (print) => group(print.spaced([
-        "dropKw",
-        "kind",
-        "viewKw",
-        "ifExistsKw",
-        "views",
-        "behaviorKw",
-    ])),
-    alter_view_stmt: (print) => group([
-        print.spaced([
-            "alterKw",
-            "kind",
-            "viewKw",
-            "ifExistsKw",
-            "name",
-            "columns",
-        ]),
-        hardline,
-        print("actions"),
-    ]),
-    refresh_materialized_view_stmt: (print, node) => group([
-        print.spaced(["refreshMaterializedViewKw", "concurrentlyKw", "name"]),
-        node.clauses.length > 0
-            ? [print.dynamicLine(), join(line, print("clauses"))]
-            : [],
-    ]),
-};

package/dist/transform/addFinalSemicolon.d.ts

@@ -1,2 +0,0 @@
-import { Program } from "sql-parser-cst";
-export declare const addFinalSemicolon: (program: Program, originalText: string) => Program;

package/dist/transform/addFinalSemicolon.js

@@ -1,9 +0,0 @@
-import { isEmpty } from "../node_utils";
-import { last } from "../utils";
-export const addFinalSemicolon = (program, originalText) => {
-    if (!isEmpty(last(program.statements))) {
-        const end = originalText.length;
-        program.statements.push({ type: "empty", range: [end, end] });
-    }
-    return program;
-};

package/dist/transform/aliasAs.d.ts

@@ -1,2 +0,0 @@
-import { Program } from "sql-parser-cst";
-export declare const processAliasAs: (cst: Program) => Program;

package/dist/transform/aliasAs.js

@@ -1,10 +0,0 @@
-import { cstVisitor } from "sql-parser-cst";
-// Adds AS keyword to aliases if none exists
-export const processAliasAs = (cst) => {
-    cstVisitor({
-        alias: (node) => {
-            node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
-        },
-    })(cst);
-    return cst;
-};

package/dist/transform/canonicKeywords.d.ts

@@ -1,2 +0,0 @@
-import { Program } from "sql-parser-cst";
-export declare const canonicKeywords: (cst: Program) => Program;