@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/statements/StatementParser.ts

@@ -1,461 +0,0 @@
-import type { Field } from "../builders/Field.ts";
-import { ArrayExpression } from "./ArrayExpression.ts";
-import { DeleteStatement } from "./DeleteStatement.ts";
-import { Identifier } from "./Identifier.ts";
-import type { IExpression } from "./IExpression.ts";
-import type { IStatement } from "./IStatement.ts";
-import { InsertStatement } from "./InsertStatement.ts";
-import { Join, type JoinKind } from "./Join.ts";
-import { Literal } from "./Literal.ts";
-import { Operator } from "./Operator.ts";
-import { OrderBy } from "./OrderBy.ts";
-import { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.ts";
-import { SelectStatement } from "./SelectStatement.ts";
-import { Subquery } from "./Subquery.ts";
-import { UpdateStatement } from "./UpdateStatement.ts";
-import { Where } from "./Where.ts";
-
-const empty = (): never => {
-  throw new Error("empty statement");
-};
-
-class Cursor {
-  private i = 0;
-
-  constructor(private readonly text: string) {}
-
-  statement(): IStatement {
-    const word = (["SELECT", "INSERT", "UPDATE", "DELETE"] as const).find((name) => this.peekWord(name)) ?? empty();
-    return {
-      SELECT: () => this.selectStatement(),
-      INSERT: () => this.parseInsert(),
-      UPDATE: () => this.parseUpdate(),
-      DELETE: () => this.parseDelete(),
-    }[word]();
-  }
-
-  private parseInsert(): InsertStatement {
-    this.expectWord("INSERT");
-    this.expectWord("INTO");
-    const table = this.ident();
-    this.expectChar("(");
-    const columns = [this.ident()];
-    while (this.tryChar(",")) columns.push(this.ident());
-    this.expectChar(")");
-    this.expectWord("VALUES");
-    this.expectChar("(");
-    const values = [this.rawExpr()];
-    while (this.tryChar(",")) values.push(this.rawExpr());
-    this.expectChar(")");
-    const fields: Field[] = columns.map((name) => ({ name, value: null }));
-    return values.length === columns.length &&
-      values.every((value, index) => value.trim() === `$${columns[index]}`)
-      ? new InsertStatement(table, fields)
-      : empty();
-  }
-
-  private parseUpdate(): UpdateStatement {
-    this.expectWord("UPDATE");
-    const table = this.ident();
-    this.expectWord("SET");
-    const columns: string[] = [];
-    let canonical = this.assignment(columns);
-    while (this.tryChar(",")) canonical = this.assignment(columns) && canonical;
-    const where = this.tryWord("WHERE") ? new Where(this.expr()) : undefined;
-    const fields: Field[] = columns.map((name) => ({ name, value: null }));
-    return canonical ? new UpdateStatement(table, fields, where) : empty();
-  }
-
-  private assignment(columns: string[]): boolean {
-    const column = this.ident();
-    this.expectChar("=");
-    const raw = this.rawExpr();
-    columns.push(column);
-    return raw.trim() === `$${column}`;
-  }
-
-  private parseDelete(): DeleteStatement {
-    this.expectWord("DELETE");
-    this.expectWord("FROM");
-    const table = this.ident();
-    return new DeleteStatement(table, this.tryWord("WHERE") ? new Where(this.expr()) : undefined);
-  }
-
-  private rawExpr(): string {
-    this.skip();
-    const start = this.i;
-    this.expr();
-    return this.text.slice(start, this.i);
-  }
-
-  end(): void {
-    this.skip();
-    if (this.i !== this.text.length) empty();
-  }
-
-  private selectStatement(): SelectStatement {
-    this.expectWord("SELECT");
-    const distinct = this.tryWord("DISTINCT");
-    const fields = this.selectList();
-    this.expectWord("FROM");
-    const table = this.fromItem();
-    const joins = this.joins();
-    const where = this.tryWord("WHERE") ? new Where(this.expr()) : undefined;
-    const groupBy = this.tryWord("GROUP") ? this.group() : undefined;
-    const having = this.tryWord("HAVING") ? new Where(this.expr()) : undefined;
-    const orderBy = this.tryWord("ORDER") ? this.order() : undefined;
-    const limit = this.tryWord("LIMIT") ? this.integer() : undefined;
-    const offset = this.tryWord("OFFSET") ? this.integer() : undefined;
-    return new SelectStatement({
-      distinct,
-      table,
-      fields,
-      where,
-      joins,
-      groupBy,
-      having,
-      orderBy,
-      limit,
-      offset,
-    });
-  }
-
-  private selectList(): string[] {
-    if (this.tryChar("*")) return [];
-    const fields = [this.selectItem()];
-    while (this.tryChar(",")) fields.push(this.selectItem());
-    return fields;
-  }
-
-  private selectItem(): string {
-    for (const name of ["COUNT", "SUM", "MIN", "MAX"]) {
-      const mark = this.i;
-      if (!this.tryWord(name) || !this.tryChar("(")) {
-        this.i = mark;
-        continue;
-      }
-      const arg = this.tryChar("*") ? "*" : this.ident();
-      this.expectChar(")");
-      const alias = this.tryWord("AS") ? ` AS ${this.ident()}` : "";
-      return `${name}(${arg})${alias}`;
-    }
-    const column = this.ident();
-    return this.tryWord("AS") ? `${column} AS ${this.ident()}` : column;
-  }
-
-  private fromItem(): string {
-    if (!this.peek("(")) return this.ident();
-    const nested = this.nested();
-    this.expectWord("AS");
-    return `(${DefaultStatementTextRenderer.instance.render(nested)}) AS ${this.ident()}`;
-  }
-
-  private nested(): SelectStatement {
-    this.expectChar("(");
-    const query = this.selectStatement();
-    this.expectChar(")");
-    return query;
-  }
-
-  private joins(): Join[] {
-    const joins: Join[] = [];
-    for (let kind = this.kind(); kind; kind = this.kind()) {
-      this.expectWord(
-        kind === "cross"
-          ? "CROSS"
-          : kind === "inner"
-            ? "INNER"
-            : kind === "left"
-              ? "LEFT"
-              : kind === "right"
-                ? "RIGHT"
-                : "FULL",
-      );
-      this.expectWord("JOIN");
-      const table = this.fromItem();
-      joins.push(kind === "cross" ? Join.cross(table) : { kind, table, on: this.on() });
-    }
-    return joins;
-  }
-
-  private kind(): JoinKind | undefined {
-    return this.peekWord("CROSS")
-      ? "cross"
-      : this.peekWord("INNER")
-        ? "inner"
-        : this.peekWord("LEFT")
-          ? "left"
-          : this.peekWord("RIGHT")
-            ? "right"
-            : this.peekWord("FULL")
-              ? "full"
-              : undefined;
-  }
-
-  private on(): IExpression {
-    this.expectWord("ON");
-    return this.expr();
-  }
-
-  private group(): string[] {
-    this.expectWord("BY");
-    return this.list(() => this.ident());
-  }
-
-  private order(): OrderBy[] {
-    this.expectWord("BY");
-    return this.list(() => this.orderItem());
-  }
-
-  private orderItem(): OrderBy {
-    const column = this.ident();
-    if (this.tryWord("DESC")) return OrderBy.desc(column);
-    this.expectWord("ASC");
-    return OrderBy.asc(column);
-  }
-
-  private list<T>(item: () => T): T[] {
-    const items = [item()];
-    while (this.tryChar(",")) items.push(item());
-    return items;
-  }
-
-  private expr(): IExpression {
-    let left = this.and();
-    while (this.tryWord("OR")) left = new Operator.Or(left, this.and());
-    return left;
-  }
-
-  private and(): IExpression {
-    let left = this.not();
-    while (this.tryWord("AND")) left = new Operator.And(left, this.not());
-    return left;
-  }
-
-  private not(): IExpression {
-    if (!this.peekWord("NOT") || !this.peekAfter("NOT", "(")) return this.predicate();
-    this.expectWord("NOT");
-    this.expectChar("(");
-    const inner = this.expr();
-    this.expectChar(")");
-    return new Operator.Not(inner);
-  }
-
-  private predicate(): IExpression {
-    if (this.tryWord("EXISTS")) return new Operator.Exists(new Subquery(this.nested()));
-    const left = this.primary();
-    if (this.tryWord("IS")) return this.nullTest(left);
-    if (this.tryWord("NOT")) return this.negated(left);
-    if (this.tryWord("IN")) return new Operator.In(left, this.inList());
-    if (this.tryWord("BETWEEN")) return this.bounds(left, false);
-    if (this.tryWord("LIKE")) return new Operator.Like(left, this.param());
-    if (this.tryText("<>")) return new Operator.NotEquals(left, this.primary());
-    if (this.tryText("<=")) return new Operator.LessThanOrEqual(left, this.primary());
-    if (this.tryText(">=")) return new Operator.GreaterThanOrEqual(left, this.primary());
-    if (this.tryChar("=")) return new Operator.Equals(left, this.primary());
-    if (this.tryChar("<")) return new Operator.LessThan(left, this.primary());
-    if (this.tryChar(">")) return new Operator.GreaterThan(left, this.primary());
-    return left;
-  }
-
-  private nullTest(left: IExpression): IExpression {
-    if (this.tryWord("NOT")) {
-      this.expectWord("NULL");
-      return new Operator.IsNotNull(left);
-    }
-    this.expectWord("NULL");
-    return new Operator.IsNull(left);
-  }
-
-  private negated(left: IExpression): IExpression {
-    if (this.tryWord("IN")) return new Operator.NotIn(left, this.inList());
-    if (this.tryWord("BETWEEN")) return this.bounds(left, true);
-    this.expectWord("LIKE");
-    return new Operator.NotLike(left, this.param());
-  }
-
-  private bounds(left: IExpression, not: boolean): IExpression {
-    const low = this.param();
-    this.expectWord("AND");
-    const high = this.param();
-    return not ? new Operator.NotBetween(left, low, high) : new Operator.Between(left, low, high);
-  }
-
-  private inList(): IExpression {
-    this.expectChar("(");
-    if (this.peekWord("SELECT")) {
-      const query = this.selectStatement();
-      this.expectChar(")");
-      return new Subquery(query);
-    }
-    const items = [this.param()];
-    while (this.tryChar(",")) items.push(this.param());
-    this.expectChar(")");
-    return new ArrayExpression(items);
-  }
-
-  private primary(): IExpression {
-    if (this.tryChar("(")) {
-      if (this.peekWord("SELECT")) {
-        const query = this.selectStatement();
-        this.expectChar(")");
-        return new Subquery(query);
-      }
-      const inner = this.expr();
-      this.expectChar(")");
-      return inner;
-    }
-    if (this.tryChar("$")) {
-      this.ident();
-      return new Literal(null);
-    }
-    if (this.peekDigit()) return new Literal(this.integer());
-    if (this.tryWord("true")) return new Literal(true);
-    if (this.tryWord("false")) return new Literal(false);
-    if (this.tryWord("null")) return new Literal(null);
-    if (this.peek("'")) return this.string();
-    return new Identifier(this.ident());
-  }
-
-  private param(): IExpression {
-    this.expectChar("$");
-    this.ident();
-    return new Literal(null);
-  }
-
-  private string(): IExpression {
-    this.expectChar("'");
-    let value = "";
-    while (this.i < this.text.length) {
-      if (this.text[this.i] === "'") {
-        if (this.text[this.i + 1] === "'") {
-          value += "'";
-          this.i += 2;
-          continue;
-        }
-        this.i++;
-        return new Literal(value);
-      }
-      value += this.text[this.i++];
-    }
-    return empty();
-  }
-
-  private ident(): string {
-    let name = this.part();
-    while (this.tryChar(".")) name += `.${this.part()}`;
-    return name;
-  }
-
-  private part(): string {
-    this.skip();
-    return this.peek('"') ? this.quoted() : this.name();
-  }
-
-  private quoted(): string {
-    this.expectChar('"');
-    let name = '"';
-    while (this.i < this.text.length) {
-      if (this.text[this.i] === '"') {
-        if (this.text[this.i + 1] === '"') {
-          name += '""';
-          this.i += 2;
-          continue;
-        }
-        this.i++;
-        return `${name}"`;
-      }
-      name += this.text[this.i++];
-    }
-    return empty();
-  }
-
-  private name(): string {
-    this.skip();
-    if (this.i >= this.text.length || !/[A-Za-z]/.test(this.at(this.i))) empty();
-    const start = this.i++;
-    while (this.i < this.text.length && /[A-Za-z0-9_]/.test(this.at(this.i))) this.i++;
-    return this.text.slice(start, this.i);
-  }
-
-  private integer(): number {
-    this.skip();
-    const start = this.i;
-    while (this.i < this.text.length && /[0-9]/.test(this.at(this.i))) this.i++;
-    if (start === this.i) empty();
-    return Number(this.text.slice(start, this.i));
-  }
-
-  private peekDigit(): boolean {
-    this.skip();
-    return /[0-9]/.test(this.at(this.i));
-  }
-
-  private peek(token: string): boolean {
-    this.skip();
-    return this.text[this.i] === token;
-  }
-
-  private peekWord(word: string): boolean {
-    const mark = this.i;
-    const matched = this.tryWord(word);
-    this.i = mark;
-    return matched;
-  }
-
-  private peekAfter(word: string, token: string): boolean {
-    const mark = this.i;
-    const matched = this.tryWord(word) && this.peek(token);
-    this.i = mark;
-    return matched;
-  }
-
-  private tryWord(word: string): boolean {
-    this.skip();
-    if (this.i + word.length > this.text.length) return false;
-    if (this.text.slice(this.i, this.i + word.length).toLowerCase() !== word.toLowerCase()) return false;
-    const after = this.i + word.length;
-    if (/[A-Za-z0-9_]/.test(this.at(after))) return false;
-    this.i = after;
-    return true;
-  }
-
-  private tryChar(token: string): boolean {
-    this.skip();
-    if (this.text[this.i] !== token) return false;
-    this.i++;
-    return true;
-  }
-
-  private tryText(token: string): boolean {
-    this.skip();
-    if (!this.text.startsWith(token, this.i)) return false;
-    this.i += token.length;
-    return true;
-  }
-
-  private expectChar(token: string): void {
-    if (!this.tryChar(token)) empty();
-  }
-
-  private expectWord(word: string): void {
-    if (!this.tryWord(word)) empty();
-  }
-
-  private skip(): void {
-    while (this.i < this.text.length && /\s/.test(this.at(this.i))) this.i++;
-  }
-
-  private at(index: number): string {
-    return this.text[index] ?? "";
-  }
-}
-
-export class StatementParser {
-  static parse(text: string): IStatement {
-    const cursor = new Cursor(text);
-    const statement = cursor.statement();
-    cursor.end();
-    return statement;
-  }
-}

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;
-}