kysely 0.27.1 → 0.27.3

package/dist/cjs/operation-node/select-query-node.js

@@ -86,6 +86,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             offset,
         });
     },
+    cloneWithFetch(selectNode, fetch) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            fetch,
+        });
+    },
     cloneWithHaving(selectNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,

package/dist/cjs/operation-node/top-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export type TopModifier = 'percent' | 'with ties' | 'percent with ties';
+export interface TopNode extends OperationNode {
+    readonly kind: 'TopNode';
+    readonly expression: number | bigint;
+    readonly modifiers?: TopModifier;
+}
+/**
+ * @internal
+ */
+export declare const TopNode: Readonly<{
+    is(node: OperationNode): node is TopNode;
+    create(expression: number | bigint, modifiers?: TopModifier): TopNode;
+}>;

package/dist/cjs/operation-node/top-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.TopNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'TopNode';
+    },
+    create(expression, modifiers) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'TopNode',
+            expression,
+            modifiers,
+        });
+    },
+});

package/dist/cjs/operation-node/update-query-node.d.ts

@@ -8,10 +8,12 @@ import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { FromNode } from './from-node.js';
 import { ExplainNode } from './explain-node.js';
+import { LimitNode } from './limit-node.js';
+import { TopNode } from './top-node.js';
 export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
-    readonly table: OperationNode;
+    readonly table?: OperationNode;
     readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
@@ -19,6 +21,8 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
     readonly explain?: ExplainNode;
+    readonly limit?: LimitNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -26,6 +30,8 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
+    createWithoutTable(): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
+    cloneWithLimit(updateQuery: UpdateQueryNode, limit: LimitNode): UpdateQueryNode;
 }>;

package/dist/cjs/operation-node/update-query-node.js

@@ -17,6 +17,11 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
             ...(withNode && { with: withNode }),
         });
     },
+    createWithoutTable() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UpdateQueryNode',
+        });
+    },
     cloneWithFromItems(updateQuery, fromItems) {
         return (0, object_utils_js_1.freeze)({
             ...updateQuery,
@@ -33,4 +38,10 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
                 : updates,
         });
     },
+    cloneWithLimit(updateQuery, limit) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            limit,
+        });
+    },
 });

package/dist/cjs/parser/binary-operation-parser.d.ts

@@ -18,4 +18,4 @@ export declare function parseValueBinaryOperationOrExpression(args: any[]): Oper
 export declare function parseValueBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseReferentialBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseFilterObject(obj: Readonly<FilterObject<any, any>>, combinator: 'and' | 'or'): OperationNode;
-export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or'): OperationNode;
+export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or', withParens?: boolean): OperationNode;

package/dist/cjs/parser/binary-operation-parser.js

@@ -38,7 +38,7 @@ function parseFilterObject(obj, combinator) {
         .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
 exports.parseFilterObject = parseFilterObject;
-function parseFilterList(list, combinator) {
+function parseFilterList(list, combinator, withParens = true) {
     const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
     if (list.length === 0) {
         return binary_operation_node_js_1.BinaryOperationNode.create(value_node_js_1.ValueNode.createImmediate(1), operator_node_js_1.OperatorNode.create('='), value_node_js_1.ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
@@ -47,7 +47,7 @@ function parseFilterList(list, combinator) {
     for (let i = 1; i < list.length; ++i) {
         node = combine(node, toOperationNode(list[i]));
     }
-    if (list.length > 1) {
+    if (list.length > 1 && withParens) {
         return parens_node_js_1.ParensNode.create(node);
     }
     return node;

package/dist/cjs/parser/data-type-parser.js

@@ -4,8 +4,12 @@ exports.parseDataTypeExpression = void 0;
 const data_type_node_js_1 = require("../operation-node/data-type-node.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 function parseDataTypeExpression(dataType) {
-    return (0, operation_node_source_js_1.isOperationNodeSource)(dataType)
-        ? dataType.toOperationNode()
-        : data_type_node_js_1.DataTypeNode.create(dataType);
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(dataType)) {
+        return dataType.toOperationNode();
+    }
+    if ((0, data_type_node_js_1.isColumnDataType)(dataType)) {
+        return data_type_node_js_1.DataTypeNode.create(dataType);
+    }
+    throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
 }
 exports.parseDataTypeExpression = parseDataTypeExpression;

package/dist/cjs/parser/fetch-parser.d.ts

@@ -0,0 +1,2 @@
+import { FetchModifier, FetchNode } from '../operation-node/fetch-node.js';
+export declare function parseFetch(rowCount: number | bigint, modifier: FetchModifier): FetchNode;

package/dist/cjs/parser/fetch-parser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFetch = void 0;
+const fetch_node_js_1 = require("../operation-node/fetch-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+function parseFetch(rowCount, modifier) {
+    if (!(0, object_utils_js_1.isNumber)(rowCount) && !(0, object_utils_js_1.isBigInt)(rowCount)) {
+        throw new Error(`Invalid fetch row count: ${rowCount}`);
+    }
+    if (!isFetchModifier(modifier)) {
+        throw new Error(`Invalid fetch modifier: ${modifier}`);
+    }
+    return fetch_node_js_1.FetchNode.create(rowCount, modifier);
+}
+exports.parseFetch = parseFetch;
+function isFetchModifier(value) {
+    return value === 'only' || value === 'with ties';
+}

package/dist/cjs/parser/insert-values-parser.d.ts

@@ -9,6 +9,6 @@ export type InsertObject<DB, TB extends keyof DB> = {
     [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
 };
 export type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export type InsertObjectOrListFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => InsertObjectOrList<DB, TB>;
-export type InsertExpression<DB, TB extends keyof DB> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB>;
-export declare function parseInsertExpression(arg: InsertExpression<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
+export type InsertObjectOrListFactory<DB, TB extends keyof DB, UT extends keyof DB = never> = (eb: ExpressionBuilder<DB, TB | UT>) => InsertObjectOrList<DB, TB>;
+export type InsertExpression<DB, TB extends keyof DB, UT extends keyof DB = never> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB, UT>;
+export declare function parseInsertExpression(arg: InsertExpression<any, any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

package/dist/cjs/parser/merge-parser.d.ts

@@ -0,0 +1,9 @@
+import { InsertQueryNode } from '../operation-node/insert-query-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+export declare function parseMergeWhen(type: {
+    isMatched: boolean;
+    bySource?: boolean;
+}, args?: any[], refRight?: boolean): WhenNode;
+export declare function parseMergeThen(result: 'delete' | 'do nothing' | OperationNodeSource | InsertQueryNode): OperationNode;

package/dist/cjs/parser/merge-parser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMergeThen = exports.parseMergeWhen = void 0;
+const matched_node_js_1 = require("../operation-node/matched-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const when_node_js_1 = require("../operation-node/when-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const binary_operation_parser_js_1 = require("./binary-operation-parser.js");
+function parseMergeWhen(type, args, refRight) {
+    return when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseFilterList)([
+        matched_node_js_1.MatchedNode.create(!type.isMatched, type.bySource),
+        ...(args && args.length > 0
+            ? [
+                args.length === 3 && refRight
+                    ? (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(args[0], args[1], args[2])
+                    : (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args),
+            ]
+            : []),
+    ], 'and', false));
+}
+exports.parseMergeWhen = parseMergeWhen;
+function parseMergeThen(result) {
+    if ((0, object_utils_js_1.isString)(result)) {
+        return raw_node_js_1.RawNode.create([result], []);
+    }
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(result)) {
+        return result.toOperationNode();
+    }
+    return result;
+}
+exports.parseMergeThen = parseMergeThen;

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

@@ -6,16 +6,17 @@ import { AliasedExpression } from '../expression/expression.js';
 import { DrainOuterGeneric, ShallowRecord } from '../util/type-utils.js';
 export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
 export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
-export type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export type TableReference<DB> = SimpleTableReference<DB> | AliasedExpression<any, any>;
+export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;
 export type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 export type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export type From<DB, TE> = DrainOuterGeneric<{
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 }>;
 export type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
-export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never;
+export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA extends keyof DB ? TA : never : TE extends keyof DB ? TE : never;
 export type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? ShallowRecord<A, DB[TB]> : never : never;
-type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? ExtractTableAlias<DB, TE> : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
+type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
 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 AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
 type AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];

package/dist/cjs/parser/top-parser.d.ts

@@ -0,0 +1,2 @@
+import { TopModifier, TopNode } from '../operation-node/top-node.js';
+export declare function parseTop(expression: number | bigint, modifiers?: TopModifier): TopNode;

package/dist/cjs/parser/top-parser.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTop = void 0;
+const top_node_js_1 = require("../operation-node/top-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+function parseTop(expression, modifiers) {
+    if (!(0, object_utils_js_1.isNumber)(expression) && !(0, object_utils_js_1.isBigInt)(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!(0, object_utils_js_1.isUndefined)(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return top_node_js_1.TopNode.create(expression, modifiers);
+}
+exports.parseTop = parseTop;
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}

package/dist/cjs/plugin/with-schema/with-schema-transformer.js

@@ -29,6 +29,7 @@ const ROOT_OPERATION_NODES = (0, object_utils_js_1.freeze)({
     RawNode: true,
     SelectQueryNode: true,
     UpdateQueryNode: true,
+    MergeQueryNode: true,
 });
 class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
     #schema;
@@ -103,6 +104,9 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
                 this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
             }
         }
+        if ('using' in node && node.using) {
+            this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
+        }
         return schemableIds;
     }
     #collectCTEs(node) {

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

@@ -399,6 +399,46 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     clearWhere(): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Changes a `delete from` query into a `delete top from` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Delete the first 5 rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(5)
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(5) from "person" where "age" > @1
+     * ```
+     *
+     * Delete the first 50% of rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(50, 'percent')
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(50) percent from "person" where "age" > @1
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: 'percent'): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `using` clause to the query.
      *
@@ -762,6 +802,65 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     returningAll<T extends TB>(table: T): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, T, O>>;
     returningAll(): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max"
+     * ```
+     */
+    clearReturning(): DeleteQueryBuilder<DB, TB, DeleteResult>;
+    /**
+     * Clears the `limit` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .limit(5)
+     *   .clearLimit()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearLimit(): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .orderBy('id')
+     *   .clearOrderBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearOrderBy(): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds an `order by` clause to the query.
      *

package/dist/cjs/query-builder/delete-query-builder.js

@@ -14,6 +14,7 @@ const limit_node_js_1 = require("../operation-node/limit-node.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -37,6 +38,51 @@ class DeleteQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithoutWhere(this.#props.queryNode),
         });
     }
+    /**
+     * Changes a `delete from` query into a `delete top from` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Delete the first 5 rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(5)
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(5) from "person" where "age" > @1
+     * ```
+     *
+     * Delete the first 50% of rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(50, 'percent')
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(50) percent from "person" where "age" > @1
+     * ```
+     */
+    top(expression, modifiers) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
     using(tables) {
         return new DeleteQueryBuilder({
             ...this.#props,
@@ -79,6 +125,80 @@ class DeleteQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
         });
     }
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max"
+     * ```
+     */
+    clearReturning() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithoutReturning(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears the `limit` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .limit(5)
+     *   .clearLimit()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearLimit() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithoutLimit(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .orderBy('id')
+     *   .clearOrderBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearOrderBy() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
+        });
+    }
     /**
      * Adds an `order by` clause to the query.
      *

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -1,7 +1,7 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
-import { InsertObjectOrList, InsertObjectOrListFactory } from '../parser/insert-values-parser.js';
+import { InsertExpression } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { NarrowPartial, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
@@ -184,8 +184,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * }))
      * ```
      */
-    values(insert: InsertObjectOrList<DB, TB>): InsertQueryBuilder<DB, TB, O>;
-    values(insert: InsertObjectOrListFactory<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    values(insert: InsertExpression<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Sets the columns to insert.
      *
@@ -242,6 +241,14 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     expression(expression: ExpressionOrFactory<DB, TB, any>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Creates an `insert into "person" default values` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .defaultValues()
+     *   .execute()
+     * ```
      */
     defaultValues(): InsertQueryBuilder<DB, TB, O>;
     /**
@@ -266,6 +273,50 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     ignore(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert top into` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Insert the first 5 rows:
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .top(5)
+     *   .columns(['first_name', 'gender'])
+     *   .expression(
+     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * insert top(5) into "person" ("first_name", "gender") select "name", 'other' as "gender" from "pet"
+     * ```
+     *
+     * Insert the first 50 percent of rows:
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .top(50, 'percent')
+     *   .columns(['first_name', 'gender'])
+     *   .expression(
+     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * insert top(50) percent into "person" ("first_name", "gender") select "name", 'other' as "gender" from "pet"
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: 'percent'): InsertQueryBuilder<DB, TB, O>;
     /**
      * Adds an `on conflict` clause to the query.
      *
@@ -504,6 +555,25 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * that support `returning` such as PostgreSQL.
      */
     returningAll(): InsertQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values({ first_name: 'James', last_name: 'Smith', age: 42 })
+     *   .returning(['first_name'])
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("James", "Smith", 42)
+     * ```
+     */
+    clearReturning(): InsertQueryBuilder<DB, TB, InsertResult>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.