@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/statements/StatementParser.ts

@@ -0,0 +1,461 @@
+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

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,34 @@
+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;
+}