feat: orWhere, Col.cast, TRUNCATE TABLE

productdevbook · claude · productdevbook · commit 5e7a20df59ca · 2026-04-04T17:53:35.000+03:00
- orWhere() on Select/Update/Delete for OR conditions with existing WHERE
- Col.cast&lt;R&gt;(dataType) inline CAST shorthand
- TRUNCATE TABLE DDL with CASCADE and RESTART IDENTITY
- orWhere on all untyped builders too (UpdateBuilder, DeleteBuilder)

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/AGENTS.md b/AGENTS.md
@@ -185,4 +185,4 @@ pnpm release        # pnpm test && pnpm build && bumpp && npm publish && git pus
 - **No code without tests** — PR must include tests for all new/changed code
 - Run all: `pnpm test`
 - Run single: `pnpm vitest run test/<path>.test.ts`
-- **Current:** 80 test files, 691 tests, 0 lint errors, 0 tsgo errors
+- **Current:** 81 test files, 699 tests, 0 lint errors, 0 tsgo errors
diff --git a/src/ast/ddl-nodes.ts b/src/ast/ddl-nodes.ts
@@ -157,6 +157,15 @@ export interface DropViewNode {
   materialized?: boolean
 }
 
+// ── TRUNCATE TABLE ──
+
+export interface TruncateTableNode {
+  type: "truncate_table"
+  table: TableRefNode
+  cascade?: boolean
+  restartIdentity?: boolean
+}
+
 // ── Union of all DDL nodes ──
 
 export type DDLNode =
@@ -167,3 +176,4 @@ export type DDLNode =
   | DropIndexNode
   | CreateViewNode
   | DropViewNode
+  | TruncateTableNode
diff --git a/src/builder/ddl/drop.ts b/src/builder/ddl/drop.ts
@@ -1,4 +1,9 @@
-import type { DropIndexNode, DropTableNode, DropViewNode } from "../../ast/ddl-nodes.ts"
+import type {
+  DropIndexNode,
+  DropTableNode,
+  DropViewNode,
+  TruncateTableNode,
+} from "../../ast/ddl-nodes.ts"
 import type { TableRefNode } from "../../ast/nodes.ts"
 
 // ── DROP TABLE ──
@@ -91,6 +96,34 @@ export class DropViewBuilder {
   }
 }
 
+// ── TRUNCATE TABLE ──
+
+export class TruncateTableBuilder {
+  private readonly node: TruncateTableNode
+
+  constructor(table: string, schema?: string) {
+    const ref: TableRefNode = { type: "table_ref", name: table, schema }
+    this.node = { type: "truncate_table", table: ref }
+  }
+
+  private clone(patch: Partial<TruncateTableNode>): TruncateTableBuilder {
+    const next = new TruncateTableBuilder(this.node.table.name, this.node.table.schema)
+    return Object.assign(next, { node: { ...this.node, ...patch } }) as TruncateTableBuilder
+  }
+
+  cascade(): TruncateTableBuilder {
+    return this.clone({ cascade: true })
+  }
+
+  restartIdentity(): TruncateTableBuilder {
+    return this.clone({ restartIdentity: true })
+  }
+
+  build(): TruncateTableNode {
+    return { ...this.node }
+  }
+}
+
 // ── Factory functions ──
 
 export function dropTable(table: string, schema?: string): DropTableBuilder {
diff --git a/src/builder/delete.ts b/src/builder/delete.ts
@@ -31,6 +31,16 @@ export class DeleteBuilder {
     return new DeleteBuilder({ ...this.node, where: expr })
   }
 
+  orWhere(expr: ExpressionNode): DeleteBuilder {
+    if (this.node.where) {
+      return new DeleteBuilder({
+        ...this.node,
+        where: { type: "binary_op", op: "OR", left: this.node.where, right: expr },
+      })
+    }
+    return new DeleteBuilder({ ...this.node, where: expr })
+  }
+
   /** USING clause (PG: DELETE FROM t USING other WHERE ...) */
   using(table: string | TableRefNode): DeleteBuilder {
     const ref: TableRefNode = typeof table === "string" ? { type: "table_ref", name: table } : table
diff --git a/src/builder/eb.ts b/src/builder/eb.ts
@@ -254,6 +254,11 @@ export class Col<T> {
     return wrap<T>(this._node)
   }
 
+  /** CAST(col AS dataType) inline */
+  cast<R>(dataType: string): Expression<R> {
+    return wrap<R>(rawCast(this._node, dataType))
+  }
+
   /** ASC ordering — for use with orderBy(col.asc()) */
   asc(): { expr: Expression<T>; direction: "ASC" } {
     return { expr: wrap<T>(this._node), direction: "ASC" }
diff --git a/src/builder/select.ts b/src/builder/select.ts
@@ -58,6 +58,16 @@ export class SelectBuilder {
     return new SelectBuilder({ ...this.node, where: expr })
   }
 
+  orWhere(expr: ExpressionNode): SelectBuilder {
+    if (this.node.where) {
+      return new SelectBuilder({
+        ...this.node,
+        where: { type: "binary_op", op: "OR", left: this.node.where, right: expr },
+      })
+    }
+    return new SelectBuilder({ ...this.node, where: expr })
+  }
+
   join(
     type: JoinType,
     table: string | TableRefNode,
diff --git a/src/builder/typed-select.ts b/src/builder/typed-select.ts
@@ -98,6 +98,21 @@ export class TypedSelectBuilder<DB, TB extends keyof DB, O> {
     return new TypedSelectBuilder(this._builder.where(unwrap(exprOrCallback)), this._table)
   }
 
+  /**
+   * OR WHERE — ORs with existing WHERE clause instead of AND.
+   */
+  orWhere(
+    exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>,
+  ): TypedSelectBuilder<DB, TB, O> {
+    if (typeof exprOrCallback === "function") {
+      resetParams()
+      const cols = createColumnProxies<DB, TB>(this._table)
+      const result = exprOrCallback(cols)
+      return new TypedSelectBuilder(this._builder.orWhere(unwrap(result)), this._table)
+    }
+    return new TypedSelectBuilder(this._builder.orWhere(unwrap(exprOrCallback)), this._table)
+  }
+
   /**
    * INNER JOIN.
    *
diff --git a/src/builder/update.ts b/src/builder/update.ts
@@ -38,6 +38,16 @@ export class UpdateBuilder {
     return new UpdateBuilder({ ...this.node, where: expr })
   }
 
+  orWhere(expr: ExpressionNode): UpdateBuilder {
+    if (this.node.where) {
+      return new UpdateBuilder({
+        ...this.node,
+        where: { type: "binary_op", op: "OR", left: this.node.where, right: expr },
+      })
+    }
+    return new UpdateBuilder({ ...this.node, where: expr })
+  }
+
   from(table: string | TableRefNode): UpdateBuilder {
     const ref: TableRefNode = typeof table === "string" ? { type: "table_ref", name: table } : table
     return new UpdateBuilder({ ...this.node, from: ref })
diff --git a/src/index.ts b/src/index.ts
@@ -281,7 +281,12 @@ export {
 export { AlterTableBuilder } from "./builder/ddl/alter-table.ts"
 export { CreateIndexBuilder } from "./builder/ddl/create-index.ts"
 export { CreateViewBuilder } from "./builder/ddl/create-view.ts"
-export { DropTableBuilder, DropIndexBuilder, DropViewBuilder } from "./builder/ddl/drop.ts"
+export {
+  DropTableBuilder,
+  DropIndexBuilder,
+  DropViewBuilder,
+  TruncateTableBuilder,
+} from "./builder/ddl/drop.ts"
 export { DDLPrinter } from "./printer/ddl.ts"
 export { SchemaBuilder } from "./sumak.ts"
 
@@ -303,6 +308,7 @@ export type {
   ForeignKeyConstraintNode,
   PrimaryKeyConstraintNode,
   TableConstraintNode,
+  TruncateTableNode,
   UniqueConstraintNode,
 } from "./ast/ddl-nodes.ts"
 
diff --git a/src/printer/ddl.ts b/src/printer/ddl.ts
@@ -10,6 +10,7 @@ import type {
   DropViewNode,
   ForeignKeyConstraintNode,
   TableConstraintNode,
+  TruncateTableNode,
 } from "../ast/ddl-nodes.ts"
 import type { CompiledQuery, SQLDialect } from "../types.ts"
 import { quoteIdentifier, quoteTableRef } from "../utils/identifier.ts"
@@ -44,6 +45,8 @@ export class DDLPrinter {
         return this.printCreateView(node)
       case "drop_view":
         return this.printDropView(node)
+      case "truncate_table":
+        return this.printTruncateTable(node)
     }
   }
 
@@ -253,6 +256,14 @@ export class DDLPrinter {
     return parts.join(" ")
   }
 
+  private printTruncateTable(node: TruncateTableNode): string {
+    const parts: string[] = ["TRUNCATE TABLE"]
+    parts.push(quoteTableRef(node.table.name, this.dialect, node.table.schema))
+    if (node.restartIdentity) parts.push("RESTART IDENTITY")
+    if (node.cascade) parts.push("CASCADE")
+    return parts.join(" ")
+  }
+
   private printExpr(node: import("../ast/nodes.ts").ExpressionNode): string {
     // Simplified expression printing for DDL contexts
     switch (node.type) {
diff --git a/src/sumak.ts b/src/sumak.ts
@@ -4,7 +4,12 @@ import { AlterTableBuilder } from "./builder/ddl/alter-table.ts"
 import { CreateIndexBuilder } from "./builder/ddl/create-index.ts"
 import { CreateTableBuilder } from "./builder/ddl/create-table.ts"
 import { CreateViewBuilder } from "./builder/ddl/create-view.ts"
-import { DropIndexBuilder, DropTableBuilder, DropViewBuilder } from "./builder/ddl/drop.ts"
+import {
+  DropIndexBuilder,
+  DropTableBuilder,
+  DropViewBuilder,
+  TruncateTableBuilder,
+} from "./builder/ddl/drop.ts"
 import { Col } from "./builder/eb.ts"
 import { SelectBuilder } from "./builder/select.ts"
 import { TypedDeleteBuilder } from "./builder/typed-delete.ts"
@@ -362,4 +367,8 @@ export class SchemaBuilder {
   dropView(name: string): DropViewBuilder {
     return new DropViewBuilder(name)
   }
+
+  truncateTable(table: string, schema?: string): TruncateTableBuilder {
+    return new TruncateTableBuilder(table, schema)
+  }
 }
diff --git a/test/builder/convenience.test.ts b/test/builder/convenience.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest"
+
+import { Col, count, val } from "../../src/builder/eb.ts"
+import { pgDialect } from "../../src/dialect/pg.ts"
+import { integer, serial, text } from "../../src/schema/column.ts"
+import { sumak } from "../../src/sumak.ts"
+
+const db = sumak({
+  dialect: pgDialect(),
+  tables: {
+    users: {
+      id: serial().primaryKey(),
+      name: text().notNull(),
+      email: text().notNull(),
+      age: integer(),
+    },
+  },
+})
+
+const p = db.printer()
+
+describe("orWhere()", () => {
+  it("first orWhere acts as regular where", () => {
+    const q = db
+      .selectFrom("users")
+      .select("id")
+      .orWhere(({ name }) => name.eq("Alice"))
+      .compile(p)
+    expect(q.sql).toContain("WHERE")
+    expect(q.sql).not.toContain("OR")
+  })
+
+  it("orWhere after where produces OR", () => {
+    const q = db
+      .selectFrom("users")
+      .select("id")
+      .where(({ name }) => name.eq("Alice"))
+      .orWhere(({ name }) => name.eq("Bob"))
+      .compile(p)
+    expect(q.sql).toContain("OR")
+  })
+
+  it("mixed where + orWhere + where", () => {
+    const q = db
+      .selectFrom("users")
+      .select("id")
+      .where(({ name }) => name.eq("Alice"))
+      .orWhere(({ name }) => name.eq("Bob"))
+      .where(({ age }) => age.gt(18))
+      .compile(p)
+    // (name = Alice OR name = Bob) AND age > 18
+    expect(q.sql).toContain("OR")
+    expect(q.sql).toContain("AND")
+  })
+})
+
+describe("Col.cast()", () => {
+  it("inline CAST on column", () => {
+    const col = new Col<number>("age")
+    const q = db.selectFrom("users").selectExpr(col.cast<string>("text"), "ageText").compile(p)
+    expect(q.sql).toContain("CAST(")
+    expect(q.sql).toContain("AS text")
+  })
+})
+
+describe("TRUNCATE TABLE", () => {
+  it("basic TRUNCATE", () => {
+    const node = db.schema.truncateTable("users").build()
+    const q = db.compileDDL(node)
+    expect(q.sql).toContain("TRUNCATE TABLE")
+    expect(q.sql).toContain('"users"')
+  })
+
+  it("TRUNCATE with CASCADE", () => {
+    const node = db.schema.truncateTable("users").cascade().build()
+    const q = db.compileDDL(node)
+    expect(q.sql).toContain("CASCADE")
+  })
+
+  it("TRUNCATE with RESTART IDENTITY", () => {
+    const node = db.schema.truncateTable("users").restartIdentity().build()
+    const q = db.compileDDL(node)
+    expect(q.sql).toContain("RESTART IDENTITY")
+  })
+
+  it("TRUNCATE with RESTART IDENTITY CASCADE", () => {
+    const node = db.schema.truncateTable("users").restartIdentity().cascade().build()
+    const q = db.compileDDL(node)
+    expect(q.sql).toContain("RESTART IDENTITY")
+    expect(q.sql).toContain("CASCADE")
+  })
+})
