@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/statements/StatementRenderer.js

@@ -0,0 +1,140 @@
+import { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.js";
+import { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.js";
+import { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.js";
+import { AlterTableStatementTextRenderer } from "./AlterTableStatementTextRenderer.js";
+import { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.js";
+import { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+import { CreateTriggerStatementTextRenderer } from "./CreateTriggerStatementTextRenderer.js";
+import { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.js";
+import { DropIndexStatementTextRenderer } from "./DropIndexStatementTextRenderer.js";
+import { DropRoutineStatementTextRenderer } from "./DropRoutineStatementTextRenderer.js";
+import { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
+import { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+import { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
+import { CreateDeleteStoredProcedureStatementTextRenderer } from "./CreateDeleteStoredProcedureStatementTextRenderer.js";
+import { CreateBulkCreateStoredProcedureStatementTextRenderer } from "./CreateBulkCreateStoredProcedureStatementTextRenderer.js";
+import { CreateBulkUpdateStoredProcedureStatementTextRenderer } from "./CreateBulkUpdateStoredProcedureStatementTextRenderer.js";
+import { CreateBulkDeleteStoredProcedureStatementTextRenderer } from "./CreateBulkDeleteStoredProcedureStatementTextRenderer.js";
+import { DropTableStatementTextRenderer } from "./DropTableStatementTextRenderer.js";
+import { DropTriggerStatementTextRenderer } from "./DropTriggerStatementTextRenderer.js";
+import { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.js";
+import { IdentityInsertStatementTextRenderer } from "./IdentityInsertStatementTextRenderer.js";
+import { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.js";
+import { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.js";
+import { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.js";
+import { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.js";
+import { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export class StatementRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    visit(statement) {
+        return ({
+            SelectStatement: () => this.visitSelect(statement),
+            InsertStatement: () => this.visitInsert(statement),
+            UpdateStatement: () => this.visitUpdate(statement),
+            DeleteStatement: () => this.visitDelete(statement),
+            CreateTableStatement: () => this.visitCreateTable(statement),
+            CreateIndexStatement: () => this.visitCreateIndex(statement),
+            ExecuteStoredProcedureStatement: () => this.visitExecuteStoredProcedure(statement),
+            ReturnStatement: () => this.visitReturn(statement),
+            BulkInsertStatement: () => this.visitBulkInsert(statement),
+            BulkUpdateStatement: () => this.visitBulkUpdate(statement),
+            BulkDeleteStatement: () => this.visitBulkDelete(statement),
+            DropTableStatement: () => this.visitDropTable(statement),
+            AlterTableStatement: () => this.visitAlterTable(statement),
+            DropIndexStatement: () => this.visitDropIndex(statement),
+            DropTriggerStatement: () => this.visitDropTrigger(statement),
+            CreateTriggerStatement: () => this.visitCreateTrigger(statement),
+            IdentityInsertStatement: () => this.visitIdentityInsert(statement),
+            DropRoutineStatement: () => this.visitDropRoutine(statement),
+            CreateCreateStoredProcedureStatement: () => this.visitCreateCreateStoredProcedureStatement(statement),
+            CreateReadStoredProcedureStatement: () => this.visitCreateReadStoredProcedureStatement(statement),
+            CreateUpdateStoredProcedureStatement: () => this.visitCreateUpdateStoredProcedureStatement(statement),
+            CreateDeleteStoredProcedureStatement: () => this.visitCreateDeleteStoredProcedureStatement(statement),
+            CreateBulkCreateStoredProcedureStatement: () => this.visitCreateBulkCreateStoredProcedureStatement(statement),
+            CreateBulkUpdateStoredProcedureStatement: () => this.visitCreateBulkUpdateStoredProcedureStatement(statement),
+            CreateBulkDeleteStoredProcedureStatement: () => this.visitCreateBulkDeleteStoredProcedureStatement(statement),
+            SelectInsertedIdStatement: () => this.visitSelectInsertedId(statement),
+        }[statement.constructor.name] ?? (() => this.visitSelectInsertedId(statement)))();
+    }
+    visitSelect(statement) {
+        return new SelectStatementTextRenderer(this.text).render(statement);
+    }
+    visitInsert(statement) {
+        return new InsertStatementTextRenderer().render(statement);
+    }
+    visitUpdate(statement) {
+        return new UpdateStatementTextRenderer(this.text).render(statement);
+    }
+    visitDelete(statement) {
+        return new DeleteStatementTextRenderer(this.text).render(statement);
+    }
+    visitCreateTable(statement) {
+        return new CreateTableStatementTextRenderer().render(statement);
+    }
+    visitCreateIndex(statement) {
+        return new CreateIndexStatementTextRenderer().render(statement);
+    }
+    visitExecuteStoredProcedure(statement) {
+        return new ExecuteStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitReturn(statement) {
+        return new ReturnStatementTextRenderer().render(statement);
+    }
+    visitSelectInsertedId(statement) {
+        return new SelectInsertedIdStatementTextRenderer().render(statement);
+    }
+    visitBulkInsert(statement) {
+        return new BulkInsertStatementTextRenderer().render(statement);
+    }
+    visitBulkUpdate(statement) {
+        return new BulkUpdateStatementTextRenderer().render(statement);
+    }
+    visitBulkDelete(statement) {
+        return new BulkDeleteStatementTextRenderer().render(statement);
+    }
+    visitDropTable(statement) {
+        return new DropTableStatementTextRenderer().render(statement);
+    }
+    visitAlterTable(statement) {
+        return new AlterTableStatementTextRenderer().renderAlter(statement);
+    }
+    visitDropIndex(statement) {
+        return new DropIndexStatementTextRenderer().render(statement);
+    }
+    visitDropTrigger(statement) {
+        return new DropTriggerStatementTextRenderer().render(statement);
+    }
+    visitCreateTrigger(statement) {
+        return new CreateTriggerStatementTextRenderer().render(statement);
+    }
+    visitIdentityInsert(statement) {
+        return new IdentityInsertStatementTextRenderer().render(statement);
+    }
+    visitDropRoutine(statement) {
+        return new DropRoutineStatementTextRenderer().render(statement);
+    }
+    visitCreateCreateStoredProcedureStatement(statement) {
+        return new CreateCreateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateReadStoredProcedureStatement(statement) {
+        return new CreateReadStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateUpdateStoredProcedureStatement(statement) {
+        return new CreateUpdateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateDeleteStoredProcedureStatement(statement) {
+        return new CreateDeleteStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateBulkCreateStoredProcedureStatement(statement) {
+        return new CreateBulkCreateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateBulkUpdateStoredProcedureStatement(statement) {
+        return new CreateBulkUpdateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateBulkDeleteStoredProcedureStatement(statement) {
+        return new CreateBulkDeleteStoredProcedureStatementTextRenderer().render(statement);
+    }
+}

package/dist/statements/StatementTextRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { ICondition } from "./ICondition.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IStatement } from "./IStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import { ConditionRenderer } from "./ConditionRenderer.js";
+import { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { StatementRenderer } from "./StatementRenderer.js";
+export declare class StatementTextRenderer {
+    protected readonly statements: IStatementVisitor;
+    protected readonly conditions: IConditionVisitor;
+    constructor(statements?: (text: StatementTextRenderer) => StatementRenderer, conditions?: (expressions: ExpressionRenderer) => ConditionRenderer, expressions?: (text: StatementTextRenderer) => ExpressionRenderer);
+    render(statement: IStatement): string;
+    render(condition: ICondition): string;
+}

package/dist/statements/StatementTextRenderer.js

@@ -0,0 +1,27 @@
+import { ConditionRenderer } from "./ConditionRenderer.js";
+import { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { StatementRenderer } from "./StatementRenderer.js";
+import { Where } from "./Where.js";
+import { WhereText } from "./WhereText.js";
+export class StatementTextRenderer {
+    statements;
+    conditions;
+    constructor(statements, conditions, expressions) {
+        const expressionRenderer = expressions?.(this) ?? new ExpressionRenderer(this);
+        this.statements = statements?.(this) ?? new StatementRenderer(this);
+        this.conditions = conditions?.(expressionRenderer) ?? new ConditionRenderer(expressionRenderer);
+    }
+    render(target) {
+        if (target.constructor.name === "Where" || target.constructor.name === "WhereText") {
+            return target.accept(this.conditions);
+        }
+        if (target.constructor.name.endsWith("Statement")) {
+            return target.accept(this.statements);
+        }
+        if (target instanceof Where || target instanceof WhereText)
+            return target.accept(this.conditions);
+        return "where" in target || "fields" in target || "joins" in target || "column" in target
+            ? target.accept(this.statements)
+            : target.accept(this.conditions);
+    }
+}

package/dist/statements/Subquery.d.ts

@@ -0,0 +1,6 @@
+import type { IExpression } from "./IExpression.js";
+import type { SelectStatement } from "./SelectStatement.js";
+export declare class Subquery implements IExpression {
+    readonly query: SelectStatement;
+    constructor(query: SelectStatement);
+}

package/dist/statements/Subquery.js

@@ -0,0 +1,6 @@
+export class Subquery {
+    query;
+    constructor(query) {
+        this.query = query;
+    }
+}

package/dist/statements/UniqueConstraint.d.ts

@@ -0,0 +1,7 @@
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class UniqueConstraint implements ITableConstraint {
+    readonly name: string;
+    readonly columns: string[];
+    readonly kind: "unique";
+    constructor(name: string, columns: string[]);
+}

package/dist/statements/UniqueConstraint.js

@@ -0,0 +1,9 @@
+export class UniqueConstraint {
+    name;
+    columns;
+    kind = "unique";
+    constructor(name, columns) {
+        this.name = name;
+        this.columns = columns;
+    }
+}

package/dist/statements/UpdateStatement.d.ts

@@ -0,0 +1,14 @@
+import type { Field } from "../builders/Field.js";
+import type { Parameter } from "../Parameter.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { IUpdateStatement } from "./IUpdateStatement.js";
+import type { IWhere } from "./IWhere.js";
+export declare class UpdateStatement implements IUpdateStatement {
+    readonly table: string;
+    readonly fields: Field[];
+    readonly where?: IWhere;
+    constructor(table: string, fields: Field[], where?: IWhere);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+    static parameterList: (fields: Field[], where?: IWhere) => Parameter[];
+}

package/dist/statements/UpdateStatement.js

@@ -0,0 +1,19 @@
+import { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
+import { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export class UpdateStatement {
+    table;
+    fields;
+    where;
+    constructor(table, fields, where) {
+        this.table = table;
+        this.fields = fields;
+        this.where = where;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return new UpdateStatementTextRenderer(DefaultStatementTextRenderer.instance)
+            .compose(`UPDATE ${this.table} SET ${this.fields.map((item) => `${item.name} = $${item.name}`).join(", ")}`, this.where, this.fields).parameters;
+    }
+    static parameterList = (fields, where) => new UpdateStatementTextRenderer(DefaultStatementTextRenderer.instance).compose("", where, fields)
+        .parameters;
+}

package/dist/statements/UpdateStatementTextRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { Field } from "../builders/Field.js";
+import type { Parameter } from "../Parameter.js";
+import type { IWhere } from "./IWhere.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+import type { UpdateStatement } from "./UpdateStatement.js";
+export declare class UpdateStatementTextRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render(statement: UpdateStatement): string;
+    compose(sql: string, where: IWhere | undefined, fields: Field[]): {
+        text: string;
+        parameters: Parameter[];
+    };
+}

package/dist/statements/UpdateStatementTextRenderer.js

@@ -0,0 +1,51 @@
+const rename = (text, name, alias) => {
+    const token = `$${name}`;
+    const next = `$${alias}`;
+    let index = 0;
+    let result = "";
+    while (text.indexOf(token, index) >= 0) {
+        const at = text.indexOf(token, index);
+        const end = at + token.length;
+        const nextChar = text.charAt(end);
+        const boundary = nextChar === "" || !/[A-Za-z0-9_]/.test(nextChar);
+        result += text.slice(index, at) + (boundary ? next : token);
+        index = end;
+    }
+    return result + text.slice(index);
+};
+const setClause = (fields) => fields.map((field) => `${field.name} = $${field.name}`).join(", ");
+export class UpdateStatementTextRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render(statement) {
+        return this.compose(`UPDATE ${statement.table} SET ${setClause(statement.fields)}`, statement.where, statement.fields).text;
+    }
+    compose(sql, where, fields) {
+        if (!where)
+            return { text: sql, parameters: fields };
+        const rendered = `${sql} WHERE ${this.text.render(where)}`;
+        const split = rendered.lastIndexOf(" WHERE ");
+        /* v8 ignore next 2 */
+        const head = split < 0 ? rendered : rendered.slice(0, split);
+        let tail = split < 0 ? "" : rendered.slice(split);
+        const parameters = [...fields];
+        const values = new Map();
+        for (const field of fields)
+            values.set(field.name, field.value);
+        for (const parameter of where.parameters ?? []) {
+            if (parameter.value === undefined)
+                continue;
+            const current = values.get(parameter.name);
+            if (values.has(parameter.name) && current !== parameter.value) {
+                const alias = `${parameter.name}__where`;
+                tail = rename(tail, parameter.name, alias);
+                parameters.push({ name: alias, value: parameter.value });
+            }
+            else
+                parameters.push({ name: parameter.name, value: parameter.value });
+        }
+        return { text: head + tail, parameters };
+    }
+}

package/dist/statements/Where.d.ts

@@ -0,0 +1,16 @@
+import type { Parameter } from "../Parameter.js";
+import type { Cell } from "../converters/Cell.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IExpression } from "./IExpression.js";
+import type { IWhere } from "./IWhere.js";
+import type { Comparison } from "./Cmp.js";
+export declare class Where implements IWhere {
+    readonly condition: IExpression;
+    constructor(condition: IExpression);
+    constructor(column: string, op: Comparison, value: Cell);
+    and(column: string, op: Comparison, value: Cell): Where;
+    or(column: string, op: Comparison, value: Cell): Where;
+    map(column: (name: string) => string, value: (name: string, cell: Cell) => Cell): Where;
+    accept: (visitor: IConditionVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/Where.js

@@ -0,0 +1,182 @@
+import { ArrayExpression } from "./ArrayExpression.js";
+import { Identifier } from "./Identifier.js";
+import { Literal } from "./Literal.js";
+import { Operator } from "./Operator.js";
+import { eq } from "./Cmp.js";
+import { SelectStatement } from "./SelectStatement.js";
+import { Subquery } from "./Subquery.js";
+const pair = (expression) => expression instanceof Operator.Equals ||
+    expression instanceof Operator.NotEquals ||
+    expression instanceof Operator.GreaterThan ||
+    expression instanceof Operator.LessThan ||
+    expression instanceof Operator.GreaterThanOrEqual ||
+    expression instanceof Operator.LessThanOrEqual ||
+    expression instanceof Operator.And ||
+    expression instanceof Operator.Or ||
+    expression instanceof Operator.In ||
+    expression instanceof Operator.Like ||
+    expression instanceof Operator.NotLike
+    ? expression
+    : undefined;
+const parameterName = (name) => parts(name)
+    .map((part) => part.length >= 2 && part.startsWith('"') && part.endsWith('"')
+    ? part.slice(1, -1).replace(/""/g, '"')
+    : part)
+    .join(".");
+const parts = (name) => {
+    const found = [];
+    let start = 0;
+    let quoted = false;
+    for (let i = 0; i < name.length; i++) {
+        if (name[i] === '"')
+            quoted = !quoted;
+        if (name[i] !== "." || quoted)
+            continue;
+        found.push(name.slice(start, i));
+        start = i + 1;
+    }
+    found.push(name.slice(start));
+    return found;
+};
+const side = (expression, other, column, value) => expression instanceof Literal && other instanceof Identifier
+    ? new Literal(value(other.name, expression.value))
+    : rewrite(expression, column, value);
+const inRight = (left, right, column, value) => left instanceof Identifier && right instanceof ArrayExpression
+    ? new ArrayExpression(right.elements.map((element) => element instanceof Literal
+        ? new Literal(value(left.name, element.value))
+        : rewrite(element, column, value)))
+    : rewrite(right, column, value);
+const bound = (subject, edge, column, value) => subject instanceof Identifier && edge instanceof Literal
+    ? new Literal(value(subject.name, edge.value))
+    : rewrite(edge, column, value);
+const rewriteWhere = (where, column, value) => where instanceof Where ? new Where(rewrite(where.condition, column, value)) : where;
+const rewriteQuery = (query, column, value) => query.table === undefined
+    ? query
+    : new SelectStatement({
+        distinct: query.distinct,
+        table: query.table,
+        fields: query.fields,
+        where: rewriteWhere(query.where, column, value),
+        joins: query.joins.map((join) => join.on ? { ...join, on: rewrite(join.on, column, value) } : join),
+        groupBy: query.groupBy,
+        having: rewriteWhere(query.having, column, value),
+        orderBy: query.orderBy,
+        limit: query.limit,
+        offset: query.offset,
+    });
+const rewrite = (expression, column, value) => expression instanceof Where
+    ? rewrite(expression.condition, column, value)
+    : expression instanceof Identifier
+        ? new Identifier(column(expression.name))
+        : expression instanceof Literal
+            ? expression
+            : expression instanceof ArrayExpression
+                ? new ArrayExpression(expression.elements.map((element) => rewrite(element, column, value)))
+                : expression instanceof Subquery
+                    ? new Subquery(rewriteQuery(expression.query, column, value))
+                    : expression instanceof Operator.Not
+                        ? new Operator.Not(rewrite(expression.argument, column, value))
+                        : expression instanceof Operator.IsNull
+                            ? new Operator.IsNull(rewrite(expression.argument, column, value))
+                            : expression instanceof Operator.IsNotNull
+                                ? new Operator.IsNotNull(rewrite(expression.argument, column, value))
+                                : expression instanceof Operator.Exists
+                                    ? new Operator.Exists(rewrite(expression.argument, column, value))
+                                    : expression instanceof Operator.And
+                                        ? new Operator.And(rewrite(expression.left, column, value), rewrite(expression.right, column, value))
+                                        : expression instanceof Operator.Or
+                                            ? new Operator.Or(rewrite(expression.left, column, value), rewrite(expression.right, column, value))
+                                            : expression instanceof Operator.In
+                                                ? new Operator.In(rewrite(expression.left, column, value), inRight(expression.left, expression.right, column, value))
+                                                : expression instanceof Operator.NotIn
+                                                    ? new Operator.NotIn(rewrite(expression.left, column, value), inRight(expression.left, expression.right, column, value))
+                                                    : expression instanceof Operator.Like
+                                                        ? new Operator.Like(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                        : expression instanceof Operator.NotLike
+                                                            ? new Operator.NotLike(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                            : expression instanceof Operator.Between
+                                                                ? new Operator.Between(rewrite(expression.value, column, value), bound(expression.value, expression.low, column, value), bound(expression.value, expression.high, column, value))
+                                                                : expression instanceof Operator.NotBetween
+                                                                    ? new Operator.NotBetween(rewrite(expression.value, column, value), bound(expression.value, expression.low, column, value), bound(expression.value, expression.high, column, value))
+                                                                    : expression instanceof Operator.Equals
+                                                                        ? new Operator.Equals(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                        : expression instanceof Operator.NotEquals
+                                                                            ? new Operator.NotEquals(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                            : expression instanceof Operator.GreaterThan
+                                                                                ? new Operator.GreaterThan(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                : expression instanceof Operator.LessThan
+                                                                                    ? new Operator.LessThan(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                    : expression instanceof Operator.GreaterThanOrEqual
+                                                                                        ? new Operator.GreaterThanOrEqual(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                        : expression instanceof Operator.LessThanOrEqual
+                                                                                            ? new Operator.LessThanOrEqual(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
+                                                                                            : (() => {
+                                                                                                throw new Error("empty expression");
+                                                                                            })();
+const listed = (name, elements) => elements.map((element, i) => element instanceof Literal
+    ? { name: `${parameterName(name)}_${i}`, value: element.value }
+    : (() => {
+        throw new Error("empty in");
+    })());
+const collect = (expression) => {
+    if (expression instanceof Where)
+        return collect(expression.condition);
+    if (expression instanceof Literal || expression instanceof Identifier)
+        return [];
+    if (expression instanceof Operator.Not || expression instanceof Operator.IsNull || expression instanceof Operator.IsNotNull)
+        return collect(expression.argument);
+    if (expression instanceof Operator.Exists)
+        return collect(expression.argument);
+    if (expression instanceof Subquery)
+        return [
+            ...(expression.query.where ? collect(expression.query.where) : []),
+            ...(expression.query.having ? collect(expression.query.having) : []),
+            ...expression.query.joins.flatMap((join) => (join.on ? collect(join.on) : [])),
+        ];
+    if (expression instanceof Operator.In && expression.left instanceof Identifier && expression.right instanceof ArrayExpression)
+        return listed(expression.left.name, expression.right.elements);
+    if (expression instanceof Operator.NotIn && expression.left instanceof Identifier && expression.right instanceof ArrayExpression)
+        return listed(expression.left.name, expression.right.elements);
+    if (expression instanceof Operator.In || expression instanceof Operator.NotIn)
+        return [...collect(expression.left), ...collect(expression.right)];
+    if ((expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
+        expression.value instanceof Identifier &&
+        expression.low instanceof Literal &&
+        expression.high instanceof Literal)
+        return [
+            { name: `${parameterName(expression.value.name)}_0`, value: expression.low.value },
+            { name: `${parameterName(expression.value.name)}_1`, value: expression.high.value },
+        ];
+    if (expression instanceof Operator.Between || expression instanceof Operator.NotBetween)
+        return [...collect(expression.value), ...collect(expression.low), ...collect(expression.high)];
+    const operands = expression instanceof Operator ? pair(expression) : undefined;
+    if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
+        return [{ name: parameterName(operands.left.name), value: operands.right.value }];
+    if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
+        return [];
+    if (operands)
+        return [...collect(operands.left), ...collect(operands.right)];
+    if (expression instanceof ArrayExpression)
+        return expression.elements.flatMap(collect);
+    throw new Error("empty expression");
+};
+export class Where {
+    condition;
+    constructor(columnOrCondition, op = eq, value = null) {
+        this.condition =
+            typeof columnOrCondition === "string" ? op(columnOrCondition, value) : columnOrCondition;
+    }
+    and(column, op, value) {
+        return new Where(new Operator.And(this.condition, op(column, value)));
+    }
+    or(column, op, value) {
+        return new Where(new Operator.Or(this.condition, op(column, value)));
+    }
+    map(column, value) {
+        return new Where(rewrite(this.condition, column, value));
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return collect(this.condition);
+    }
+}

package/dist/statements/WhereText.d.ts

@@ -0,0 +1,8 @@
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IWhere } from "./IWhere.js";
+export declare class WhereText implements IWhere {
+    private readonly text;
+    constructor(text: string);
+    get rawText(): string;
+    accept: (visitor: IConditionVisitor) => string;
+}

package/dist/statements/WhereText.js

@@ -0,0 +1,10 @@
+export class WhereText {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    get rawText() {
+        return this.text;
+    }
+    accept = (visitor) => visitor.visit(this);
+}