kysely 0.16.9 → 0.17.1

package/dist/esm/parser/parse-utils.js

@@ -0,0 +1,32 @@
+/// <reference types="./parse-utils.d.ts" />
+import { JoinNode } from '../operation-node/join-node.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { ExpressionBuilder } from '../query-builder/expression-builder.js';
+import { JoinBuilder } from '../query-builder/join-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { QueryCreator } from '../query-creator.js';
+import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+import { createQueryId } from '../util/query-id.js';
+import { parseTableExpression, parseTableExpressionOrList, } from './table-parser.js';
+export function createSelectQueryBuilder() {
+    return new SelectQueryBuilder({
+        queryId: createQueryId(),
+        executor: NOOP_QUERY_EXECUTOR,
+        queryNode: SelectQueryNode.create(parseTableExpressionOrList([])),
+    });
+}
+export function createExpressionBuilder() {
+    return new ExpressionBuilder({
+        executor: NOOP_QUERY_EXECUTOR,
+    });
+}
+export function createQueryCreator() {
+    return new QueryCreator({
+        executor: NOOP_QUERY_EXECUTOR,
+    });
+}
+export function createJoinBuilder(joinType, table) {
+    return new JoinBuilder({
+        joinNode: JoinNode.create(joinType, parseTableExpression(table)),
+    });
+}

package/dist/esm/parser/reference-parser.d.ts

@@ -5,7 +5,6 @@ import { ReferenceNode } from '../operation-node/reference-node.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { ParseContext } from './parse-context.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
@@ -14,8 +13,8 @@ export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = Referen
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
 export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : unknown;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : unknown;
-export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
-export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
+export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
+export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;
 export declare function parseAliasedStringReference(ref: string): ColumnNode | ReferenceNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;

package/dist/esm/parser/reference-parser.js

@@ -6,22 +6,22 @@ import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseComplexExpression, } from './complex-expression-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
-export function parseReferenceExpressionOrList(ctx, arg) {
+export function parseReferenceExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
-        return arg.map((it) => parseReferenceExpression(ctx, it));
+        return arg.map((it) => parseReferenceExpression(it));
     }
     else {
-        return [parseReferenceExpression(ctx, arg)];
+        return [parseReferenceExpression(arg)];
     }
 }
-export function parseReferenceExpression(ctx, exp) {
+export function parseReferenceExpression(exp) {
     if (isString(exp)) {
         return parseStringReference(exp);
     }
     else if (isDynamicReferenceBuilder(exp)) {
         return exp.toOperationNode();
     }
-    return parseComplexExpression(ctx, exp);
+    return parseComplexExpression(exp);
 }
 export function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';

package/dist/esm/parser/select-parser.d.ts

@@ -3,7 +3,6 @@ import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
 export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
@@ -29,6 +28,6 @@ declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
         [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
     }[TB];
 }>;
-export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
+export declare function parseSelectExpressionOrList(selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

package/dist/esm/parser/select-parser.js

@@ -4,15 +4,15 @@ import { SelectionNode } from '../operation-node/selection-node.js';
 import { parseAliasedStringReference } from './reference-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
 import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
-export function parseSelectExpressionOrList(ctx, selection) {
+export function parseSelectExpressionOrList(selection) {
     if (isReadonlyArray(selection)) {
-        return selection.map((it) => parseSelectExpression(ctx, it));
+        return selection.map((it) => parseSelectExpression(it));
     }
     else {
-        return [parseSelectExpression(ctx, selection)];
+        return [parseSelectExpression(selection)];
     }
 }
-function parseSelectExpression(ctx, selection) {
+function parseSelectExpression(selection) {
     if (isString(selection)) {
         return SelectionNode.create(parseAliasedStringReference(selection));
     }
@@ -20,7 +20,7 @@ function parseSelectExpression(ctx, selection) {
         return SelectionNode.create(selection.toOperationNode());
     }
     else {
-        return SelectionNode.create(parseAliasedComplexExpression(ctx, selection));
+        return SelectionNode.create(parseAliasedComplexExpression(selection));
     }
 }
 export function parseSelectAll(table) {

package/dist/esm/parser/table-parser.d.ts

@@ -3,7 +3,6 @@ import { TableNode } from '../operation-node/table-node.js';
 import { AnyAliasedRawBuilder, Nullable } from '../util/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
@@ -25,8 +24,8 @@ export declare type TableExpressionTables<DB, TB extends keyof DB, TE> = TB | Ex
 declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
 declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
-export declare function parseTableExpressionOrList(ctx: ParseContext, table: TableExpressionOrList<any, any>): TableExpressionNode[];
-export declare function parseTableExpression(ctx: ParseContext, table: TableExpression<any, any>): TableExpressionNode;
+export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): TableExpressionNode[];
+export declare function parseTableExpression(table: TableExpression<any, any>): TableExpressionNode;
 export declare function parseAliasedTable(from: string): TableExpressionNode;
 export declare function parseTable(from: string): TableNode;
 export {};

package/dist/esm/parser/table-parser.js

@@ -3,20 +3,20 @@ import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
 import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
-export function parseTableExpressionOrList(ctx, table) {
+export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
-        return table.map((it) => parseTableExpression(ctx, it));
+        return table.map((it) => parseTableExpression(it));
     }
     else {
-        return [parseTableExpression(ctx, table)];
+        return [parseTableExpression(table)];
     }
 }
-export function parseTableExpression(ctx, table) {
+export function parseTableExpression(table) {
     if (isString(table)) {
         return parseAliasedTable(table);
     }
     else {
-        return parseAliasedComplexExpression(ctx, table);
+        return parseAliasedComplexExpression(table);
     }
 }
 export function parseAliasedTable(from) {

package/dist/esm/parser/update-set-parser.d.ts

@@ -1,8 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
-import { ParseContext } from './parse-context.js';
 import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
     [C in UpdateKeys<DB[TB]>]?: ValueExpression<DB, TB, UpdateType<DB[TB][C]>>;
 };
-export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObject(row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/update-set-parser.js

@@ -2,10 +2,10 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { parseValueExpression } from './value-parser.js';
-export function parseUpdateObject(ctx, row) {
+export function parseUpdateObject(row) {
     return Object.entries(row)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {
-        return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(ctx, value));
+        return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(value));
     });
 }

package/dist/esm/parser/value-parser.d.ts

@@ -1,10 +1,9 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { ParseContext } from './parse-context.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { ComplexExpression } from './complex-expression-parser.js';
-export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB>;
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;

package/dist/esm/parser/value-parser.js

@@ -4,23 +4,23 @@ import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
 import { isReadonlyArray } from '../util/object-utils.js';
 import { parseComplexExpression, isComplexExpression, } from './complex-expression-parser.js';
-export function parseValueExpressionOrList(ctx, arg) {
+export function parseValueExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
-        return parseValueExpressionList(ctx, arg);
+        return parseValueExpressionList(arg);
     }
     else {
-        return parseValueExpression(ctx, arg);
+        return parseValueExpression(arg);
     }
 }
-export function parseValueExpression(ctx, exp) {
+export function parseValueExpression(exp) {
     if (isComplexExpression(exp)) {
-        return parseComplexExpression(ctx, exp);
+        return parseComplexExpression(exp);
     }
     return ValueNode.create(exp);
 }
-function parseValueExpressionList(ctx, arg) {
+function parseValueExpressionList(arg) {
     if (arg.some(isComplexExpression)) {
-        return ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
+        return ValueListNode.create(arg.map((it) => parseValueExpression(it)));
     }
     return PrimitiveValueListNode.create(arg);
 }

package/dist/esm/parser/with-parser.d.ts

@@ -5,7 +5,6 @@ import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { ParseContext } from './parse-context.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
@@ -37,5 +36,5 @@ declare type ExtractRowFromCommonTableExpressionName<CN extends string> = CN ext
  * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
  */
 declare type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
-export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
+export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
 export {};

package/dist/esm/parser/with-parser.js

@@ -1,8 +1,9 @@
 /// <reference types="./with-parser.d.ts" />
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
-export function parseCommonTableExpression(ctx, name, expression) {
-    const builder = expression(ctx.createQueryCreator());
+import { createQueryCreator } from './parse-utils.js';
+export function parseCommonTableExpression(name, expression) {
+    const builder = expression(createQueryCreator());
     return CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
 }
 function parseCommonTableExpressionName(name) {

package/dist/esm/query-builder/delete-query-builder.d.ts

@@ -10,7 +10,6 @@ import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-util
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
-import { ParseContext } from '../parser/parse-context.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { JoinInterface } from './join-interface.js';
@@ -19,6 +18,7 @@ import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { Selectable } from '../util/column-type.js';
+import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -46,7 +46,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `db.raw('your operator')`.
+     * you can always use `sql\`your operator\``.
      *
      * ```ts
      * const persons = await db
@@ -116,7 +116,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * A `where in` query can be built by using the `in` operator and an array
      * of values. The values in the array can also be subqueries or raw
-     * instances.
+     * {@link sql} expressions.
      *
      * ```ts
      * const persons = await db
@@ -132,15 +132,17 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always pass {@link Kysely.raw | raw}
+     * If everything else fails, you can always use the {@link sql} tag
      * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     db.raw('coalesce(first_name, last_name)'),
+     *     sql`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -175,24 +177,25 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * In all examples above the columns were known at compile time
-     * (except for the `raw` expressions). By default kysely only allows
-     * you to refer to columns that exist in the database **and** can be
-     * referred to in the current query and context.
+     * (except for the raw {@link sql} expressions). By default kysely only
+     * allows you to refer to columns that exist in the database **and**
+     * can be referred to in the current query and context.
      *
      * Sometimes you may want to refer to columns that come from the user
      * input and thus are not available at compile time.
      *
-     * You have two options, `db.raw` or `db.dynamic`. The example below
+     * You have two options, the {@link sql} tag or `db.dynamic`. The example below
      * uses both:
      *
      * ```ts
+     * import { sql } from 'kysely'
      * const { ref } = db.dynamic
      *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(db.raw('??', [columnFromUserInput]), '=', 2)
+     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
@@ -326,13 +329,14 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Adds a `where exists` clause to the query.
      *
-     * You can either use a subquery or a raw instance.
+     * You can either use a subquery or a raw {@link sql} snippet.
      *
      * ### Examples
      *
      * The query below selets all persons that own a pet named Catto:
      *
      * ```ts
+     * const petName = 'Catto'
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
@@ -340,7 +344,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .selectFrom('pet')
      *     .select('pet.id')
      *     .whereRef('person.id', '=', 'pet.owner_id')
-     *     .where('pet.name', '=', 'Catto')
+     *     .where('pet.name', '=', petName)
      *   )
      *   .execute()
      * ```
@@ -357,16 +361,16 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * )
      * ```
      *
-     * The same query as in the previous example but with using raw:
+     * The same query as in the previous example but with using raw {@link sql}:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const petName = 'Catto'
      * db.selectFrom('person')
      *   .selectAll()
      *   .whereExists(
-     *     db.raw(
-     *       '(select pet.id from pet where person.id = pet.owner_id and pet.name = ?)',
-     *       ['Catto']
-     *     )
+     *     sql`(select pet.id from pet where person.id = pet.owner_id and pet.name = ${petName})`
      *   )
      * ```
      *
@@ -564,7 +568,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Return arbitrary expressions:
      *
      * ```ts
-     * const { raw } = db
+     * import { sql } from 'kysely'
      *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
@@ -574,7 +578,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   })
      *   .returning([
      *     'id as id',
-     *     raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
      *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()
@@ -587,6 +591,60 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * that support `returning` such as PostgreSQL.
      */
     returningAll(): DeleteQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    /**
+     * Adds an `order by` clause to the query.
+     *
+     * `orderBy` calls are additive. To order by multiple columns, call `orderBy`
+     * multiple times.
+     *
+     * The first argument is the expression to order by and the second is the
+     * order (`asc` or `desc`).
+     *
+     * An `order by` clause in a delete query is only supported by some dialects
+     * like MySQL.
+     *
+     * See {@link SelectQueryBuilder.orderBy} for more examples.
+     *
+     * ### Examples
+     *
+     * Delete 5 oldest items in a table:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .orderBy('created_at')
+     *   .limit(5)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `pet`
+     * order by `created_at`
+     * limit ?
+     * ```
+     */
+    orderBy(orderBy: OrderByExpression<DB, TB, O>, direction?: OrderByDirectionExpression): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a limit clause to the query.
+     *
+     * A limit clause in a delete query is only supported by some dialects
+     * like MySQL.
+     *
+     * ### Examples
+     *
+     * Delete 5 oldest items in a table:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .orderBy('created_at')
+     *   .limit(5)
+     *   .execute()
+     * ```
+     */
+    limit(limit: number): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -683,5 +741,4 @@ export interface DeleteQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: DeleteQueryNode;
     readonly executor: QueryExecutor;
-    readonly parseContext: ParseContext;
 }