@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/statements/StatementRenderer.ts

@@ -1,120 +0,0 @@
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
-import { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.ts";
-import { BulkInsertStatement } from "./BulkInsertStatement.ts";
-import { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.ts";
-import { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
-import { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.ts";
-import { CreateIndexStatement } from "./CreateIndexStatement.ts";
-import { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.ts";
-import { CreateTableStatement } from "./CreateTableStatement.ts";
-import { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.ts";
-import { DeleteStatement } from "./DeleteStatement.ts";
-import { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.ts";
-import { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-import { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.ts";
-import { InsertStatement } from "./InsertStatement.ts";
-import { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.ts";
-import { ReturnStatement } from "./ReturnStatement.ts";
-import { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.ts";
-import { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
-import { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.ts";
-import { SelectStatement } from "./SelectStatement.ts";
-import { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.ts";
-import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
-import { UpdateStatement } from "./UpdateStatement.ts";
-import { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.ts";
-
-type AnyStatement =
-  | SelectStatement
-  | InsertStatement
-  | UpdateStatement
-  | DeleteStatement
-  | CreateTableStatement
-  | CreateIndexStatement
-  | ExecuteStoredProcedureStatement
-  | ReturnStatement
-  | SelectInsertedIdStatement
-  | BulkInsertStatement
-  | BulkUpdateStatement
-  | BulkDeleteStatement;
-
-export class StatementRenderer implements IStatementVisitor {
-  constructor(protected readonly text: StatementTextRenderer) {}
-
-  visit(statement: SelectStatement): string;
-  visit(statement: InsertStatement): string;
-  visit(statement: UpdateStatement): string;
-  visit(statement: DeleteStatement): string;
-  visit(statement: CreateTableStatement): string;
-  visit(statement: CreateIndexStatement): string;
-  visit(statement: ExecuteStoredProcedureStatement): string;
-  visit(statement: ReturnStatement): string;
-  visit(statement: SelectInsertedIdStatement): string;
-  visit(statement: BulkInsertStatement): string;
-  visit(statement: BulkUpdateStatement): string;
-  visit(statement: BulkDeleteStatement): string;
-  visit(statement: AnyStatement): string {
-    if (statement instanceof SelectStatement) return this.visitSelect(statement);
-    if (statement instanceof InsertStatement) return this.visitInsert(statement);
-    if (statement instanceof UpdateStatement) return this.visitUpdate(statement);
-    if (statement instanceof DeleteStatement) return this.visitDelete(statement);
-    if (statement instanceof CreateTableStatement) return this.visitCreateTable(statement);
-    if (statement instanceof CreateIndexStatement) return this.visitCreateIndex(statement);
-    if (statement instanceof ExecuteStoredProcedureStatement)
-      return this.visitExecuteStoredProcedure(statement);
-    if (statement instanceof ReturnStatement) return this.visitReturn(statement);
-    if (statement instanceof BulkInsertStatement) return this.visitBulkInsert(statement);
-    if (statement instanceof BulkUpdateStatement) return this.visitBulkUpdate(statement);
-    if (statement instanceof BulkDeleteStatement) return this.visitBulkDelete(statement);
-    return this.visitSelectInsertedId(statement as SelectInsertedIdStatement);
-  }
-
-  protected visitSelect(statement: SelectStatement): string {
-    return new SelectStatementTextRenderer(this.text).render(statement);
-  }
-
-  protected visitInsert(statement: InsertStatement): string {
-    return new InsertStatementTextRenderer().render(statement);
-  }
-
-  protected visitUpdate(statement: UpdateStatement): string {
-    return new UpdateStatementTextRenderer(this.text).render(statement);
-  }
-
-  protected visitDelete(statement: DeleteStatement): string {
-    return new DeleteStatementTextRenderer(this.text).render(statement);
-  }
-
-  protected visitCreateTable(statement: CreateTableStatement): string {
-    return new CreateTableStatementTextRenderer().render(statement);
-  }
-
-  protected visitCreateIndex(statement: CreateIndexStatement): string {
-    return new CreateIndexStatementTextRenderer().render(statement);
-  }
-
-  protected visitExecuteStoredProcedure(statement: ExecuteStoredProcedureStatement): string {
-    return new ExecuteStoredProcedureStatementTextRenderer().render(statement);
-  }
-
-  protected visitReturn(statement: ReturnStatement): string {
-    return new ReturnStatementTextRenderer().render(statement);
-  }
-
-  protected visitSelectInsertedId(statement: SelectInsertedIdStatement): string {
-    return new SelectInsertedIdStatementTextRenderer().render(statement);
-  }
-
-  protected visitBulkInsert(statement: BulkInsertStatement): string {
-    return new BulkInsertStatementTextRenderer().render(statement);
-  }
-
-  protected visitBulkUpdate(statement: BulkUpdateStatement): string {
-    return new BulkUpdateStatementTextRenderer().render(statement);
-  }
-
-  protected visitBulkDelete(statement: BulkDeleteStatement): string {
-    return new BulkDeleteStatementTextRenderer().render(statement);
-  }
-}

package/src/statements/StatementTextRenderer.ts

@@ -1,60 +0,0 @@
-import type { ICondition } from "./ICondition.ts";
-import type { IConditionVisitor } from "./IConditionVisitor.ts";
-import type { IStatement } from "./IStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import { ConditionRenderer } from "./ConditionRenderer.ts";
-import { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
-import { BulkInsertStatement } from "./BulkInsertStatement.ts";
-import { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
-import { CreateIndexStatement } from "./CreateIndexStatement.ts";
-import { CreateTableStatement } from "./CreateTableStatement.ts";
-import { DeleteStatement } from "./DeleteStatement.ts";
-import { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-import { ExpressionRenderer } from "./ExpressionRenderer.ts";
-import { InsertStatement } from "./InsertStatement.ts";
-import { ReturnStatement } from "./ReturnStatement.ts";
-import { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
-import { SelectStatement } from "./SelectStatement.ts";
-import { StatementRenderer } from "./StatementRenderer.ts";
-import { UpdateStatement } from "./UpdateStatement.ts";
-import { Where } from "./Where.ts";
-import { WhereText } from "./WhereText.ts";
-
-export class StatementTextRenderer {
-  protected readonly statements: IStatementVisitor;
-  protected readonly conditions: IConditionVisitor;
-
-  constructor(
-    statements?: (text: StatementTextRenderer) => StatementRenderer,
-    conditions?: (expressions: ExpressionRenderer) => ConditionRenderer,
-    expressions?: (text: StatementTextRenderer) => ExpressionRenderer,
-  ) {
-    const expressionRenderer = expressions?.(this) ?? new ExpressionRenderer(this);
-    this.statements = statements?.(this) ?? new StatementRenderer(this);
-    this.conditions = conditions?.(expressionRenderer) ?? new ConditionRenderer(expressionRenderer);
-  }
-
-  render(statement: IStatement): string;
-  render(condition: ICondition): string;
-  render(target: IStatement | ICondition): string {
-    if (target instanceof Where || target instanceof WhereText) return target.accept(this.conditions);
-    if (
-      target instanceof SelectStatement ||
-      target instanceof InsertStatement ||
-      target instanceof UpdateStatement ||
-      target instanceof DeleteStatement ||
-      target instanceof CreateTableStatement ||
-      target instanceof CreateIndexStatement ||
-      target instanceof ExecuteStoredProcedureStatement ||
-      target instanceof ReturnStatement ||
-      target instanceof SelectInsertedIdStatement ||
-      target instanceof BulkInsertStatement ||
-      target instanceof BulkUpdateStatement ||
-      target instanceof BulkDeleteStatement
-    )
-      return target.accept(this.statements);
-    return "where" in target || "fields" in target || "joins" in target || "column" in target
-      ? (target as IStatement).accept(this.statements)
-      : (target as ICondition).accept(this.conditions);
-  }
-}

package/src/statements/Subquery.ts

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

package/src/statements/UniqueConstraint.ts

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

package/src/statements/UpdateStatement.ts

@@ -1,34 +0,0 @@
-import type { Field } from "../builders/Field.ts";
-import type { Parameter } from "../Parameter.ts";
-import { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import type { IUpdateStatement } from "./IUpdateStatement.ts";
-import type { IWhere } from "./IWhere.ts";
-import { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.ts";
-
-export class UpdateStatement implements IUpdateStatement {
-  readonly table: string;
-  readonly fields: Field[];
-  readonly where?: IWhere;
-
-  constructor(table: string, fields: Field[], where?: IWhere) {
-    this.table = table;
-    this.fields = fields;
-    this.where = where;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-
-  get parameters(): Parameter[] {
-    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: Field[], where?: IWhere): Parameter[] =>
-    new UpdateStatementTextRenderer(DefaultStatementTextRenderer.instance).compose("", where, fields)
-      .parameters;
-}

package/src/statements/UpdateStatementTextRenderer.ts

@@ -1,63 +0,0 @@
-import type { Field } from "../builders/Field.ts";
-import type { Scalar } from "../builders/Scalar.ts";
-import type { Parameter } from "../Parameter.ts";
-import type { IWhere } from "./IWhere.ts";
-import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
-import type { UpdateStatement } from "./UpdateStatement.ts";
-
-const rename = (text: string, name: string, alias: string): string => {
-  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: Field[]): string =>
-  fields.map((field) => `${field.name} = $${field.name}`).join(", ");
-
-export class UpdateStatementTextRenderer {
-  constructor(private readonly text: StatementTextRenderer) {}
-
-  render(statement: UpdateStatement): string {
-    return this.compose(
-      `UPDATE ${statement.table} SET ${setClause(statement.fields)}`,
-      statement.where,
-      statement.fields,
-    ).text;
-  }
-
-  compose(
-    sql: string,
-    where: IWhere | undefined,
-    fields: Field[],
-  ): { text: string; parameters: Parameter[] } {
-    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: Parameter[] = [...fields];
-    const values = new Map<string, Scalar>();
-    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/src/statements/Where.ts

@@ -1,250 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { Cell } from "../converters/Cell.ts";
-import { ArrayExpression } from "./ArrayExpression.ts";
-import { Identifier } from "./Identifier.ts";
-import type { IConditionVisitor } from "./IConditionVisitor.ts";
-import type { IExpression } from "./IExpression.ts";
-import type { IWhere } from "./IWhere.ts";
-import { Literal } from "./Literal.ts";
-import { Operator } from "./Operator.ts";
-import type { Comparison } from "./Cmp.ts";
-import { eq } from "./Cmp.ts";
-import { SelectStatement } from "./SelectStatement.ts";
-import { Subquery } from "./Subquery.ts";
-
-const pair = (
-  expression: Operator,
-): { left: IExpression; right: IExpression } | undefined =>
-  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: string): string =>
-  parts(name)
-    .map((part) =>
-      part.length >= 2 && part.startsWith('"') && part.endsWith('"')
-        ? part.slice(1, -1).replace(/""/g, '"')
-        : part,
-    )
-    .join(".");
-
-const parts = (name: string): string[] => {
-  const found: string[] = [];
-  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: IExpression,
-  other: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  expression instanceof Literal && other instanceof Identifier
-    ? new Literal(value(other.name, expression.value))
-    : rewrite(expression, column, value);
-
-const inRight = (
-  left: IExpression,
-  right: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  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: IExpression,
-  edge: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  subject instanceof Identifier && edge instanceof Literal
-    ? new Literal(value(subject.name, edge.value))
-    : rewrite(edge, column, value);
-
-const rewriteWhere = (
-  where: IWhere | undefined,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IWhere | undefined =>
-  where instanceof Where ? new Where(rewrite(where.condition, column, value)) : where;
-
-const rewriteQuery = (
-  query: SelectStatement,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): SelectStatement =>
-  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: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  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: string, elements: IExpression[]): Parameter<Cell>[] =>
-  elements.map((element, i) =>
-    element instanceof Literal
-      ? { name: `${parameterName(name)}_${i}`, value: element.value }
-      : (() => {
-          throw new Error("empty in");
-        })(),
-  );
-
-const collect = (expression: IExpression): Parameter<Cell>[] => {
-  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 implements IWhere {
-  readonly condition: IExpression;
-
-  constructor(condition: IExpression);
-  constructor(column: string, op: Comparison, value: Cell);
-  constructor(columnOrCondition: IExpression | string, op: Comparison = eq, value: Cell = null) {
-    this.condition =
-      typeof columnOrCondition === "string" ? op(columnOrCondition, value) : columnOrCondition;
-  }
-
-  and(column: string, op: Comparison, value: Cell): Where {
-    return new Where(new Operator.And(this.condition, op(column, value)));
-  }
-
-  or(column: string, op: Comparison, value: Cell): Where {
-    return new Where(new Operator.Or(this.condition, op(column, value)));
-  }
-
-  map(column: (name: string) => string, value: (name: string, cell: Cell) => Cell): Where {
-    return new Where(rewrite(this.condition, column, value));
-  }
-
-  accept = (visitor: IConditionVisitor): string => visitor.visit(this);
-
-  get parameters(): Parameter[] {
-    return collect(this.condition) as Parameter[];
-  }
-}

package/src/statements/WhereText.ts

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

package/src/statements/index.ts

@@ -1,75 +0,0 @@
-export type { IExpression } from "./IExpression.ts";
-export type { IStatement } from "./IStatement.ts";
-export type { IStatementVisitor } from "./IStatementVisitor.ts";
-export type { ICondition } from "./ICondition.ts";
-export type { IConditionVisitor } from "./IConditionVisitor.ts";
-export type { IWhere } from "./IWhere.ts";
-export type { ISelectStatement } from "./ISelectStatement.ts";
-export type { IInsertStatement } from "./IInsertStatement.ts";
-export type { IUpdateStatement } from "./IUpdateStatement.ts";
-export type { IDeleteStatement } from "./IDeleteStatement.ts";
-export type { IBulkInsertStatement } from "./IBulkInsertStatement.ts";
-export type { IBulkUpdateStatement } from "./IBulkUpdateStatement.ts";
-export type { IBulkDeleteStatement } from "./IBulkDeleteStatement.ts";
-export type { ICreateTableStatement } from "./ICreateTableStatement.ts";
-export type { ICreateIndexStatement } from "./ICreateIndexStatement.ts";
-export type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.ts";
-export type { IReturnStatement } from "./IReturnStatement.ts";
-export type { Column } from "./Column.ts";
-export type { ITableConstraint, TableConstraintKind } from "./ITableConstraint.ts";
-export type { Join, JoinKind } from "./Join.ts";
-export { Join } from "./Join.ts";
-export { Aggregate } from "./Aggregate.ts";
-export type { SortDirection } from "./OrderBy.ts";
-export { OrderBy } from "./OrderBy.ts";
-export type { SelectStatementOptions } from "./SelectStatementOptions.ts";
-export { Condition } from "./Condition.ts";
-export { Operator } from "./Operator.ts";
-export { eq, ne, gt, lt, ge, le } from "./Cmp.ts";
-export type { Comparison } from "./Cmp.ts";
-export { Identifier } from "./Identifier.ts";
-export { Literal } from "./Literal.ts";
-export { ArrayExpression } from "./ArrayExpression.ts";
-export { Where } from "./Where.ts";
-export { ExpressionEvaluator } from "./ExpressionEvaluator.ts";
-export { StatementEvaluator } from "./StatementEvaluator.ts";
-export { WhereText } from "./WhereText.ts";
-export { SelectStatement } from "./SelectStatement.ts";
-export { StatementParser } from "./StatementParser.ts";
-export { StatementTextRenderer } from "./StatementTextRenderer.ts";
-export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.ts";
-export { StatementRenderer } from "./StatementRenderer.ts";
-export { ExpressionRenderer } from "./ExpressionRenderer.ts";
-export { ConditionRenderer } from "./ConditionRenderer.ts";
-export { Native, n } from "./Native.ts";
-export { Subquery } from "./Subquery.ts";
-export { InsertStatement } from "./InsertStatement.ts";
-export { UpdateStatement } from "./UpdateStatement.ts";
-export { DeleteStatement } from "./DeleteStatement.ts";
-export { BulkInsertStatement } from "./BulkInsertStatement.ts";
-export { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
-export { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
-export { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.ts";
-export { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.ts";
-export { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.ts";
-export { CreateTableStatement } from "./CreateTableStatement.ts";
-export { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.ts";
-export { CreateIndexStatement } from "./CreateIndexStatement.ts";
-export { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.ts";
-export { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.ts";
-export { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.ts";
-export { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.ts";
-export { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.ts";
-export { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.ts";
-export { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.ts";
-export { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.ts";
-export { ColumnDefault } from "./ColumnDefault.ts";
-export { NotNull } from "./NotNull.ts";
-export { PrimaryKey } from "./PrimaryKey.ts";
-export { ForeignKey, ReferentialAction } from "./ForeignKey.ts";
-export type { ReferentialAction as ReferentialActionName } from "./ForeignKey.ts";
-export { UniqueConstraint } from "./UniqueConstraint.ts";
-export { CheckConstraint } from "./CheckConstraint.ts";
-export { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-export { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
-export { ReturnStatement } from "./ReturnStatement.ts";

package/src/stubs/StubCommand.ts

@@ -1,30 +0,0 @@
-import type { ICommand } from "../ICommand.ts";
-import type { IConnection } from "../IConnection.ts";
-import type { Cells } from "../converters/Cell.ts";
-import type { IReader } from "../IReader.ts";
-import type { Response } from "../Response.ts";
-import type { Parameter } from "../Parameter.ts";
-import { CommandMiddlewareHost } from "../CommandMiddlewareHost.ts";
-import { Native } from "../statements/Native.ts";
-import { notImplemented } from "./notImplemented.ts";
-
-export class StubCommand extends CommandMiddlewareHost implements ICommand {
-  constructor(
-    readonly provider: string,
-    readonly connection: IConnection,
-  ) {
-    super();
-  }
-
-  executeReaderNative = (
-    text: Native,
-    parameters?: Parameter[],
-  ): Promise<IReader<Cells>> =>
-    this.run(text.text, parameters, async () => notImplemented(this.provider));
-
-  executeNative = (
-    text: Native,
-    parameters?: Parameter[],
-  ): Promise<Response> =>
-    this.run(text.text, parameters, async () => notImplemented(this.provider));
-}