add using clause support @ DeleteQueryBuilder.

src/index.ts

@@ -175,6 +175,7 @@ export * from './operation-node/partition-by-item-node.js'
 export * from './operation-node/set-operation-node.js'
 export * from './operation-node/binary-operation-node.js'
 export * from './operation-node/unary-operation-node.js'
+export * from './operation-node/using-node.js'
 
 export * from './util/column-type.js'
 export * from './util/compilable.js'

src/operation-node/delete-query-node.ts

@@ -9,10 +9,12 @@ import { LimitNode } from './limit-node.js'
 import { OrderByNode } from './order-by-node.js'
 import { OrderByItemNode } from './order-by-item-node.js'
 import { ExplainNode } from './explain-node.js'
+import { UsingNode } from './using-node.js'
 
 export interface DeleteQueryNode extends OperationNode {
   readonly kind: 'DeleteQueryNode'
   readonly from: FromNode
+  readonly using?: UsingNode
   readonly joins?: ReadonlyArray<JoinNode>
   readonly where?: WhereNode
   readonly returning?: ReturningNode
@@ -69,4 +71,17 @@ export const DeleteQueryNode = freeze({
       explain,
     })
   },
+
+  cloneWithUsing(
+    deleteNode: DeleteQueryNode,
+    tables: OperationNode[]
+  ): DeleteQueryNode {
+    return freeze({
+      ...deleteNode,
+      using:
+        deleteNode.using !== undefined
+          ? UsingNode.cloneWithTables(deleteNode.using, tables)
+          : UsingNode.create(tables),
+    })
+  },
 })

src/operation-node/operation-node-transformer.ts

@@ -78,6 +78,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js'
 import { SetOperationNode } from './set-operation-node.js'
 import { BinaryOperationNode } from './binary-operation-node.js'
 import { UnaryOperationNode } from './unary-operation-node.js'
+import { UsingNode } from './using-node.js'
 
 /**
  * Transforms an operation node tree into another one.
@@ -190,6 +191,7 @@ export class OperationNodeTransformer {
     SetOperationNode: this.transformSetOperation.bind(this),
     BinaryOperationNode: this.transformBinaryOperation.bind(this),
     UnaryOperationNode: this.transformUnaryOperation.bind(this),
+    UsingNode: this.transformUsing.bind(this),
   })
 
   transformNode<T extends OperationNode | undefined>(node: T): T {
@@ -364,6 +366,7 @@ export class OperationNodeTransformer {
     return requireAllProps<DeleteQueryNode>({
       kind: 'DeleteQueryNode',
       from: this.transformNode(node.from),
+      using: this.transformNode(node.using),
       joins: this.transformNodeList(node.joins),
       where: this.transformNode(node.where),
       returning: this.transformNode(node.returning),
@@ -877,6 +880,13 @@ export class OperationNodeTransformer {
     })
   }
 
+  protected transformUsing(node: UsingNode): UsingNode {
+    return requireAllProps<UsingNode>({
+      kind: 'UsingNode',
+      tables: node.tables,
+    })
+  }
+
   protected transformDataType(node: DataTypeNode): DataTypeNode {
     // An Object.freezed leaf node. No need to clone.
     return node

src/operation-node/operation-node-visitor.ts

@@ -80,6 +80,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js'
 import { SetOperationNode } from './set-operation-node.js'
 import { BinaryOperationNode } from './binary-operation-node.js'
 import { UnaryOperationNode } from './unary-operation-node.js'
+import { UsingNode } from './using-node.js'
 
 export abstract class OperationNodeVisitor {
   protected readonly nodeStack: OperationNode[] = []
@@ -167,6 +168,7 @@ export abstract class OperationNodeVisitor {
     SetOperationNode: this.visitSetOperation.bind(this),
     BinaryOperationNode: this.visitBinaryOperation.bind(this),
     UnaryOperationNode: this.visitUnaryOperation.bind(this),
+    UsingNode: this.visitUsing.bind(this),
   })
 
   protected readonly visitNode = (node: OperationNode): void => {
@@ -262,4 +264,5 @@ export abstract class OperationNodeVisitor {
   protected abstract visitSetOperation(node: SetOperationNode): void
   protected abstract visitBinaryOperation(node: BinaryOperationNode): void
   protected abstract visitUnaryOperation(node: UnaryOperationNode): void
+  protected abstract visitUsing(node: UsingNode): void
 }

src/operation-node/operation-node.ts

@@ -76,6 +76,7 @@ export type OperationNodeKind =
   | 'SetOperationNode'
   | 'BinaryOperationNode'
   | 'UnaryOperationNode'
+  | 'UsingNode'
 
 export interface OperationNode {
   readonly kind: OperationNodeKind

src/operation-node/using-node.ts

@@ -0,0 +1,33 @@
+import { freeze } from '../util/object-utils.js'
+import { OperationNode } from './operation-node.js'
+
+export interface UsingNode extends OperationNode {
+  readonly kind: 'UsingNode'
+  readonly tables: ReadonlyArray<OperationNode>
+}
+
+/**
+ * @internal
+ */
+export const UsingNode = freeze({
+  is(node: OperationNode): node is UsingNode {
+    return node.kind === 'UsingNode'
+  },
+
+  create(tables: ReadonlyArray<OperationNode>): UsingNode {
+    return freeze({
+      kind: 'UsingNode',
+      tables: freeze(tables),
+    })
+  },
+
+  cloneWithTables(
+    using: UsingNode,
+    tables: ReadonlyArray<OperationNode>
+  ): UsingNode {
+    return freeze({
+      ...using,
+      tables: freeze([...using.tables, ...tables]),
+    })
+  },
+})

src/query-builder/delete-query-builder.ts

@@ -5,7 +5,13 @@ import {
   JoinReferenceExpression,
   parseJoin,
 } from '../parser/join-parser.js'
-import { TableExpression } from '../parser/table-parser.js'
+import {
+  From,
+  FromTables,
+  parseTableExpressionOrList,
+  TableExpression,
+  TableExpressionOrList,
+} from '../parser/table-parser.js'
 import {
   parseSelectExpressionOrList,
   parseSelectAll,
@@ -180,6 +186,98 @@ export class DeleteQueryBuilder<DB, TB extends keyof DB, O>
     })
   }
 
+  /**
+   * Adds a `using` clause to the query.
+   *
+   * This clause allows adding additional tables to the query for filtering/returning
+   * only. Usually a non-standard syntactic-sugar alternative to a `where` with a sub-query.
+   *
+   * ### Examples:
+   *
+   * ```ts
+   * await db
+   *   .deleteFrom('pet')
+   *   .using('person')
+   *   .whereRef('pet.owner_id', '=', 'person.id')
+   *   .where('person.first_name', '=', 'Bob')
+   *   .executeTakeFirstOrThrow()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * delete from "pet"
+   * using "person"
+   * where "pet"."owner_id" = "person"."id"
+   *   and "person"."first_name" = $1
+   * ```
+   *
+   * On supported databases such as MySQL, this clause allows using joins, but requires
+   * at least one of the tables after the `from` keyword to be also named after
+   * the `using` keyword. See also {@link innerJoin}, {@link leftJoin}, {@link rightJoin}
+   * and {@link fullJoin}.
+   *
+   * ```ts
+   * await db
+   *   .deleteFrom('pet')
+   *   .using('pet')
+   *   .leftJoin('person', 'person.id', 'pet.owner_id')
+   *   .where('person.first_name', '=', 'Bob')
+   *   .executeTakeFirstOrThrow()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * delete from `pet`
+   * using `pet`
+   * left join `person` on `person`.`id` = `pet`.`owner_id`
+   * where `person`.`first_name` = ?
+   * ```
+   *
+   * You can also chain multiple invocations of this method, or pass an array to
+   * a single invocation to name multiple tables.
+   *
+   * ```ts
+   * await db
+   *   .deleteFrom('toy')
+   *   .using(['pet', 'person'])
+   *   .whereRef('toy.pet_id', '=', 'pet.id')
+   *   .whereRef('pet.owner_id', '=', 'person.id')
+   *   .where('person.first_name', '=', 'Bob')
+   *   .returning('pet.name')
+   *   .executeTakeFirstOrThrow()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * delete from "toy"
+   * using "pet", "person"
+   * where "toy"."pet_id" = "pet"."id"
+   *   and "pet"."owner_id" = "person"."id"
+   *   and "person"."first_name" = $1
+   * returning "pet"."name"
+   * ```
+   */
+  using<TE extends TableExpression<DB, keyof DB>>(
+    tables: TE[]
+  ): DeleteQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, O>
+
+  using<TE extends TableExpression<DB, keyof DB>>(
+    table: TE
+  ): DeleteQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, O>
+
+  using(tables: TableExpressionOrList<any, any>): any {
+    return new DeleteQueryBuilder({
+      ...this.#props,
+      queryNode: DeleteQueryNode.cloneWithUsing(
+        this.#props.queryNode,
+        parseTableExpressionOrList(tables)
+      ),
+    })
+  }
+
   /**
    * Joins another table to the query using an inner join.
    *

src/query-compiler/default-query-compiler.ts

@@ -93,6 +93,7 @@ import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js
 import { SetOperationNode } from '../operation-node/set-operation-node.js'
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js'
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js'
+import { UsingNode } from '../operation-node/using-node.js'
 
 export class DefaultQueryCompiler
   extends OperationNodeVisitor
@@ -338,6 +339,11 @@ export class DefaultQueryCompiler
     this.append('delete ')
     this.visitNode(node.from)
 
+    if (node.using) {
+      this.append(' ')
+      this.visitNode(node.using)
+    }
+
     if (node.joins) {
       this.append(' ')
       this.compileList(node.joins, ' ')
@@ -1258,6 +1264,11 @@ export class DefaultQueryCompiler
     this.visitNode(node.operand)
   }
 
+  protected override visitUsing(node: UsingNode): void {
+    this.append('using ')
+    this.compileList(node.tables)
+  }
+
   protected append(str: string): void {
     this.#sql += str
   }