@shaxpir/squilt 1.0.0

package/dist/visitor/ParamCollector.d.ts

@@ -0,0 +1,46 @@
+import { AliasableExpression } from "../ast/Abstractions";
+import { Alias } from "../ast/Alias";
+import { BinaryExpression } from "../ast/BinaryExpression";
+import { CaseExpression } from "../ast/CaseExpression";
+import { Column } from "../ast/Column";
+import { Concat } from "../ast/Concat";
+import { ExistsExpression } from "../ast/ExistsExpression";
+import { From, JsonEachFrom, SubqueryFrom, TableFrom } from "../ast/From";
+import { FunctionExpression } from "../ast/FunctionExpression";
+import { InExpression } from "../ast/InExpression";
+import { InsertQuery } from "../ast/InsertQuery";
+import { Join } from "../ast/Join";
+import { NullLiteral, NumberLiteral, Param, StringLiteral } from "../ast/Literals";
+import { OrderBy } from "../ast/OrderBy";
+import { SelectQuery } from "../ast/SelectQuery";
+import { UnaryExpression } from "../ast/UnaryExpression";
+import { With } from "../ast/With";
+import { ColumnLikeVisitorAcceptor, FromLikeAndJoinVisitorAcceptor, SqlTreeNodeVisitor } from "./SqlTreeNodeVisitor";
+export declare class ParamCollectingVisitor implements SqlTreeNodeVisitor<any[]> {
+    protected fromLikeAndJoinAcceptor: FromLikeAndJoinVisitorAcceptor<any[]>;
+    protected columnLikeAcceptor: ColumnLikeVisitorAcceptor<any[]>;
+    private readonly keyValuePairs;
+    private readonly params;
+    constructor(keyValuePairs: Record<string, any>);
+    visitInsertQuery(node: InsertQuery): any[];
+    visitSelectQuery(node: SelectQuery): any[];
+    visitTableFrom(_node: TableFrom): any[];
+    visitSubqueryFrom(node: SubqueryFrom): any[];
+    visitJsonEachFrom(node: JsonEachFrom): any[];
+    visitColumn(_node: Column): any[];
+    visitAlias(node: Alias<From | AliasableExpression>): any[];
+    visitJoinClause(node: Join): any[];
+    visitOrderBy(node: OrderBy): any[];
+    visitWithClause(node: With): any[];
+    visitBinaryExpression(node: BinaryExpression): any[];
+    visitUnaryExpression(node: UnaryExpression): any[];
+    visitInExpression(node: InExpression): any[];
+    visitConcat(node: Concat): any[];
+    visitCaseExpression(node: CaseExpression): any[];
+    visitFunctionExpression(node: FunctionExpression): any[];
+    visitParamExpression(node: Param): any[];
+    visitStringLiteral(_node: StringLiteral): any[];
+    visitNumberLiteral(_node: NumberLiteral): any[];
+    visitNullLiteral(_node: NullLiteral): any[];
+    visitExistsExpression(node: ExistsExpression): any[];
+}

package/dist/visitor/ParamCollector.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamCollectingVisitor = void 0;
+const SelectQuery_1 = require("../ast/SelectQuery");
+const SqlTreeNodeVisitor_1 = require("./SqlTreeNodeVisitor");
+class ParamCollectingVisitor {
+    constructor(keyValuePairs) {
+        this.fromLikeAndJoinAcceptor = new SqlTreeNodeVisitor_1.FromLikeAndJoinVisitorAcceptor();
+        this.columnLikeAcceptor = new SqlTreeNodeVisitor_1.ColumnLikeVisitorAcceptor();
+        this.params = [];
+        this.keyValuePairs = keyValuePairs;
+    }
+    visitInsertQuery(node) {
+        node['_values'].forEach(v => v.accept(this));
+        return this.params;
+    }
+    visitSelectQuery(node) {
+        node['_with'].forEach(w => w.accept(this));
+        node['_fromsAndJoins'].forEach(item => this.fromLikeAndJoinAcceptor.accept(this, item));
+        node['_columns'].forEach(c => this.columnLikeAcceptor.accept(this, c));
+        if (node['_where']) {
+            node['_where'].accept(this);
+        }
+        node['_groupBy'].forEach(c => c.accept(this));
+        if (node['_having']) {
+            node['_having'].accept(this);
+        }
+        node['_union'].forEach(u => u.accept(this));
+        node['_orderBy'].forEach(o => o.accept(this));
+        return this.params;
+    }
+    visitTableFrom(_node) {
+        return this.params;
+    }
+    visitSubqueryFrom(node) {
+        node.subquery.accept(this);
+        return this.params;
+    }
+    visitJsonEachFrom(node) {
+        node.jsonExpression.accept(this);
+        if (node.jsonPath) {
+            node.jsonPath.accept(this);
+        }
+        return this.params;
+    }
+    visitColumn(_node) {
+        return this.params;
+    }
+    visitAlias(node) {
+        node.referent.accept(this);
+        return this.params;
+    }
+    visitJoinClause(node) {
+        node.on.accept(this);
+        return this.params;
+    }
+    visitOrderBy(node) {
+        node.column.accept(this);
+        return this.params;
+    }
+    visitWithClause(node) {
+        node.query.accept(this);
+        return this.params;
+    }
+    visitBinaryExpression(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+        return this.params;
+    }
+    visitUnaryExpression(node) {
+        node.operand.accept(this);
+        return this.params;
+    }
+    visitInExpression(node) {
+        node.left.forEach(l => l.accept(this));
+        if (node.values instanceof SelectQuery_1.SelectQuery) {
+            node.values.accept(this);
+        }
+        else {
+            node.values.forEach(set => set.forEach(v => v.accept(this)));
+        }
+        return this.params;
+    }
+    visitConcat(node) {
+        node.expressions.forEach(e => e.accept(this));
+        return this.params;
+    }
+    visitCaseExpression(node) {
+        node.cases.forEach(c => {
+            c.when.accept(this);
+            c.then.accept(this);
+        });
+        if (node.else) {
+            node.else.accept(this);
+        }
+        return this.params;
+    }
+    visitFunctionExpression(node) {
+        node.args.forEach(a => a.accept(this));
+        return this.params;
+    }
+    visitParamExpression(node) {
+        if (node.paramName) {
+            if (!this.keyValuePairs || typeof this.keyValuePairs !== 'object' || !(node.paramName in this.keyValuePairs)) {
+                throw new Error(`No value provided for parameter: ${node.paramName}`);
+            }
+            this.params.push(this.keyValuePairs[node.paramName]);
+        }
+        else {
+            this.params.push(undefined);
+        }
+        return this.params;
+    }
+    visitStringLiteral(_node) {
+        return this.params;
+    }
+    visitNumberLiteral(_node) {
+        return this.params;
+    }
+    visitNullLiteral(_node) {
+        return this.params;
+    }
+    visitExistsExpression(node) {
+        node.subquery.accept(this);
+        return this.params;
+    }
+}
+exports.ParamCollectingVisitor = ParamCollectingVisitor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ParamCollector.js","sourceRoot":"","sources":["../../src/visitor/ParamCollector.ts"],"names":[],"mappings":"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","sourcesContent":["import { AliasableExpression } from \"../ast/Abstractions\";\nimport { Alias } from \"../ast/Alias\";\nimport { BinaryExpression } from \"../ast/BinaryExpression\";\nimport { CaseExpression } from \"../ast/CaseExpression\";\nimport { Column } from \"../ast/Column\";\nimport { Concat } from \"../ast/Concat\";\nimport { ExistsExpression } from \"../ast/ExistsExpression\";\nimport { From, JsonEachFrom, SubqueryFrom, TableFrom } from \"../ast/From\";\nimport { FunctionExpression } from \"../ast/FunctionExpression\";\nimport { InExpression } from \"../ast/InExpression\";\nimport { InsertQuery } from \"../ast/InsertQuery\";\nimport { Join } from \"../ast/Join\";\nimport { NullLiteral, NumberLiteral, Param, StringLiteral } from \"../ast/Literals\";\nimport { OrderBy } from \"../ast/OrderBy\";\nimport { SelectQuery } from \"../ast/SelectQuery\";\nimport { UnaryExpression } from \"../ast/UnaryExpression\";\nimport { With } from \"../ast/With\";\nimport { ColumnLikeVisitorAcceptor, FromLikeAndJoinVisitorAcceptor, SqlTreeNodeVisitor } from \"./SqlTreeNodeVisitor\";\n\nexport class ParamCollectingVisitor implements SqlTreeNodeVisitor<any[]> {\n\n  protected fromLikeAndJoinAcceptor = new FromLikeAndJoinVisitorAcceptor<any[]>();\n  protected columnLikeAcceptor = new ColumnLikeVisitorAcceptor<any[]>();\n\n  private readonly keyValuePairs: Record<string, any>;\n  private readonly params: any[] = [];\n\n  constructor(keyValuePairs: Record<string, any>) {\n    this.keyValuePairs = keyValuePairs;\n  }\n\n  visitInsertQuery(node: InsertQuery): any[] {\n    node['_values'].forEach(v => v.accept(this));\n    return this.params;\n  }\n\n  visitSelectQuery(node: SelectQuery): any[] {\n    node['_with'].forEach(w => w.accept(this));\n    node['_fromsAndJoins'].forEach(item => this.fromLikeAndJoinAcceptor.accept(this, item));\n    node['_columns'].forEach(c => this.columnLikeAcceptor.accept(this, c));\n    if (node['_where']) {\n      node['_where'].accept(this);\n    }\n    node['_groupBy'].forEach(c => c.accept(this));\n    if (node['_having']) {\n      node['_having'].accept(this);\n    }\n    node['_union'].forEach(u => u.accept(this));\n    node['_orderBy'].forEach(o => o.accept(this));\n    return this.params;\n  }\n\n  visitTableFrom(_node: TableFrom): any[] {\n    return this.params;\n  }\n\n  visitSubqueryFrom(node: SubqueryFrom): any[] {\n    node.subquery.accept(this);\n    return this.params;\n  }\n\n  visitJsonEachFrom(node: JsonEachFrom): any[] {\n    node.jsonExpression.accept(this);\n    if (node.jsonPath) {\n      node.jsonPath.accept(this);\n    }\n    return this.params;\n  }\n\n  visitColumn(_node: Column): any[] {\n    return this.params;\n  }\n\n  visitAlias(node: Alias<From|AliasableExpression>): any[] {\n    node.referent.accept(this);\n    return this.params;\n  }\n\n  visitJoinClause(node: Join): any[] {\n    node.on.accept(this);\n    return this.params;\n  }\n\n  visitOrderBy(node: OrderBy): any[] {\n    node.column.accept(this);\n    return this.params;\n  }\n\n  visitWithClause(node: With): any[] {\n    node.query.accept(this);\n    return this.params;\n  }\n\n  visitBinaryExpression(node: BinaryExpression): any[] {\n    node.left.accept(this);\n    node.right.accept(this);\n    return this.params;\n  }\n\n  visitUnaryExpression(node: UnaryExpression): any[] {\n    node.operand.accept(this);\n    return this.params;\n  }\n\n  visitInExpression(node: InExpression): any[] {\n    node.left.forEach(l => l.accept(this));\n    if (node.values instanceof SelectQuery) {\n      node.values.accept(this);\n    } else {\n      node.values.forEach(set => set.forEach(v => v.accept(this)));\n    }\n    return this.params;\n  }\n\n  visitConcat(node: Concat): any[] {\n    node.expressions.forEach(e => e.accept(this));\n    return this.params;\n  }\n\n  visitCaseExpression(node: CaseExpression): any[] {\n    node.cases.forEach(c => {\n      c.when.accept(this);\n      c.then.accept(this);\n    });\n    if (node.else) {\n      node.else.accept(this);\n    }\n    return this.params;\n  }\n\n  visitFunctionExpression(node: FunctionExpression): any[] {\n    node.args.forEach(a => a.accept(this));\n    return this.params;\n  }\n\n  visitParamExpression(node: Param): any[] {\n    if (node.paramName) {\n      if (!this.keyValuePairs || typeof this.keyValuePairs !== 'object' || !(node.paramName in this.keyValuePairs)) {\n        throw new Error(`No value provided for parameter: ${node.paramName}`);\n      }\n      this.params.push(this.keyValuePairs[node.paramName]);\n    } else {\n      this.params.push(undefined);\n    }\n    return this.params;\n  }\n\n  visitStringLiteral(_node: StringLiteral): any[] {\n    return this.params;\n  }\n\n  visitNumberLiteral(_node: NumberLiteral): any[] {\n    return this.params;\n  }\n\n  visitNullLiteral(_node: NullLiteral): any[] {\n    return this.params;\n  }\n\n  visitExistsExpression(node: ExistsExpression): any[] {\n    node.subquery.accept(this);\n    return this.params;\n  }\n}\n"]}

package/dist/visitor/QueryIdentityTransformer.d.ts

@@ -0,0 +1,45 @@
+import { Aliasable, SqlTreeNode } from "../ast/Abstractions";
+import { Alias } from "../ast/Alias";
+import { BinaryExpression } from "../ast/BinaryExpression";
+import { CaseExpression } from "../ast/CaseExpression";
+import { Column } from "../ast/Column";
+import { Concat } from "../ast/Concat";
+import { ExistsExpression } from "../ast/ExistsExpression";
+import { JsonEachFrom, SubqueryFrom, TableFrom } from "../ast/From";
+import { FunctionExpression } from "../ast/FunctionExpression";
+import { InExpression } from "../ast/InExpression";
+import { InsertQuery } from "../ast/InsertQuery";
+import { Join } from "../ast/Join";
+import { NullLiteral, NumberLiteral, Param, StringLiteral } from "../ast/Literals";
+import { OrderBy } from "../ast/OrderBy";
+import { SelectQuery } from "../ast/SelectQuery";
+import { UnaryExpression } from "../ast/UnaryExpression";
+import { With } from "../ast/With";
+import { SqlTreeNodeTransformer } from "./SqlTreeNodeTransformer";
+export declare class QueryIdentityTransformer implements SqlTreeNodeTransformer {
+    transform(node: SqlTreeNode): SqlTreeNode;
+    protected expectSingle<T extends SqlTreeNode>(result: SqlTreeNode | SqlTreeNode[], typeName: string): T;
+    protected flatList(results: (SqlTreeNode | SqlTreeNode[])[]): SqlTreeNode[];
+    protected flatList2D(results: (SqlTreeNode | SqlTreeNode[])[][]): SqlTreeNode[][];
+    visitSelectQuery(node: SelectQuery): SqlTreeNode | SqlTreeNode[];
+    visitInsertQuery(node: InsertQuery): SqlTreeNode | SqlTreeNode[];
+    visitTableFrom(node: TableFrom): SqlTreeNode | SqlTreeNode[];
+    visitSubqueryFrom(node: SubqueryFrom): SqlTreeNode | SqlTreeNode[];
+    visitJsonEachFrom(node: JsonEachFrom): SqlTreeNode | SqlTreeNode[];
+    visitColumn(node: Column): SqlTreeNode | SqlTreeNode[];
+    visitAlias<T extends Aliasable>(node: Alias<T>): SqlTreeNode | SqlTreeNode[];
+    visitJoinClause(node: Join): SqlTreeNode | SqlTreeNode[];
+    visitOrderBy(node: OrderBy): SqlTreeNode | SqlTreeNode[];
+    visitWithClause(node: With): SqlTreeNode | SqlTreeNode[];
+    visitBinaryExpression(node: BinaryExpression): SqlTreeNode | SqlTreeNode[];
+    visitUnaryExpression(node: UnaryExpression): SqlTreeNode | SqlTreeNode[];
+    visitInExpression(node: InExpression): SqlTreeNode | SqlTreeNode[];
+    visitConcat(node: Concat): SqlTreeNode | SqlTreeNode[];
+    visitCaseExpression(node: CaseExpression): SqlTreeNode | SqlTreeNode[];
+    visitFunctionExpression(node: FunctionExpression): SqlTreeNode | SqlTreeNode[];
+    visitParamExpression(node: Param): SqlTreeNode | SqlTreeNode[];
+    visitStringLiteral(node: StringLiteral): SqlTreeNode | SqlTreeNode[];
+    visitNumberLiteral(node: NumberLiteral): SqlTreeNode | SqlTreeNode[];
+    visitNullLiteral(node: NullLiteral): SqlTreeNode | SqlTreeNode[];
+    visitExistsExpression(node: ExistsExpression): SqlTreeNode | SqlTreeNode[];
+}

package/dist/visitor/QueryIdentityTransformer.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryIdentityTransformer = void 0;
+const Alias_1 = require("../ast/Alias");
+const BinaryExpression_1 = require("../ast/BinaryExpression");
+const CaseExpression_1 = require("../ast/CaseExpression");
+const Column_1 = require("../ast/Column");
+const Concat_1 = require("../ast/Concat");
+const ExistsExpression_1 = require("../ast/ExistsExpression");
+const From_1 = require("../ast/From");
+const FunctionExpression_1 = require("../ast/FunctionExpression");
+const InExpression_1 = require("../ast/InExpression");
+const InsertQuery_1 = require("../ast/InsertQuery");
+const Join_1 = require("../ast/Join");
+const Literals_1 = require("../ast/Literals");
+const OrderBy_1 = require("../ast/OrderBy");
+const SelectQuery_1 = require("../ast/SelectQuery");
+const UnaryExpression_1 = require("../ast/UnaryExpression");
+const With_1 = require("../ast/With");
+class QueryIdentityTransformer {
+    transform(node) {
+        const result = node.accept(this);
+        if (Array.isArray(result)) {
+            throw new Error('Top-level transformation must return a single SqlTreeNode');
+        }
+        return result;
+    }
+    expectSingle(result, typeName) {
+        if (Array.isArray(result)) {
+            throw new Error(`Unexpected array in single-node context for ${typeName}`);
+        }
+        return result;
+    }
+    flatList(results) {
+        return results.flatMap(r => Array.isArray(r) ? r : [r]);
+    }
+    flatList2D(results) {
+        return results.map(set => this.flatList(set));
+    }
+    visitSelectQuery(node) {
+        const newQuery = new SelectQuery_1.SelectQuery();
+        newQuery['_distinct'] = node['_distinct'];
+        newQuery['_with'] = this.flatList(node['_with'].map(w => w.accept(this)));
+        newQuery['_fromsAndJoins'] = node['_fromsAndJoins'].map(fj => {
+            if (fj && typeof fj === 'object' && 'referent' in fj && 'alias' in fj) {
+                return new Alias_1.Alias(this.expectSingle(fj.referent.accept(this), 'referent'), fj.alias);
+            }
+            else if (fj && typeof fj === 'object' && 'accept' in fj) {
+                return this.expectSingle(fj.accept(this), 'from/join');
+            }
+            else {
+                throw new Error('Invalid from/join object');
+            }
+        });
+        newQuery['_columns'] = node['_columns'].map(c => {
+            if (c && typeof c === 'object' && 'referent' in c && 'alias' in c) {
+                return new Alias_1.Alias(this.expectSingle(c.referent.accept(this), 'referent'), c.alias);
+            }
+            else if (c && typeof c === 'object' && 'accept' in c) {
+                return this.expectSingle(c.accept(this), 'column');
+            }
+            else {
+                throw new Error('Invalid column object');
+            }
+        });
+        if (node['_where'])
+            newQuery['_where'] = this.expectSingle(node['_where'].accept(this), 'WHERE');
+        newQuery['_groupBy'] = this.flatList(node['_groupBy'].map(g => g.accept(this)));
+        if (node['_having'])
+            newQuery['_having'] = this.expectSingle(node['_having'].accept(this), 'HAVING');
+        newQuery['_union'] = this.flatList(node['_union'].map(u => u.accept(this)));
+        newQuery['_orderBy'] = this.flatList(node['_orderBy'].map(o => o.accept(this)));
+        newQuery['_offset'] = node['_offset'];
+        newQuery['_limit'] = node['_limit'];
+        return newQuery;
+    }
+    visitInsertQuery(node) {
+        const newQuery = new InsertQuery_1.InsertQuery(node['_tableName']);
+        newQuery['_orReplace'] = node['_orReplace'];
+        newQuery['_columns'] = [...node['_columns']]; // Strings, reuse
+        newQuery['_values'] = this.flatList(node['_values'].map(v => v.accept(this)));
+        return newQuery;
+    }
+    visitTableFrom(node) {
+        return new From_1.TableFrom(node.tableName);
+    }
+    visitSubqueryFrom(node) {
+        return new From_1.SubqueryFrom(this.expectSingle(node.subquery.accept(this), 'subquery'));
+    }
+    visitJsonEachFrom(node) {
+        const newJsonExpr = this.expectSingle(node.jsonExpression.accept(this), 'jsonExpression');
+        const newJsonPath = node.jsonPath ? this.expectSingle(node.jsonPath.accept(this), 'jsonPath') : undefined;
+        return new From_1.JsonEachFrom(newJsonExpr, newJsonPath);
+    }
+    visitColumn(node) {
+        return new Column_1.Column(node.hasTableName() ? node.tableName : node.columnName, node.hasTableName() ? node.columnName : undefined);
+    }
+    visitAlias(node) {
+        return new Alias_1.Alias(this.expectSingle(node.referent.accept(this), 'referent'), node.alias);
+    }
+    visitJoinClause(node) {
+        return new Join_1.Join(node.type, node.tableName, node.alias, this.expectSingle(node.on.accept(this), 'on'));
+    }
+    visitOrderBy(node) {
+        return new OrderBy_1.OrderBy(this.expectSingle(node.column.accept(this), 'column'), node.direction);
+    }
+    visitWithClause(node) {
+        return new With_1.With(node.name, this.expectSingle(node.query.accept(this), 'query'));
+    }
+    visitBinaryExpression(node) {
+        return new BinaryExpression_1.BinaryExpression(this.expectSingle(node.left.accept(this), 'left'), node.operator, this.expectSingle(node.right.accept(this), 'right'));
+    }
+    visitUnaryExpression(node) {
+        return new UnaryExpression_1.UnaryExpression(node.operator, this.expectSingle(node.operand.accept(this), 'operand'));
+    }
+    visitInExpression(node) {
+        const newLeft = this.flatList(node.left.map(l => l.accept(this)));
+        let newValues;
+        if (node.values instanceof SelectQuery_1.SelectQuery) {
+            newValues = this.expectSingle(node.values.accept(this), 'values subquery');
+        }
+        else {
+            const newSets = [];
+            for (const set of node.values) {
+                const transformedSetParts = set.map(v => v.accept(this));
+                if (set.length > 1 && transformedSetParts.some(Array.isArray)) {
+                    throw new Error('Array replacement not allowed in multi-column tuple position');
+                }
+                if (set.length === 1 && Array.isArray(transformedSetParts[0])) {
+                    // Single-column splice: add as separate sets
+                    transformedSetParts[0].forEach(r => newSets.push([r]));
+                }
+                else {
+                    // Normal or multi-column (no arrays)
+                    newSets.push(transformedSetParts);
+                }
+            }
+            newValues = newSets;
+        }
+        return new InExpression_1.InExpression(newLeft, newValues, node.not);
+    }
+    visitConcat(node) {
+        return new Concat_1.Concat(...this.flatList(node.expressions.map(e => e.accept(this))));
+    }
+    visitCaseExpression(node) {
+        const newCases = node.cases.map(c => ({
+            when: this.expectSingle(c.when.accept(this), 'when'),
+            then: this.expectSingle(c.then.accept(this), 'then')
+        }));
+        const newElse = node.else ? this.expectSingle(node.else.accept(this), 'else') : undefined;
+        return new CaseExpression_1.CaseExpression(newCases, newElse);
+    }
+    visitFunctionExpression(node) {
+        return new FunctionExpression_1.FunctionExpression(node.name, this.flatList(node.args.map(a => a.accept(this))));
+    }
+    visitParamExpression(node) {
+        return new Literals_1.Param(node.paramName);
+    }
+    visitStringLiteral(node) {
+        return new Literals_1.StringLiteral(node.value);
+    }
+    visitNumberLiteral(node) {
+        return new Literals_1.NumberLiteral(node.value);
+    }
+    visitNullLiteral(node) {
+        return Literals_1.NullLiteral.INSTANCE;
+    }
+    visitExistsExpression(node) {
+        return new ExistsExpression_1.ExistsExpression(this.expectSingle(node.subquery.accept(this), 'subquery'));
+    }
+}
+exports.QueryIdentityTransformer = QueryIdentityTransformer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QueryIdentityTransformer.js","sourceRoot":"","sources":["../../src/visitor/QueryIdentityTransformer.ts"],"names":[],"mappings":";;;AACA,wCAAqC;AACrC,8DAA2D;AAC3D,0DAAiE;AACjE,0CAAmD;AACnD,0CAAuC;AACvC,8DAA2D;AAC3D,sCAAoF;AACpF,kEAA+D;AAE/D,sDAAmD;AACnD,oDAAiD;AACjD,sCAA6C;AAC7C,8CAAmF;AAEnF,4CAA2D;AAC3D,oDAAiD;AACjD,4DAAyD;AACzD,sCAAmC;AAGnC,MAAa,wBAAwB;IAC5B,SAAS,CAAC,IAAiB;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC/E,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,YAAY,CAAwB,MAAmC,EAAE,QAAgB;QACjG,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,+CAA+C,QAAQ,EAAE,CAAC,CAAC;QAC7E,CAAC;QACD,OAAO,MAAW,CAAC;IACrB,CAAC;IAES,QAAQ,CAAC,OAAwC;QACzD,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,CAAC;IAES,UAAU,CAAC,OAA0C;QAC7D,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,gBAAgB,CAAC,IAAiB;QAChC,MAAM,QAAQ,GAAG,IAAI,yBAAW,EAAE,CAAC;QACnC,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1C,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAW,CAAC;QACpF,QAAQ,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAC3D,IAAI,EAAE,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,UAAU,IAAI,EAAE,IAAI,OAAO,IAAI,EAAE,EAAE,CAAC;gBACtE,OAAO,IAAI,aAAK,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAS,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;YAC9F,CAAC;iBAAM,IAAI,EAAE,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,QAAQ,IAAI,EAAE,EAAE,CAAC;gBAC1D,OAAO,IAAI,CAAC,YAAY,CAAE,EAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC;YAClE,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC,CAAwB,CAAC;QAC1B,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YAC9C,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,UAAU,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;gBAClE,OAAO,IAAI,aAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAwB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YAC3G,CAAC;iBAAM,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;gBACvD,OAAO,IAAI,CAAC,YAAY,CAAE,CAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;YAC9D,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC,CAAiB,CAAC;QACnB,IAAI,IAAI,CAAC,QAAQ,CAAC;YAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,CAAe,CAAC;QAC/G,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAa,CAAC;QAC5F,IAAI,IAAI,CAAC,SAAS,CAAC;YAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAe,CAAC;QACnH,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAkB,CAAC;QAC7F,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAc,CAAC;QAC7F,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;QACtC,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,gBAAgB,CAAC,IAAiB;QAChC,MAAM,QAAQ,GAAG,IAAI,yBAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;QACrD,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;QAC5C,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,iBAAiB;QAC/D,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAiB,CAAC;QAC9F,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,cAAc,CAAC,IAAe;QAC5B,OAAO,IAAI,gBAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED,iBAAiB,CAAC,IAAkB;QAClC,OAAO,IAAI,mBAAY,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAgB,CAAC,CAAC;IACpG,CAAC;IAED,iBAAiB,CAAC,IAAkB;QAClC,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAe,CAAC;QACxG,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAe,CAAC,CAAC,CAAC,SAAS,CAAC;QACxH,OAAO,IAAI,mBAAY,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,OAAO,IAAI,eAAM,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,SAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAChI,CAAC;IAED,UAAU,CAAsB,IAAc;QAC5C,OAAO,IAAI,aAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/F,CAAC;IAED,eAAe,CAAC,IAAU;QACxB,OAAO,IAAI,WAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,CAAe,CAAC,CAAC;IACtH,CAAC;IAED,YAAY,CAAC,IAAa;QACxB,OAAO,IAAI,iBAAO,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAe,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC1G,CAAC;IAED,eAAe,CAAC,IAAU;QACxB,OAAO,IAAI,WAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,CAAgB,CAAC,CAAC;IACjG,CAAC;IAED,qBAAqB,CAAC,IAAsB;QAC1C,OAAO,IAAI,mCAAgB,CACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,CAAe,EAC/D,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,CAAe,CAClE,CAAC;IACJ,CAAC;IAED,oBAAoB,CAAC,IAAqB;QACxC,OAAO,IAAI,iCAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,CAAe,CAAC,CAAC;IACnH,CAAC;IAED,iBAAiB,CAAC,IAAkB;QAClC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAiB,CAAC;QAClF,IAAI,SAAuC,CAAC;QAC5C,IAAI,IAAI,CAAC,MAAM,YAAY,yBAAW,EAAE,CAAC;YACvC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAgB,CAAC;QAC5F,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GAAmB,EAAE,CAAC;YACnC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBAC9B,MAAM,mBAAmB,GAAkC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;gBACxF,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC9D,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;gBAClF,CAAC;gBACD,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC9D,6CAA6C;oBAC7C,mBAAmB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACzD,CAAC;qBAAM,CAAC;oBACN,qCAAqC;oBACrC,OAAO,CAAC,IAAI,CAAC,mBAAmC,CAAC,CAAC;gBACpD,CAAC;YACH,CAAC;YACD,SAAS,GAAG,OAAO,CAAC;QACtB,CAAC;QACD,OAAO,IAAI,2BAAY,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IACxD,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,OAAO,IAAI,eAAM,CAAC,GAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAkB,CAAC,CAAC;IACnG,CAAC;IAED,mBAAmB,CAAC,IAAoB;QACtC,MAAM,QAAQ,GAAe,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAChD,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,CAAe;YAClE,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,CAAe;SACnE,CAAC,CAAC,CAAC;QACJ,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,CAAe,CAAC,CAAC,CAAC,SAAS,CAAC;QACxG,OAAO,IAAI,+BAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,uBAAuB,CAAC,IAAwB;QAC9C,OAAO,IAAI,uCAAkB,CAAC,IAAI,CAAC,IAAoB,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAiB,CAAC,CAAC;IAC9H,CAAC;IAED,oBAAoB,CAAC,IAAW;QAC9B,OAAO,IAAI,gBAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,kBAAkB,CAAC,IAAmB;QACpC,OAAO,IAAI,wBAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,kBAAkB,CAAC,IAAmB;QACpC,OAAO,IAAI,wBAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,gBAAgB,CAAC,IAAiB;QAChC,OAAO,sBAAW,CAAC,QAAQ,CAAC;IAC9B,CAAC;IAED,qBAAqB,CAAC,IAAsB;QAC1C,OAAO,IAAI,mCAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAgB,CAAC,CAAC;IACxG,CAAC;CACF;AA3KD,4DA2KC","sourcesContent":["import { Aliasable, AliasableExpression, Expression, SqlTreeNode } from \"../ast/Abstractions\";\nimport { Alias } from \"../ast/Alias\";\nimport { BinaryExpression } from \"../ast/BinaryExpression\";\nimport { CaseExpression, CaseItem } from \"../ast/CaseExpression\";\nimport { Column, ColumnLike } from \"../ast/Column\";\nimport { Concat } from \"../ast/Concat\";\nimport { ExistsExpression } from \"../ast/ExistsExpression\";\nimport { From, FromLike, JsonEachFrom, SubqueryFrom, TableFrom } from \"../ast/From\";\nimport { FunctionExpression } from \"../ast/FunctionExpression\";\nimport { FunctionName } from \"../ast/FunctionName\";\nimport { InExpression } from \"../ast/InExpression\";\nimport { InsertQuery } from \"../ast/InsertQuery\";\nimport { Join, JoinType } from \"../ast/Join\";\nimport { NullLiteral, NumberLiteral, Param, StringLiteral } from \"../ast/Literals\";\nimport { Operator } from \"../ast/Operator\";\nimport { OrderBy, OrderByDirection } from \"../ast/OrderBy\";\nimport { SelectQuery } from \"../ast/SelectQuery\";\nimport { UnaryExpression } from \"../ast/UnaryExpression\";\nimport { With } from \"../ast/With\";\nimport { SqlTreeNodeTransformer } from \"./SqlTreeNodeTransformer\";\n\nexport class QueryIdentityTransformer implements SqlTreeNodeTransformer {\n  public transform(node: SqlTreeNode): SqlTreeNode {\n    const result = node.accept(this);\n    if (Array.isArray(result)) {\n      throw new Error('Top-level transformation must return a single SqlTreeNode');\n    }\n    return result;\n  }\n\n  protected expectSingle<T extends SqlTreeNode>(result: SqlTreeNode | SqlTreeNode[], typeName: string): T {\n    if (Array.isArray(result)) {\n      throw new Error(`Unexpected array in single-node context for ${typeName}`);\n    }\n    return result as T;\n  }\n\n  protected flatList(results: (SqlTreeNode | SqlTreeNode[])[]): SqlTreeNode[] {\n    return results.flatMap(r => Array.isArray(r) ? r : [r]);\n  }\n\n  protected flatList2D(results: (SqlTreeNode | SqlTreeNode[])[][]): SqlTreeNode[][] {\n    return results.map(set => this.flatList(set));\n  }\n\n  visitSelectQuery(node: SelectQuery): SqlTreeNode | SqlTreeNode[] {\n    const newQuery = new SelectQuery();\n    newQuery['_distinct'] = node['_distinct'];\n    newQuery['_with'] = this.flatList(node['_with'].map(w => w.accept(this))) as With[];\n    newQuery['_fromsAndJoins'] = node['_fromsAndJoins'].map(fj => {\n      if (fj && typeof fj === 'object' && 'referent' in fj && 'alias' in fj) {\n        return new Alias(this.expectSingle(fj.referent.accept(this), 'referent') as From, fj.alias);\n      } else if (fj && typeof fj === 'object' && 'accept' in fj) {\n        return this.expectSingle((fj as any).accept(this), 'from/join');\n      } else {\n        throw new Error('Invalid from/join object');\n      }\n    }) as (FromLike | Join)[];\n    newQuery['_columns'] = node['_columns'].map(c => {\n      if (c && typeof c === 'object' && 'referent' in c && 'alias' in c) {\n        return new Alias(this.expectSingle(c.referent.accept(this), 'referent') as AliasableExpression, c.alias);\n      } else if (c && typeof c === 'object' && 'accept' in c) {\n        return this.expectSingle((c as any).accept(this), 'column');\n      } else {\n        throw new Error('Invalid column object');\n      }\n    }) as ColumnLike[];\n    if (node['_where']) newQuery['_where'] = this.expectSingle(node['_where'].accept(this), 'WHERE') as Expression;\n    newQuery['_groupBy'] = this.flatList(node['_groupBy'].map(g => g.accept(this))) as Column[];\n    if (node['_having']) newQuery['_having'] = this.expectSingle(node['_having'].accept(this), 'HAVING') as Expression;\n    newQuery['_union'] = this.flatList(node['_union'].map(u => u.accept(this))) as SelectQuery[];\n    newQuery['_orderBy'] = this.flatList(node['_orderBy'].map(o => o.accept(this))) as OrderBy[];\n    newQuery['_offset'] = node['_offset'];\n    newQuery['_limit'] = node['_limit'];\n    return newQuery;\n  }\n\n  visitInsertQuery(node: InsertQuery): SqlTreeNode | SqlTreeNode[] {\n    const newQuery = new InsertQuery(node['_tableName']);\n    newQuery['_orReplace'] = node['_orReplace'];\n    newQuery['_columns'] = [...node['_columns']]; // Strings, reuse\n    newQuery['_values'] = this.flatList(node['_values'].map(v => v.accept(this))) as Expression[];\n    return newQuery;\n  }\n\n  visitTableFrom(node: TableFrom): SqlTreeNode | SqlTreeNode[] {\n    return new TableFrom(node.tableName);\n  }\n\n  visitSubqueryFrom(node: SubqueryFrom): SqlTreeNode | SqlTreeNode[] {\n    return new SubqueryFrom(this.expectSingle(node.subquery.accept(this), 'subquery') as SelectQuery);\n  }\n\n  visitJsonEachFrom(node: JsonEachFrom): SqlTreeNode | SqlTreeNode[] {\n    const newJsonExpr = this.expectSingle(node.jsonExpression.accept(this), 'jsonExpression') as Expression;\n    const newJsonPath = node.jsonPath ? this.expectSingle(node.jsonPath.accept(this), 'jsonPath') as Expression : undefined;\n    return new JsonEachFrom(newJsonExpr, newJsonPath);\n  }\n\n  visitColumn(node: Column): SqlTreeNode | SqlTreeNode[] {\n    return new Column(node.hasTableName() ? node.tableName! : node.columnName, node.hasTableName() ? node.columnName : undefined);\n  }\n\n  visitAlias<T extends Aliasable>(node: Alias<T>): SqlTreeNode | SqlTreeNode[] {\n    return new Alias(this.expectSingle(node.referent.accept(this), 'referent') as T, node.alias);\n  }\n\n  visitJoinClause(node: Join): SqlTreeNode | SqlTreeNode[] {\n    return new Join(node.type, node.tableName, node.alias, this.expectSingle(node.on.accept(this), 'on') as Expression);\n  }\n\n  visitOrderBy(node: OrderBy): SqlTreeNode | SqlTreeNode[] {\n    return new OrderBy(this.expectSingle(node.column.accept(this), 'column') as Expression, node.direction);\n  }\n\n  visitWithClause(node: With): SqlTreeNode | SqlTreeNode[] {\n    return new With(node.name, this.expectSingle(node.query.accept(this), 'query') as SelectQuery);\n  }\n\n  visitBinaryExpression(node: BinaryExpression): SqlTreeNode | SqlTreeNode[] {\n    return new BinaryExpression(\n      this.expectSingle(node.left.accept(this), 'left') as Expression,\n      node.operator,\n      this.expectSingle(node.right.accept(this), 'right') as Expression\n    );\n  }\n\n  visitUnaryExpression(node: UnaryExpression): SqlTreeNode | SqlTreeNode[] {\n    return new UnaryExpression(node.operator, this.expectSingle(node.operand.accept(this), 'operand') as Expression);\n  }\n\n  visitInExpression(node: InExpression): SqlTreeNode | SqlTreeNode[] {\n    const newLeft = this.flatList(node.left.map(l => l.accept(this))) as Expression[];\n    let newValues: Expression[][] | SelectQuery;\n    if (node.values instanceof SelectQuery) {\n      newValues = this.expectSingle(node.values.accept(this), 'values subquery') as SelectQuery;\n    } else {\n      const newSets: Expression[][] = [];\n      for (const set of node.values) {\n        const transformedSetParts: (Expression | Expression[])[] = set.map(v => v.accept(this));\n        if (set.length > 1 && transformedSetParts.some(Array.isArray)) {\n          throw new Error('Array replacement not allowed in multi-column tuple position');\n        }\n        if (set.length === 1 && Array.isArray(transformedSetParts[0])) {\n          // Single-column splice: add as separate sets\n          transformedSetParts[0].forEach(r => newSets.push([r]));\n        } else {\n          // Normal or multi-column (no arrays)\n          newSets.push(transformedSetParts as Expression[]);\n        }\n      }\n      newValues = newSets;\n    }\n    return new InExpression(newLeft, newValues, node.not);\n  }\n\n  visitConcat(node: Concat): SqlTreeNode | SqlTreeNode[] {\n    return new Concat(...(this.flatList(node.expressions.map(e => e.accept(this))) as Expression[]));\n  }\n\n  visitCaseExpression(node: CaseExpression): SqlTreeNode | SqlTreeNode[] {\n    const newCases: CaseItem[] = node.cases.map(c => ({\n      when: this.expectSingle(c.when.accept(this), 'when') as Expression,\n      then: this.expectSingle(c.then.accept(this), 'then') as Expression\n    }));\n    const newElse = node.else ? this.expectSingle(node.else.accept(this), 'else') as Expression : undefined;\n    return new CaseExpression(newCases, newElse);\n  }\n\n  visitFunctionExpression(node: FunctionExpression): SqlTreeNode | SqlTreeNode[] {\n    return new FunctionExpression(node.name as FunctionName, this.flatList(node.args.map(a => a.accept(this))) as Expression[]);\n  }\n\n  visitParamExpression(node: Param): SqlTreeNode | SqlTreeNode[] {\n    return new Param(node.paramName);\n  }\n\n  visitStringLiteral(node: StringLiteral): SqlTreeNode | SqlTreeNode[] {\n    return new StringLiteral(node.value);\n  }\n\n  visitNumberLiteral(node: NumberLiteral): SqlTreeNode | SqlTreeNode[] {\n    return new NumberLiteral(node.value);\n  }\n\n  visitNullLiteral(node: NullLiteral): SqlTreeNode | SqlTreeNode[] {\n    return NullLiteral.INSTANCE;\n  }\n\n  visitExistsExpression(node: ExistsExpression): SqlTreeNode | SqlTreeNode[] {\n    return new ExistsExpression(this.expectSingle(node.subquery.accept(this), 'subquery') as SelectQuery);\n  }\n}\n"]}

package/dist/visitor/QueryParamRewriteTransformer.d.ts

@@ -0,0 +1,11 @@
+import { Expression, SqlTreeNode } from "../ast/Abstractions";
+import { Param } from "../ast/Literals";
+import { QueryIdentityTransformer } from "./QueryIdentityTransformer";
+export type ParamReplacements = {
+    [paramName: string]: Expression | Expression[];
+};
+export declare class QueryParamRewriteTransformer extends QueryIdentityTransformer {
+    private readonly _replacements;
+    constructor(paramNameOrReplacements: string | ParamReplacements, replacement?: Expression | Expression[]);
+    visitParamExpression(node: Param): SqlTreeNode | SqlTreeNode[];
+}

package/dist/visitor/QueryParamRewriteTransformer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryParamRewriteTransformer = void 0;
+const QueryIdentityTransformer_1 = require("./QueryIdentityTransformer");
+class QueryParamRewriteTransformer extends QueryIdentityTransformer_1.QueryIdentityTransformer {
+    // Support both old single-param constructor and new multi-param constructor
+    constructor(paramNameOrReplacements, replacement) {
+        super();
+        if (typeof paramNameOrReplacements === 'string') {
+            // Legacy single-parameter mode
+            this._replacements = { [paramNameOrReplacements]: replacement };
+        }
+        else {
+            // New multi-parameter mode
+            this._replacements = paramNameOrReplacements;
+        }
+    }
+    visitParamExpression(node) {
+        if (node.paramName && this._replacements && typeof this._replacements === 'object' && node.paramName in this._replacements) {
+            return this._replacements[node.paramName];
+        }
+        return super.visitParamExpression(node);
+    }
+}
+exports.QueryParamRewriteTransformer = QueryParamRewriteTransformer;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/visitor/SqlTreeNodeTransformer.d.ts

@@ -0,0 +1,5 @@
+import { SqlTreeNode } from "../ast/Abstractions";
+import { SqlTreeNodeVisitor } from "./SqlTreeNodeVisitor";
+export interface SqlTreeNodeTransformer extends SqlTreeNodeVisitor<SqlTreeNode | SqlTreeNode[]> {
+    transform(node: SqlTreeNode): SqlTreeNode;
+}

package/dist/visitor/SqlTreeNodeTransformer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3FsVHJlZU5vZGVUcmFuc2Zvcm1lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aXNpdG9yL1NxbFRyZWVOb2RlVHJhbnNmb3JtZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNxbFRyZWVOb2RlIH0gZnJvbSBcIi4uL2FzdC9BYnN0cmFjdGlvbnNcIjtcbmltcG9ydCB7IFNxbFRyZWVOb2RlVmlzaXRvciB9IGZyb20gXCIuL1NxbFRyZWVOb2RlVmlzaXRvclwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIFNxbFRyZWVOb2RlVHJhbnNmb3JtZXIgZXh0ZW5kcyBTcWxUcmVlTm9kZVZpc2l0b3I8U3FsVHJlZU5vZGUgfCBTcWxUcmVlTm9kZVtdPiB7XG4gIHRyYW5zZm9ybShub2RlOiBTcWxUcmVlTm9kZSk6IFNxbFRyZWVOb2RlO1xufVxuIl19

package/dist/visitor/SqlTreeNodeVisitor.d.ts

@@ -0,0 +1,45 @@
+import { Alias } from "../ast/Alias";
+import { BinaryExpression } from "../ast/BinaryExpression";
+import { CaseExpression } from "../ast/CaseExpression";
+import { Column, ColumnLike } from "../ast/Column";
+import { Concat } from "../ast/Concat";
+import { ExistsExpression } from "../ast/ExistsExpression";
+import { FromLike, JsonEachFrom, SubqueryFrom, TableFrom } from "../ast/From";
+import { FunctionExpression } from "../ast/FunctionExpression";
+import { InExpression } from "../ast/InExpression";
+import { InsertQuery } from "../ast/InsertQuery";
+import { Join } from "../ast/Join";
+import { NullLiteral, NumberLiteral, Param, StringLiteral } from "../ast/Literals";
+import { OrderBy } from "../ast/OrderBy";
+import { SelectQuery } from "../ast/SelectQuery";
+import { UnaryExpression } from "../ast/UnaryExpression";
+import { With } from "../ast/With";
+export interface SqlTreeNodeVisitor<T> {
+    visitSelectQuery(node: SelectQuery): T;
+    visitInsertQuery(node: InsertQuery): T;
+    visitTableFrom(node: TableFrom): T;
+    visitSubqueryFrom(node: SubqueryFrom): T;
+    visitJsonEachFrom(node: JsonEachFrom): T;
+    visitJoinClause(node: Join): T;
+    visitOrderBy(node: OrderBy): T;
+    visitWithClause(node: With): T;
+    visitColumn(node: Column): T;
+    visitAlias(node: Alias<any>): T;
+    visitBinaryExpression(node: BinaryExpression): T;
+    visitUnaryExpression(node: UnaryExpression): T;
+    visitInExpression(node: InExpression): T;
+    visitConcat(node: Concat): T;
+    visitCaseExpression(node: CaseExpression): T;
+    visitFunctionExpression(node: FunctionExpression): T;
+    visitParamExpression(node: Param): T;
+    visitStringLiteral(node: StringLiteral): T;
+    visitNumberLiteral(node: NumberLiteral): T;
+    visitNullLiteral(node: NullLiteral): T;
+    visitExistsExpression(node: ExistsExpression): T;
+}
+export declare class FromLikeAndJoinVisitorAcceptor<T> {
+    accept(visitor: SqlTreeNodeVisitor<T>, f: FromLike | Join): T;
+}
+export declare class ColumnLikeVisitorAcceptor<T> {
+    accept(visitor: SqlTreeNodeVisitor<T>, c: ColumnLike): T;
+}

package/dist/visitor/SqlTreeNodeVisitor.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnLikeVisitorAcceptor = exports.FromLikeAndJoinVisitorAcceptor = void 0;
+const Abstractions_1 = require("../ast/Abstractions");
+const Alias_1 = require("../ast/Alias");
+const Column_1 = require("../ast/Column");
+const From_1 = require("../ast/From");
+const Join_1 = require("../ast/Join");
+const Literals_1 = require("../ast/Literals");
+class FromLikeAndJoinVisitorAcceptor {
+    accept(visitor, f) {
+        if (f instanceof Join_1.Join ||
+            f instanceof From_1.TableFrom ||
+            f instanceof From_1.SubqueryFrom ||
+            f instanceof From_1.JsonEachFrom ||
+            f instanceof Alias_1.Alias) {
+            return f.accept(visitor);
+        }
+        else if (f && typeof f === 'object' && 'referent' in f && 'alias' in f) {
+            const alias = new Alias_1.Alias(f.referent, f.alias);
+            return alias.accept(visitor);
+        }
+        else {
+            throw new Error('Invalid FROM clause: ' + JSON.stringify(f));
+        }
+    }
+}
+exports.FromLikeAndJoinVisitorAcceptor = FromLikeAndJoinVisitorAcceptor;
+class ColumnLikeVisitorAcceptor {
+    accept(visitor, c) {
+        if (c instanceof Column_1.Column ||
+            c instanceof Literals_1.LiteralExpression ||
+            c instanceof Abstractions_1.AliasableExpression ||
+            c instanceof Alias_1.Alias) {
+            return c.accept(visitor);
+        }
+        else if (c && typeof c === 'object' && 'referent' in c && 'alias' in c) {
+            const alias = new Alias_1.Alias(c.referent, c.alias);
+            return alias.accept(visitor);
+        }
+        else {
+            throw new Error('Invalid COLUMN clause: ' + JSON.stringify(c));
+        }
+    }
+}
+exports.ColumnLikeVisitorAcceptor = ColumnLikeVisitorAcceptor;
+//# sourceMappingURL=data:application/json;base64,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