@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/statements/Operator.ts

@@ -0,0 +1,234 @@
+import type { Cell } from "../converters/Cell.ts";
+import { ArrayExpression } from "./ArrayExpression.ts";
+import { Condition } from "./Condition.ts";
+import { Identifier } from "./Identifier.ts";
+import type { IExpression } from "./IExpression.ts";
+import { Literal } from "./Literal.ts";
+
+const pair = (
+  left: string | IExpression,
+  right: IExpression | Cell,
+): [IExpression, IExpression] =>
+  typeof left === "string"
+    ? [new Identifier(left), new Literal(right as Cell)]
+    : [left, right as IExpression];
+
+export abstract class Operator extends Condition {}
+
+export namespace Operator {
+  export class Equals extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class NotEquals extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class GreaterThan extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class LessThan extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class GreaterThanOrEqual extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class LessThanOrEqual extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class And extends Operator {
+    constructor(
+      readonly left: IExpression,
+      readonly right: IExpression,
+    ) {
+      super();
+    }
+  }
+
+  export class Or extends Operator {
+    constructor(
+      readonly left: IExpression,
+      readonly right: IExpression,
+    ) {
+      super();
+    }
+  }
+
+  export class In extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, values: Cell[]);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: Cell[] | IExpression) {
+      super();
+      if (typeof left === "string") {
+        this.left = new Identifier(left);
+        this.right = new ArrayExpression(
+          (right as Cell[]).map((value) => new Literal(value)),
+        );
+      } else {
+        this.left = left;
+        this.right = right as IExpression;
+      }
+    }
+  }
+
+  /* v8 ignore next 6 */
+  export class Not extends Operator {
+    readonly argument: IExpression;
+    constructor(argument: IExpression) {
+      super();
+      this.argument = argument;
+    }
+  }
+
+  export class IsNull extends Operator {
+    readonly argument: IExpression;
+    constructor(argument: IExpression) {
+      super();
+      this.argument = argument;
+    }
+  }
+
+  export class IsNotNull extends Operator {
+    readonly argument: IExpression;
+    constructor(argument: IExpression) {
+      super();
+      this.argument = argument;
+    }
+  }
+
+  export class Like extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class NotLike extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, value: Cell);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: IExpression | Cell) {
+      super();
+      [this.left, this.right] = pair(left, right);
+    }
+  }
+
+  export class Between extends Operator {
+    readonly value: IExpression;
+    readonly low: IExpression;
+    readonly high: IExpression;
+    constructor(field: string, low: Cell, high: Cell);
+    constructor(value: IExpression, low: IExpression, high: IExpression);
+    constructor(value: string | IExpression, low: IExpression | Cell, high: IExpression | Cell) {
+      super();
+      if (typeof value === "string") {
+        this.value = new Identifier(value);
+        this.low = new Literal(low as Cell);
+        this.high = new Literal(high as Cell);
+      } else {
+        this.value = value;
+        this.low = low as IExpression;
+        this.high = high as IExpression;
+      }
+    }
+  }
+
+  export class NotBetween extends Operator {
+    readonly value: IExpression;
+    readonly low: IExpression;
+    readonly high: IExpression;
+    constructor(field: string, low: Cell, high: Cell);
+    constructor(value: IExpression, low: IExpression, high: IExpression);
+    constructor(value: string | IExpression, low: IExpression | Cell, high: IExpression | Cell) {
+      super();
+      if (typeof value === "string") {
+        this.value = new Identifier(value);
+        this.low = new Literal(low as Cell);
+        this.high = new Literal(high as Cell);
+      } else {
+        this.value = value;
+        this.low = low as IExpression;
+        this.high = high as IExpression;
+      }
+    }
+  }
+
+  export class NotIn extends Operator {
+    readonly left: IExpression;
+    readonly right: IExpression;
+    constructor(field: string, values: Cell[]);
+    constructor(left: IExpression, right: IExpression);
+    constructor(left: string | IExpression, right: Cell[] | IExpression) {
+      super();
+      if (typeof left === "string") {
+        this.left = new Identifier(left);
+        this.right = new ArrayExpression((right as Cell[]).map((value) => new Literal(value)));
+      } else {
+        this.left = left;
+        this.right = right as IExpression;
+      }
+    }
+  }
+
+  /* v8 ignore next */
+  export class Exists extends Operator {
+    readonly argument: IExpression;
+    constructor(argument: IExpression) {
+      super();
+      this.argument = argument;
+    }
+  }
+}

package/src/statements/OrderBy.ts

@@ -0,0 +1,19 @@
+export type SortDirection = "asc" | "desc";
+
+export type OrderBy = {
+  column: string;
+  direction: SortDirection;
+};
+
+const directionSql: Record<SortDirection, string> = {
+  asc: "ASC",
+  desc: "DESC",
+};
+
+export const OrderBy = {
+  asc: (column: string): OrderBy => ({ column, direction: "asc" }),
+  desc: (column: string): OrderBy => ({ column, direction: "desc" }),
+};
+
+export const orderText = (order: OrderBy): string =>
+  `${order.column} ${directionSql[order.direction]}`;

package/src/statements/PrimaryKey.ts

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

package/src/statements/ReturnStatement.ts

@@ -0,0 +1,15 @@
+import type { Parameter } from "../Parameter.ts";
+import type { IReturnStatement } from "./IReturnStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+export class ReturnStatement implements IReturnStatement {
+  readonly name: string;
+  readonly parameters: Parameter[];
+
+  constructor(name: string, parameters: Parameter[]) {
+    this.name = name;
+    this.parameters = parameters;
+  }
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/ReturnStatementTextRenderer.ts

@@ -0,0 +1,15 @@
+import { ParameterDirection } from "../ParameterDirection.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { ReturnStatement } from "./ReturnStatement.ts";
+
+const args = (parameters: Parameter[]): string =>
+  parameters
+    .filter((parameter) => parameter.direction !== ParameterDirection.ReturnValue)
+    .map((parameter) => `$${parameter.name}`)
+    .join(", ");
+
+export class ReturnStatementTextRenderer {
+  render(statement: ReturnStatement): string {
+    return `SELECT ${statement.name}(${args(statement.parameters)})`;
+  }
+}

package/src/statements/SelectInsertedIdStatement.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DefaultStatementTextRenderer, SelectInsertedIdStatement } from "../index.ts";
+
+describe("SelectInsertedIdStatement", () => {
+  it("requires a provider implementation", () => {
+    const statement = new SelectInsertedIdStatement("users", "id");
+    expect(() => DefaultStatementTextRenderer.instance.render(statement)).toThrow(
+      "provider must implement SelectInsertIdStatement",
+    );
+  });
+});

package/src/statements/SelectInsertedIdStatement.ts

@@ -0,0 +1,11 @@
+import type { IStatement } from "./IStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+export class SelectInsertedIdStatement implements IStatement {
+  constructor(
+    readonly table: string,
+    readonly column: string,
+  ) {}
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/SelectInsertedIdStatementTextRenderer.ts

@@ -0,0 +1,7 @@
+import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
+
+export class SelectInsertedIdStatementTextRenderer {
+  render(_statement: SelectInsertedIdStatement): string {
+    throw new Error("provider must implement SelectInsertIdStatement");
+  }
+}

package/src/statements/SelectStatement.ts

@@ -0,0 +1,34 @@
+import type { ISelectStatement } from "./ISelectStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+import type { IWhere } from "./IWhere.ts";
+import type { Join } from "./Join.ts";
+import type { OrderBy } from "./OrderBy.ts";
+import type { SelectStatementOptions } from "./SelectStatementOptions.ts";
+
+export class SelectStatement implements ISelectStatement {
+  readonly where?: IWhere;
+  readonly distinct: boolean;
+  readonly table?: string;
+  readonly fields: string[];
+  readonly joins: Join[];
+  readonly groupBy: string[];
+  readonly having?: IWhere;
+  readonly orderBy: OrderBy[];
+  readonly limit?: number;
+  readonly offset?: number;
+
+  constructor(options: SelectStatementOptions) {
+    this.where = options.where;
+    this.distinct = options.distinct ?? false;
+    this.table = options.table;
+    this.fields = options.fields ?? [];
+    this.joins = options.joins ?? [];
+    this.groupBy = options.groupBy ?? [];
+    this.having = options.having;
+    this.orderBy = options.orderBy ?? [];
+    this.limit = options.limit;
+    this.offset = options.offset;
+  }
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/SelectStatementOptions.ts

@@ -0,0 +1,16 @@
+import type { Join } from "./Join.ts";
+import type { IWhere } from "./IWhere.ts";
+import type { OrderBy } from "./OrderBy.ts";
+
+export type SelectStatementOptions = {
+  table?: string;
+  fields?: string[];
+  distinct?: boolean;
+  where?: IWhere;
+  joins?: Join[];
+  groupBy?: string[];
+  having?: IWhere;
+  orderBy?: OrderBy[];
+  limit?: number;
+  offset?: number;
+};

package/src/statements/SelectStatementTextRenderer.ts

@@ -0,0 +1,71 @@
+import type { IWhere } from "./IWhere.ts";
+import type { Join, JoinKind } from "./Join.ts";
+import { orderText, type OrderBy } from "./OrderBy.ts";
+import type { SelectStatement } from "./SelectStatement.ts";
+import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
+import { Where } from "./Where.ts";
+
+export class SelectStatementTextRenderer {
+  constructor(private readonly text: StatementTextRenderer) {}
+
+  render(statement: SelectStatement): string {
+    return `SELECT ${statement.distinct ? "DISTINCT " : ""}${
+      statement.fields.length === 0 ? "*" : statement.fields.join(", ")
+    } FROM ${statement.table}${this.joinSql(statement.joins)}${this.whereSql(statement.where)}${this.groupSql(statement.groupBy)}${this.havingSql(statement.having)}${this.orderSql(statement.orderBy)}${this.limit(statement.limit)}${this.offset(statement.offset)}`;
+  }
+
+  protected whereSql(where?: IWhere): string {
+    return where ? ` WHERE ${this.text.render(where)}` : "";
+  }
+
+  protected havingSql(having?: IWhere): string {
+    return having ? ` HAVING ${this.text.render(having)}` : "";
+  }
+
+  protected groupSql(columns?: string[]): string {
+    return !columns || columns.length === 0 ? "" : ` GROUP BY ${columns.join(", ")}`;
+  }
+
+  protected orderSql(order?: OrderBy[]): string {
+    return !order || order.length === 0 ? "" : ` ORDER BY ${order.map(orderText).join(", ")}`;
+  }
+
+  protected limit(limit?: number): string {
+    return this.bound("LIMIT", limit);
+  }
+
+  protected offset(offset?: number): string {
+    return this.bound("OFFSET", offset);
+  }
+
+  protected bound(keyword: string, value?: number): string {
+    if (value === undefined) return "";
+    if (value < 0) throw new Error(`negative ${keyword.toLowerCase()}`);
+    return ` ${keyword} ${value}`;
+  }
+
+  protected joinSql(joins?: Join[]): string {
+    if (!joins || joins.length === 0) return "";
+    return joins
+      .map((join) =>
+        join.kind === "cross"
+          ? ` CROSS JOIN ${join.table}`
+          : ` ${this.keyword(join.kind)} ${join.table} ON ${this.text.render(
+              new Where(join.on ?? (() => { throw new Error("empty join"); })()),
+            )}`,
+      )
+      .join("");
+  }
+
+  protected keyword(kind: JoinKind): string {
+    return (
+      {
+        inner: "INNER JOIN",
+        left: "LEFT JOIN",
+        right: "RIGHT JOIN",
+        full: "FULL JOIN",
+        cross: "CROSS JOIN",
+      } as Record<JoinKind, string>
+    )[kind];
+  }
+}

package/src/statements/StatementCompile.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, it } from "vitest";
+import {
+  Aggregate,
+  CheckConstraint,
+  ColumnDefault,
+  CreateIndexStatement,
+  CreateTableStatement,
+  DeleteStatement,
+  ForeignKey,
+  InsertStatement,
+  Join,
+  NotNull,
+  Operator,
+  OrderBy,
+  PrimaryKey,
+  SelectStatement,
+  ReferentialAction,
+  ReturnStatement,
+  UniqueConstraint,
+  ExecuteStoredProcedureStatement,
+  UpdateStatement,
+  WhereText,
+  Where,
+  DefaultStatementTextRenderer,
+} from "../index.ts";
+
+describe("statement compile", () => {
+  it("wraps query text and an optional where", () => {
+    const select = new SelectStatement({ table: "dual", fields: ["1"] });
+    const byId = new WhereText("id = 1");
+    const withWhere = new SelectStatement({ table: "dual", fields: ["1"], where: byId });
+    expect(DefaultStatementTextRenderer.instance.render(select)).toBe("SELECT 1 FROM dual");
+    expect(select.where).toBeUndefined();
+    expect(withWhere.where).toBe(byId);
+    expect(DefaultStatementTextRenderer.instance.render(byId)).toBe("id = 1");
+  });
+
+  it("compiles a select", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const query = new SelectStatement({ table: "users", fields: ["id", "name"], where });
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe(
+      "SELECT id, name FROM users WHERE id = $id AND age > $age",
+    );
+    expect(query.where).toBe(where);
+  });
+
+  it("joins tables", () => {
+    const query = new SelectStatement({
+      table: "users",
+      fields: ["users.id"],
+      where: new Where(new Operator.Equals("users.id", 1)),
+      joins: [
+        Join.inner("orders", "users.id", "orders.user_id"),
+        Join.left("payments", "orders.id", "payments.order_id"),
+        Join.right("profiles", "users.id", "profiles.user_id"),
+      ],
+    });
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe(
+      "SELECT users.id FROM users INNER JOIN orders ON users.id = orders.user_id LEFT JOIN payments ON orders.id = payments.order_id RIGHT JOIN profiles ON users.id = profiles.user_id WHERE users.id = $users.id",
+    );
+  });
+
+  it("groups aggregates orders and limits", () => {
+    const grouped = new SelectStatement({
+      table: "orders",
+      fields: ["status", Aggregate.count("*", "n"), Aggregate.sum("amount", "total")],
+      where: new Where(new Operator.Equals("status", "open")),
+      joins: [Join.inner("customers", "orders.customer_id", "customers.id")],
+      groupBy: ["status"],
+      orderBy: [OrderBy.desc("total"), OrderBy.asc("status")],
+      limit: 10,
+    });
+    expect(DefaultStatementTextRenderer.instance.render(grouped)).toBe(
+      "SELECT status, COUNT(*) AS n, SUM(amount) AS total FROM orders INNER JOIN customers ON orders.customer_id = customers.id WHERE status = $status GROUP BY status ORDER BY total DESC, status ASC LIMIT 10",
+    );
+  });
+
+  it("groups rows", () => {
+    const byStatus = new SelectStatement({ table: "users", fields: ["id"], groupBy: ["id"] });
+    expect(DefaultStatementTextRenderer.instance.render(byStatus)).toBe("SELECT id FROM users GROUP BY id");
+  });
+
+  it("aggregates without grouping", () => {
+    const bounds = new SelectStatement({ table: "users", fields: [Aggregate.min("n"), Aggregate.max("n")] });
+    expect(DefaultStatementTextRenderer.instance.render(bounds)).toBe("SELECT MIN(n), MAX(n) FROM users");
+  });
+
+  it("orders rows", () => {
+    const ordered = new SelectStatement({
+      table: "users",
+      fields: ["id"],
+      orderBy: [OrderBy.asc("id"), OrderBy.desc("name")],
+    });
+    expect(DefaultStatementTextRenderer.instance.render(ordered)).toBe(
+      "SELECT id FROM users ORDER BY id ASC, name DESC",
+    );
+  });
+
+  it("limits rows", () => {
+    const limited = new SelectStatement({ table: "users", fields: ["id"], limit: 10 });
+    expect(DefaultStatementTextRenderer.instance.render(limited)).toBe("SELECT id FROM users LIMIT 10");
+  });
+
+  it("compiles an insert", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const insert = new InsertStatement("users", fields);
+    expect(DefaultStatementTextRenderer.instance.render(insert)).toBe(
+      "INSERT INTO users (id, name) VALUES ($id, $name)",
+    );
+  });
+
+  it("compiles an update", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const update = new UpdateStatement("users", fields, where);
+    expect(DefaultStatementTextRenderer.instance.render(update)).toBe(
+      "UPDATE users SET id = $id, name = $name WHERE id = $id AND age > $age",
+    );
+    expect(update.where).toBe(where);
+  });
+
+  it("compiles a delete", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const del = new DeleteStatement("users", where);
+    expect(DefaultStatementTextRenderer.instance.render(del)).toBe(
+      "DELETE FROM users WHERE id = $id AND age > $age",
+    );
+    expect(del.where).toBe(where);
+  });
+
+  it("compiles a create table", () => {
+    const createTable = new CreateTableStatement("users", [
+      { name: "id", type: "INTEGER" },
+      { name: "name", type: "TEXT" },
+    ]);
+    expect(DefaultStatementTextRenderer.instance.render(createTable)).toBe(
+      "CREATE TABLE users (id INTEGER, name TEXT)",
+    );
+  });
+
+  it("compiles named constraints", () => {
+    const namedTable = new CreateTableStatement(
+      "orders",
+      [
+        { name: "id", type: "INTEGER", default: new ColumnDefault("0", "df_id"), notNull: new NotNull("nn_id") },
+        { name: "tenant_id", type: "INTEGER" },
+        { name: "user_id", type: "INTEGER" },
+        { name: "qty", type: "INTEGER" },
+      ],
+      [
+        new PrimaryKey("pk_orders", ["id", "tenant_id"]),
+        new ForeignKey("fk_orders_user", ["user_id"], "users", ["id"], ReferentialAction.Cascade),
+        new UniqueConstraint("uq_orders_user", ["user_id"]),
+        new CheckConstraint("chk_orders_qty", "qty > 0"),
+      ],
+    );
+    expect(DefaultStatementTextRenderer.instance.render(namedTable)).toBe(
+      "CREATE TABLE orders (id INTEGER CONSTRAINT df_id DEFAULT 0 CONSTRAINT nn_id NOT NULL, tenant_id INTEGER, user_id INTEGER, qty INTEGER, CONSTRAINT pk_orders PRIMARY KEY (id, tenant_id), CONSTRAINT fk_orders_user FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE, CONSTRAINT uq_orders_user UNIQUE (user_id), CONSTRAINT chk_orders_qty CHECK (qty > 0))",
+    );
+  });
+
+  it("compiles a create index", () => {
+    const createIndex = new CreateIndexStatement("idx_orders_user", "orders", ["user_id"]);
+    expect(DefaultStatementTextRenderer.instance.render(createIndex)).toBe(
+      "CREATE INDEX idx_orders_user ON orders (user_id)",
+    );
+  });
+
+  it("compiles a create unique index", () => {
+    const createIndex = new CreateIndexStatement("uq_orders_code", "orders", ["code"], true);
+    expect(DefaultStatementTextRenderer.instance.render(createIndex)).toBe(
+      "CREATE UNIQUE INDEX uq_orders_code ON orders (code)",
+    );
+  });
+
+  it("compiles a call", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const call = new ExecuteStoredProcedureStatement("save", fields);
+    expect(DefaultStatementTextRenderer.instance.render(call)).toBe("CALL save($id, $name)");
+  });
+
+  it("compiles a select function call", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const ret = new ReturnStatement("add", fields);
+    expect(DefaultStatementTextRenderer.instance.render(ret)).toBe("SELECT add($id, $name)");
+  });
+
+  it("renders compare groups not and in", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const inIds = new Where(new Operator.In("id", [1, 2]));
+    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("id = $id AND age > $age");
+    expect(DefaultStatementTextRenderer.instance.render(inIds)).toBe("id IN ($id_0, $id_1)");
+  });
+
+  it("compare tree", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("id = $id AND age > $age");
+  });
+
+  it("attaches where to a query", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const query = new SelectStatement({ table: "users", fields: ["id", "name"], where });
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe(
+      "SELECT id, name FROM users WHERE id = $id AND age > $age",
+    );
+  });
+});