rawsql-ts 0.6.0-beta → 0.7.1-beta

package/dist/esm/transformers/Formatter.js

@@ -1,661 +1,34 @@
-import { BinarySelectQuery, SimpleSelectQuery, ValuesQuery } from "../models/SelectQuery";
-import { LiteralValue, RawString, IdentifierString, ColumnReference, FunctionCall, UnaryExpression, BinaryExpression, ParameterExpression, ArrayExpression, CaseExpression, CastExpression, ParenExpression, BetweenExpression, SwitchCaseArgument, ValueList, StringSpecifierExpression, TypeValue, WindowFrameExpression, WindowFrameSpec, WindowFrameBound, WindowFrameBoundaryValue, WindowFrameBoundStatic, InlineQuery, TupleExpression } from "../models/ValueComponent";
-import { CommonTable, Distinct, DistinctOn, FetchSpecification, FetchType, ForClause, FromClause, FunctionSource, GroupByClause, HavingClause, InsertClause, JoinClause, JoinOnClause, JoinUsingClause, LimitClause, NullsSortDirection, OrderByClause, OrderByItem, PartitionByClause, ReturningClause, SelectClause, SelectItem, SetClause, SetClauseItem, SortDirection, SourceAliasExpression, SourceExpression, SubQuerySource, TableSource, UpdateClause, WhereClause, WindowFrameClause, WithClause } from "../models/Clause";
-import { CreateTableQuery } from "../models/CreateTableQuery";
-import { InsertQuery } from "../models/InsertQuery";
-import { UpdateQuery } from "../models/UpdateQuery";
-import { ParameterCollector } from "./ParameterCollector";
-export var ParameterStyle;
-(function (ParameterStyle) {
-    ParameterStyle["Anonymous"] = "anonymous";
-    ParameterStyle["Indexed"] = "indexed";
-    ParameterStyle["Named"] = "named";
-})(ParameterStyle || (ParameterStyle = {}));
+import { SqlFormatter } from './SqlFormatter';
+/**
+ * @deprecated The Formatter class is deprecated. Use SqlFormatter instead.
+ */
 export class Formatter {
     constructor() {
-        this.parameterIndex = 0;
-        this.handlers = new Map();
-        // Default settings
-        this.config = {
-            identifierEscape: {
-                start: '"',
-                end: '"'
-            },
+        this.sqlFormatter = new SqlFormatter({
+            identifierEscape: { start: '"', end: '"' },
             parameterSymbol: ':',
-            parameterStyle: ParameterStyle.Named,
-        };
-        // value
-        this.handlers.set(LiteralValue.kind, (expr) => this.visitLiteralExpression(expr));
-        this.handlers.set(RawString.kind, (expr) => this.visitRawString(expr));
-        this.handlers.set(StringSpecifierExpression.kind, (expr) => this.visitStringSpecifierExpression(expr));
-        this.handlers.set(IdentifierString.kind, (expr) => this.visitIdentifierString(expr));
-        this.handlers.set(SwitchCaseArgument.kind, (expr) => this.visitSwitchCaseArgument(expr));
-        this.handlers.set(ValueList.kind, (expr) => this.visitValueList(expr));
-        this.handlers.set(ColumnReference.kind, (expr) => this.visitColumnReference(expr));
-        this.handlers.set(FunctionCall.kind, (expr) => this.visitFunctionCall(expr));
-        this.handlers.set(UnaryExpression.kind, (expr) => this.visitUnaryExpression(expr));
-        this.handlers.set(BinaryExpression.kind, (expr) => this.visitBinaryExpression(expr));
-        this.handlers.set(ParameterExpression.kind, (expr) => this.visitParameterExpression(expr));
-        this.handlers.set(SelectItem.kind, (expr) => this.visitSelectItemExpression(expr));
-        this.handlers.set(ArrayExpression.kind, (expr) => this.visitArrayExpression(expr));
-        this.handlers.set(CaseExpression.kind, (expr) => this.visitCaseExpression(expr));
-        this.handlers.set(CastExpression.kind, (expr) => this.visitCastExpression(expr));
-        this.handlers.set(ParenExpression.kind, (expr) => this.visitBracketExpression(expr));
-        this.handlers.set(BetweenExpression.kind, (expr) => this.visitBetweenExpression(expr));
-        this.handlers.set(TypeValue.kind, (expr) => this.visitTypeValue(expr));
-        this.handlers.set(InlineQuery.kind, (expr) => this.visitInlineQuery(expr));
-        // source alias
-        this.handlers.set(SourceAliasExpression.kind, (expr) => this.visitSourceAliasExpression(expr));
-        // from
-        this.handlers.set(FromClause.kind, (expr) => this.visitFromClause(expr));
-        this.handlers.set(JoinClause.kind, (expr) => this.visitJoinClause(expr));
-        this.handlers.set(JoinOnClause.kind, (expr) => this.visitJoinOnClause(expr));
-        this.handlers.set(JoinUsingClause.kind, (expr) => this.visitJoinUsingClause(expr));
-        this.handlers.set(SourceExpression.kind, (expr) => this.visitSourceExpression(expr));
-        this.handlers.set(SubQuerySource.kind, (expr) => this.visitSubQuerySource(expr));
-        this.handlers.set(FunctionSource.kind, (expr) => this.visitFunctionSource(expr));
-        this.handlers.set(TableSource.kind, (expr) => this.visitTableSource(expr));
-        // order by
-        this.handlers.set(OrderByClause.kind, (expr) => this.visitOrderByClause(expr));
-        this.handlers.set(OrderByItem.kind, (expr) => this.visitOrderByItem(expr));
-        // partition by
-        this.handlers.set(PartitionByClause.kind, (expr) => this.visitPartitionByClause(expr));
-        // window frame
-        this.handlers.set(WindowFrameExpression.kind, (expr) => this.visitWindowFrameExpression(expr));
-        this.handlers.set(WindowFrameSpec.kind, (arg) => this.visitWindowFrameSpec(arg));
-        this.handlers.set(WindowFrameBoundStatic.kind, (arg) => this.visitWindowFrameBoundStatic(arg));
-        this.handlers.set(WindowFrameBoundaryValue.kind, (arg) => this.visitWindowFrameBoundaryValue(arg));
-        this.handlers.set(WindowFrameClause.kind, (arg) => this.visitWindowFrameClause(arg));
-        // where
-        this.handlers.set(WhereClause.kind, (expr) => this.visitWhereClause(expr));
-        // group by
-        this.handlers.set(GroupByClause.kind, (expr) => this.visitGroupByClause(expr));
-        this.handlers.set(HavingClause.kind, (expr) => this.visitHavingClause(expr));
-        // with
-        this.handlers.set(CommonTable.kind, (expr) => this.visitCommonTable(expr));
-        this.handlers.set(WithClause.kind, (expr) => this.visitWithClause(expr));
-        // select
-        this.handlers.set(SelectClause.kind, (expr) => this.visitSelectClause(expr));
-        this.handlers.set(Distinct.kind, (expr) => this.visitDistinct(expr));
-        this.handlers.set(DistinctOn.kind, (expr) => this.visitDistinctOn(expr));
-        // row limit
-        this.handlers.set(LimitClause.kind, (expr) => this.visitLimitClause(expr));
-        this.handlers.set(FetchSpecification.kind, (expr) => this.visitFetchSpecification(expr));
-        // for clause
-        this.handlers.set(ForClause.kind, (expr) => this.visitForClause(expr));
-        // values clause
-        this.handlers.set(ValuesQuery.kind, (expr) => this.visitValuesQuery(expr));
-        this.handlers.set(TupleExpression.kind, (expr) => this.visitTupleExpression(expr));
-        // select query
-        this.handlers.set(SimpleSelectQuery.kind, (expr) => this.visitSelectQuery(expr));
-        this.handlers.set(BinarySelectQuery.kind, (expr) => this.visitBinarySelectQuery(expr));
-        // create table query
-        this.handlers.set(CreateTableQuery.kind, (expr) => this.visitCreateTableQuery(expr));
-        // update query
-        this.handlers.set(UpdateQuery.kind, (expr) => this.visitUpdateQuery(expr));
-        this.handlers.set(UpdateClause.kind, (expr) => this.visitUpdateClause(expr));
-        this.handlers.set(SetClause.kind, (expr) => this.visitSetClause(expr));
-        this.handlers.set(SetClauseItem.kind, (expr) => this.visitSetClauseItem(expr));
-        this.handlers.set(ReturningClause.kind, (expr) => this.visitReturningClause(expr));
-        // insert query
-        this.handlers.set(InsertQuery.kind, (expr) => this.visitInsertQuery(expr));
-        this.handlers.set(InsertClause.kind, (expr) => this.visitInsertClause(expr));
+            parameterStyle: 'named' // Default to 'named' for backward compatibility
+        });
     }
-    /**
-     * Formats the given SQL AST node into a SQL string.
-     * This is the recommended public API for users.
-     * @param arg The root SQL AST node to format.
-     * @param config (Optional) Formatter configuration.
-     * @returns The formatted SQL string.
-     */
     format(arg, config = null) {
-        this.parameterIndex = 0; // Reset counter for each format
+        // Use the sqlFormatter instance to format the SQL component
         if (config) {
-            // Always reset to default before merging user config
-            this.config = Object.assign({ identifierEscape: { start: '"', end: '"' }, parameterSymbol: ':' }, config);
+            this.sqlFormatter = new SqlFormatter(config);
         }
-        return this.visit(arg);
+        const result = this.sqlFormatter.format(arg);
+        return result.formattedSql;
     }
     formatWithParameters(arg, config = null) {
-        var _a;
-        const sql = this.format(arg, config); // Sort parameters by index
-        const paramsRaw = ParameterCollector.collect(arg).sort((a, b) => { var _a, _b; return ((_a = a.index) !== null && _a !== void 0 ? _a : 0) - ((_b = b.index) !== null && _b !== void 0 ? _b : 0); });
-        const style = ((_a = this.config.parameterStyle) !== null && _a !== void 0 ? _a : ParameterStyle.Named);
-        if (style === ParameterStyle.Named) {
-            // Named: { name: value, ... }
-            const paramsObj = {};
-            for (const p of paramsRaw) {
-                const key = p.name.value;
-                if (paramsObj.hasOwnProperty(key)) {
-                    if (paramsObj[key] !== p.value) {
-                        throw new Error(`Duplicate parameter name '${key}' with different values detected during query composition.`);
-                    }
-                    // If value is the same, skip (already set)
-                    continue;
-                }
-                paramsObj[key] = p.value;
-            }
-            return { sql, params: paramsObj };
-        }
-        else if (style === ParameterStyle.Indexed) {
-            // Indexed: [value1, value2, ...] (sorted by index)
-            const paramsArr = paramsRaw.map(p => p.value);
-            return { sql, params: paramsArr };
-        }
-        else if (style === ParameterStyle.Anonymous) {
-            // Anonymous: [value1, value2, ...] (sorted by index, name is empty)
-            const paramsArr = paramsRaw.map(p => p.value);
-            return { sql, params: paramsArr };
+        // Use the sqlFormatter instance to format the SQL component with parameters
+        if (config) {
+            this.sqlFormatter = new SqlFormatter(config);
         }
-        // Fallback (just in case)
-        return { sql, params: [] };
+        const result = this.sqlFormatter.format(arg);
+        return { sql: result.formattedSql, params: result.params };
     }
-    /**
-     * Visitor entry point for SQL AST nodes.
-     * Note: This method is public only for interface compatibility.
-     *       Users should call the format() method instead of visit() directly.
-     *       (If you call visit() directly, you are basically breaking the abstraction, so don't do it!)
-     * @param arg The SQL AST node to visit.
-     * @returns The formatted SQL string for the node.
-     */
     visit(arg) {
-        var _a, _b;
-        const handler = this.handlers.get(arg.getKind());
-        if (handler) {
-            return handler(arg);
-        }
-        // Provide more detailed error message
-        const kindSymbol = ((_a = arg.getKind()) === null || _a === void 0 ? void 0 : _a.toString()) || 'unknown';
-        const constructor = ((_b = arg.constructor) === null || _b === void 0 ? void 0 : _b.name) || 'unknown';
-        throw new Error(`[Formatter] No handler for ${constructor} with kind ${kindSymbol}.`);
-    }
-    visitBinarySelectQuery(arg) {
-        const left = arg.left.accept(this);
-        const operator = arg.operator.accept(this);
-        const right = arg.right.accept(this);
-        return `${left} ${operator} ${right}`;
-    }
-    visitWindowFrameBoundaryValue(arg) {
-        const value = arg.value.accept(this);
-        const following = arg.isFollowing ? "following" : "preceding";
-        return `${value} ${following}`;
-    }
-    visitWindowFrameBoundStatic(arg) {
-        switch (arg.bound) {
-            case WindowFrameBound.UnboundedPreceding:
-                return "unbounded preceding";
-            case WindowFrameBound.CurrentRow:
-                return "current row";
-            case WindowFrameBound.UnboundedFollowing:
-                return "unbounded following";
-            default:
-                throw new Error(`Unknown WindowFrameBound: ${arg.bound}`);
-        }
-    }
-    visitWindowFrameExpression(arg) {
-        const partitionBy = arg.partition !== null ? arg.partition.accept(this) : null;
-        const orderBy = arg.order !== null ? arg.order.accept(this) : null;
-        const frameSpec = arg.frameSpec !== null ? arg.frameSpec.accept(this) : null;
-        const parts = [];
-        if (partitionBy)
-            parts.push(partitionBy);
-        if (orderBy)
-            parts.push(orderBy);
-        if (frameSpec)
-            parts.push(frameSpec);
-        if (parts.length > 0) {
-            return `(${parts.join(" ")})`;
-        }
-        return `()`;
-    }
-    visitWindowFrameSpec(arg) {
-        const frameType = arg.frameType;
-        const startBound = arg.startBound.accept(this);
-        if (arg.endBound === null) {
-            return `${frameType} ${startBound}`;
-        }
-        else {
-            const endBound = arg.endBound.accept(this);
-            return `${frameType} between ${startBound} and ${endBound}`;
-        }
-    }
-    visitJoinUsingClause(arg) {
-        return `using (${arg.condition.accept(this)})`;
-    }
-    visitJoinOnClause(arg) {
-        if (arg.condition !== null) {
-            return `on ${arg.condition.accept(this)}`;
-        }
-        return `on`;
-    }
-    visitTypeValue(arg) {
-        let typeStr = '';
-        if (arg.namespaces && arg.namespaces.length > 0) {
-            typeStr = arg.namespaces.map(ns => ns.accept(this)).join('.') + '.' + arg.name.accept(this);
-        }
-        else {
-            typeStr = arg.name.accept(this);
-        }
-        if (arg.argument !== null) {
-            return `${typeStr}(${arg.argument.accept(this)})`;
-        }
-        return `${typeStr}`;
-    }
-    visitStringSpecifierExpression(arg) {
-        return `${arg.specifier.accept(this)}${arg.value.accept(this)}`;
-    }
-    visitWithClause(arg) {
-        const part = arg.tables.map((e) => e.accept(this)).join(", ");
-        if (arg.recursive) {
-            return `with recursive ${part}`;
-        }
-        return `with ${part}`;
-    }
-    visitCommonTable(arg) {
-        const alias = arg.aliasExpression.accept(this);
-        const materil = arg.materialized === null
-            ? ''
-            : arg.materialized ? 'materialized' : 'not materialized';
-        if (alias && materil) {
-            return `${alias} ${materil} as (${arg.query.accept(this)})`;
-        }
-        return `${alias} as (${arg.query.accept(this)})`;
-    }
-    visitDistinctOn(arg) {
-        return `distinct on(${arg.value.accept(this)})`;
-    }
-    visitDistinct(arg) {
-        return `distinct`;
-    }
-    visitHavingClause(arg) {
-        return `having ${arg.condition.accept(this)}`;
-    }
-    visitGroupByClause(arg) {
-        const part = arg.grouping.map((e) => e.accept(this)).join(", ");
-        return `group by ${part}`;
-    }
-    visitFromClause(arg) {
-        if (arg.joins !== null && arg.joins.length > 0) {
-            const part = arg.joins.map((e) => e.accept(this)).join(" ");
-            return `from ${arg.source.accept(this)} ${part}`;
-        }
-        return `from ${arg.source.accept(this)}`;
-    }
-    visitJoinClause(arg) {
-        const joinType = `${arg.joinType.accept(this)}`;
-        const lateral = arg.lateral === true ? ` lateral` : "";
-        const joinSource = arg.source.accept(this);
-        const condition = arg.condition !== null ? ` ${arg.condition.accept(this)}` : "";
-        return `${joinType}${lateral} ${joinSource}${condition}`;
-    }
-    visitSourceAliasExpression(arg) {
-        const columnAlias = arg.columns !== null ? `(${arg.columns.map((e) => e.accept(this)).join(", ")})` : null;
-        const tableAlias = arg.table !== null ? `${arg.table.accept(this)}` : "";
-        if (columnAlias && tableAlias) {
-            return `${tableAlias}${columnAlias}`;
-        }
-        if (tableAlias) {
-            return tableAlias;
-        }
-        throw new Error("Invalid SourceAliasExpression: tableAlias is null");
-    }
-    visitSourceExpression(arg) {
-        let alias = arg.aliasExpression !== null ? `${arg.aliasExpression.accept(this)}` : "";
-        // Avoid duplicate alias if the name is the same as the alias
-        if (arg.datasource instanceof TableSource) {
-            if (arg.aliasExpression !== null && arg.datasource.identifier !== null && arg.datasource.identifier.accept(this) === arg.aliasExpression.accept(this)) {
-                alias = "";
-            }
-        }
-        if (alias) {
-            return `${arg.datasource.accept(this)} as ${alias}`;
-        }
-        return `${arg.datasource.accept(this)}`;
-    }
-    visitSubQuerySource(arg) {
-        return `(${arg.query.accept(this)})`;
-    }
-    visitFunctionSource(arg) {
-        if (arg.argument !== null) {
-            return `${arg.name.accept(this)}(${arg.argument.accept(this)})`;
-        }
-        return `${arg.name.accept(this)}()`;
-    }
-    visitTableSource(arg) {
-        if (arg.namespaces !== null) {
-            return `${arg.namespaces.map((ns) => `${ns.accept(this)}`).join(".")}.${arg.table.accept(this)}`;
-        }
-        return `${arg.table.accept(this)}`;
-    }
-    visitValueList(arg) {
-        return `${arg.values.map((v) => v.accept(this)).join(", ")}`;
-    }
-    visitSwitchCaseArgument(arg) {
-        const casePart = arg.cases.map((kv) => `when ${kv.key.accept(this)} then ${kv.value.accept(this)}`).join(" ");
-        const elsePart = arg.elseValue ? ` else ${arg.elseValue.accept(this)}` : "";
-        return `${casePart}${elsePart}`;
-    }
-    visitColumnReference(arg) {
-        if (arg.namespaces != null) {
-            return `${arg.namespaces.map((ns) => `${ns.accept(this)}`).join(".")}.${arg.column.accept(this)}`;
-        }
-        return `${arg.column.accept(this)}`;
-    }
-    visitFunctionCall(arg) {
-        const partArg = arg.argument !== null ? arg.argument.accept(this) : "";
-        let funcName;
-        if (arg.namespaces && arg.namespaces.length > 0) {
-            funcName = arg.namespaces.map(ns => ns.accept(this)).join(".") + "." + arg.name.accept(this);
-        }
-        else {
-            funcName = arg.name.accept(this);
-        }
-        if (arg.over === null) {
-            return `${funcName}(${partArg})`;
-        }
-        else {
-            let partOver = arg.over !== null ? `${arg.over.accept(this)}` : "";
-            if (partOver) {
-                if (partOver.startsWith("(")) {
-                    partOver = ` over${partOver}`;
-                }
-                else {
-                    partOver = ` over ${partOver}`;
-                }
-            }
-            return `${funcName}(${partArg})${partOver}`;
-        }
-    }
-    visitUnaryExpression(arg) {
-        return `${arg.operator.accept(this)} ${arg.expression.accept(this)}`;
-    }
-    visitBinaryExpression(arg) {
-        return `${arg.left.accept(this)} ${arg.operator.accept(this)} ${arg.right.accept(this)}`;
-    }
-    visitLiteralExpression(arg) {
-        if (typeof arg.value === "string") {
-            return `'${arg.value.replace(/'/g, "''")}'`;
-        }
-        else if (arg.value === null) {
-            return "null";
-        }
-        return arg.value.toString();
-    }
-    visitParameterExpression(arg) {
-        var _a, _b;
-        // update index
-        arg.index = this.parameterIndex;
-        this.parameterIndex++;
-        // Decide output style based on config
-        const style = (_a = this.config.parameterStyle) !== null && _a !== void 0 ? _a : ParameterStyle.Named;
-        if (style === ParameterStyle.Anonymous) {
-            return '?';
-        }
-        if (style === ParameterStyle.Indexed) {
-            return `$${arg.index + 1}`; // 0-based to 1-based
-        }
-        // Named (default)
-        if (typeof this.config.parameterSymbol === 'object' && this.config.parameterSymbol !== null) {
-            return `${this.config.parameterSymbol.start}${arg.name.accept(this)}${this.config.parameterSymbol.end}`;
-        }
-        return `${(_b = this.config.parameterSymbol) !== null && _b !== void 0 ? _b : ':'}${arg.name.accept(this)}`;
-    }
-    visitSelectItemExpression(arg) {
-        if (arg.identifier) {
-            if (arg.value instanceof ColumnReference) {
-                const c = arg.value;
-                if (c.column.name === arg.identifier.name) {
-                    return `${arg.value.accept(this)}`;
-                }
-                else {
-                    return `${arg.value.accept(this)} as ${arg.identifier.accept(this)}`;
-                }
-            }
-            return `${arg.value.accept(this)} as ${arg.identifier.accept(this)}`;
-        }
-        return arg.value.accept(this);
-    }
-    visitSelectClause(arg) {
-        const distinct = arg.distinct !== null ? " " + arg.distinct.accept(this) : "";
-        const colum = arg.items.map((e) => e.accept(this)).join(", ");
-        return `select${distinct} ${colum}`;
-    }
-    visitSelectQuery(arg) {
-        const parts = [];
-        // WITH
-        if (arg.WithClause !== null) {
-            parts.push(arg.WithClause.accept(this));
-        }
-        parts.push(arg.selectClause.accept(this));
-        if (arg.fromClause !== null) {
-            parts.push(arg.fromClause.accept(this));
-        }
-        if (arg.whereClause !== null) {
-            parts.push(arg.whereClause.accept(this));
-        }
-        if (arg.groupByClause !== null) {
-            parts.push(arg.groupByClause.accept(this));
-        }
-        if (arg.havingClause !== null) {
-            parts.push(arg.havingClause.accept(this));
-        }
-        if (arg.windowFrameClause !== null) {
-            parts.push(arg.windowFrameClause.accept(this));
-        }
-        if (arg.orderByClause !== null) {
-            parts.push(arg.orderByClause.accept(this));
-        }
-        if (arg.rowLimitClause !== null) {
-            parts.push(arg.rowLimitClause.accept(this));
-        }
-        if (arg.forClause !== null) {
-            parts.push(arg.forClause.accept(this));
-        }
-        return parts.join(" ");
-    }
-    visitArrayExpression(arg) {
-        return `array[${arg.expression.accept(this)}]`;
-    }
-    visitCaseExpression(arg) {
-        if (arg.condition !== null) {
-            return `case ${arg.condition.accept(this)} ${arg.switchCase.accept(this)} end`;
-        }
-        return `case ${arg.switchCase.accept(this)} end`;
-    }
-    visitCastExpression(arg) {
-        return `${arg.input.accept(this)}::${arg.castType.accept(this)}`;
-    }
-    visitBracketExpression(arg) {
-        return `(${arg.expression.accept(this)})`;
-    }
-    visitBetweenExpression(arg) {
-        if (arg.negated) {
-            return `${arg.expression.accept(this)} not between ${arg.lower.accept(this)} and ${arg.upper.accept(this)}`;
-        }
-        return `${arg.expression.accept(this)} between ${arg.lower.accept(this)} and ${arg.upper.accept(this)}`;
-    }
-    visitPartitionByClause(arg) {
-        return `partition by ${arg.value.accept(this)}`;
-    }
-    visitOrderByClause(arg) {
-        const part = arg.order.map((e) => e.accept(this)).join(", ");
-        return `order by ${part}`;
-    }
-    visitOrderByItem(arg) {
-        const direction = arg.sortDirection === SortDirection.Ascending ? null : "desc";
-        const nullsOption = arg.nullsPosition !== null ? (arg.nullsPosition === NullsSortDirection.First ? "nulls first" : "nulls last") : null;
-        if (direction !== null && nullsOption !== null) {
-            return `${arg.value.accept(this)} ${direction} ${nullsOption}`;
-        }
-        else if (direction !== null) {
-            return `${arg.value.accept(this)} ${direction}`;
-        }
-        else if (nullsOption !== null) {
-            return `${arg.value.accept(this)} ${nullsOption}`;
-        }
-        return arg.value.accept(this);
-    }
-    visitWindowFrameClause(arg) {
-        const partExpr = arg.expression.accept(this);
-        return `window ${arg.name.accept(this)} as ${partExpr}`;
-    }
-    visitLimitClause(arg) {
-        if (arg.offset !== null) {
-            return `limit ${arg.limit.accept(this)} offset ${arg.offset.accept(this)}`;
-        }
-        return `limit ${arg.limit.accept(this)}`;
-    }
-    visitFetchSpecification(arg) {
-        const type = arg.type === FetchType.First ? 'first' : 'next';
-        const count = arg.count.accept(this);
-        if (arg.unit !== null) {
-            return `fetch ${type} ${count} ${arg.unit}`;
-        }
-        return `fetch ${type} ${count}`;
-    }
-    visitForClause(arg) {
-        return `for ${arg.lockMode}`;
-    }
-    visitWhereClause(arg) {
-        return `where ${arg.condition.accept(this)}`;
-    }
-    visitInlineQuery(arg) {
-        return `(${arg.selectQuery.accept(this)})`;
-    }
-    visitRawString(arg) {
-        const invalidChars = new Set(["'", '"', ",", ";", ":", ".", "--", "/*"]);
-        if (invalidChars.has(arg.value)) {
-            throw new Error(`invalid keyword: ${arg.value} `);
-        }
-        else if (arg.value.trim() === "") {
-            throw new Error("invalid keyword: empty string");
-        }
-        return arg.value.trim();
-    }
-    visitIdentifierString(arg) {
-        var _a;
-        // No need to escape wildcards
-        if (arg.name === '*') {
-            return arg.name;
-        }
-        const escape = (_a = this.config.identifierEscape) !== null && _a !== void 0 ? _a : { start: '"', end: '"' };
-        return `${escape.start}${arg.name}${escape.end}`;
-    }
-    visitValuesQuery(arg) {
-        const tuples = arg.tuples.map((tuple) => tuple.accept(this)).join(", ");
-        return `values ${tuples}`;
-    }
-    visitTupleExpression(arg) {
-        const values = arg.values.map((value) => value.accept(this)).join(", ");
-        return `(${values})`;
-    }
-    /**
-     * Formats a CreateTableQuery into SQL string.
-     */
-    visitCreateTableQuery(arg) {
-        const temp = arg.isTemporary ? "temporary " : "";
-        let sql = `create ${temp}table ${arg.tableName.accept(this)}`;
-        if (arg.asSelectQuery) {
-            sql += ` as ${this.visit(arg.asSelectQuery)}`;
-        }
-        return sql;
-    }
-    visitInsertQuery(arg) {
-        const parts = [];
-        parts.push(arg.insertClause.accept(this));
-        if (arg.selectQuery) {
-            parts.push(arg.selectQuery.accept(this));
-        }
-        else {
-            throw new Error("InsertQuery must have selectQuery (SELECT or VALUES)");
-        }
-        return parts.join(" ");
-    }
-    visitUpdateQuery(arg) {
-        // Format: [WITH ...] UPDATE [source] SET ... [FROM ...] [WHERE ...] [RETURNING ...]
-        const parts = [];
-        // Add WITH clause if present
-        if (arg.withClause) {
-            parts.push(arg.withClause.accept(this));
-        }
-        // updateClause (SourceExpression) を使う
-        parts.push(arg.updateClause.accept(this));
-        if (arg.setClause.items.length === 0) {
-            throw new Error("UpdateQuery must have setClause");
-        }
-        parts.push(arg.setClause.accept(this));
-        if (arg.fromClause) {
-            parts.push(arg.fromClause.accept(this));
-        }
-        if (arg.whereClause) {
-            parts.push(arg.whereClause.accept(this));
-        }
-        if (arg.returningClause) {
-            parts.push(arg.returningClause.accept(this));
-        }
-        return parts.join(" ");
-    }
-    visitUpdateClause(arg) {
-        // Format: UPDATE table [AS alias]
-        const table = arg.source.accept(this);
-        return `update ${table}`;
-    }
-    visitSetClause(arg) {
-        // Format: SET col1 = val1, col2 = val2, ...
-        const items = arg.items.map(item => item.accept(this)).join(", ");
-        return `set ${items}`;
-    }
-    visitSetClauseItem(arg) {
-        // Format: col1 = val1 (with optional namespaces)
-        let column;
-        if (arg.namespaces && arg.namespaces.length > 0) {
-            column = arg.namespaces.map(ns => ns.accept(this)).join(".") + "." + arg.column.accept(this);
-        }
-        else {
-            column = arg.column.accept(this);
-        }
-        const value = arg.value.accept(this);
-        return `${column} = ${value}`;
-    }
-    visitReturningClause(arg) {
-        // Format: RETURNING col1, col2, ...
-        const columns = arg.columns.map(col => col.accept(this)).join(", ");
-        return `returning ${columns}`;
-    }
-    visitInsertClause(arg) {
-        const table = arg.source.accept(this);
-        const columns = arg.columns.map(col => new IdentifierString(col).accept(this)).join(", ");
-        if (arg.columns.length > 0) {
-            return `insert into ${table}(${columns})`;
-        }
-        else {
-            return `insert into ${table}`;
-        }
+        return this.format(arg);
     }
 }
-/**
- * Preset configs for common DB dialects.
- */
-Formatter.PRESETS = {
-    mysql: {
-        identifierEscape: { start: '`', end: '`' },
-        parameterSymbol: '?',
-        parameterStyle: ParameterStyle.Anonymous,
-    },
-    postgres: {
-        identifierEscape: { start: '"', end: '"' },
-        parameterSymbol: ':',
-        parameterStyle: ParameterStyle.Indexed,
-    },
-    sqlserver: {
-        identifierEscape: { start: '[', end: ']' },
-        parameterSymbol: '@',
-        parameterStyle: ParameterStyle.Named,
-    },
-    sqlite: {
-        identifierEscape: { start: '"', end: '"' },
-        parameterSymbol: ':',
-        parameterStyle: ParameterStyle.Named,
-    },
-};
+export { SqlFormatter };
 //# sourceMappingURL=Formatter.js.map