kysely 0.27.1 → 0.27.3

package/dist/esm/operation-node/operation-node-transformer.js

@@ -119,7 +119,12 @@ export class OperationNodeTransformer {
         JSONPathLegNode: this.transformJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
         TupleNode: this.transformTuple.bind(this),
+        MergeQueryNode: this.transformMergeQuery.bind(this),
+        MatchedNode: this.transformMatched.bind(this),
         AddIndexNode: this.transformAddIndex.bind(this),
+        CastNode: this.transformCast.bind(this),
+        FetchNode: this.transformFetch.bind(this),
+        TopNode: this.transformTop.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -157,6 +162,8 @@ export class OperationNodeTransformer {
             having: this.transformNode(node.having),
             explain: this.transformNode(node.explain),
             setOperations: this.transformNodeList(node.setOperations),
+            fetch: this.transformNode(node.fetch),
+            top: this.transformNode(node.top),
         });
     }
     transformSelection(node) {
@@ -258,6 +265,7 @@ export class OperationNodeTransformer {
             replace: node.replace,
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
+            top: this.transformNode(node.top),
         });
     }
     transformValues(node) {
@@ -278,6 +286,7 @@ export class OperationNodeTransformer {
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
             explain: this.transformNode(node.explain),
+            top: this.transformNode(node.top),
         });
     }
     transformReturning(node) {
@@ -317,6 +326,7 @@ export class OperationNodeTransformer {
             frontModifiers: this.transformNodeList(node.frontModifiers),
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
+            identity: node.identity,
         });
     }
     transformAddColumn(node) {
@@ -369,6 +379,8 @@ export class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
             explain: this.transformNode(node.explain),
+            limit: this.transformNode(node.limit),
+            top: this.transformNode(node.top),
         });
     }
     transformColumnUpdate(node) {
@@ -772,6 +784,23 @@ export class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
         });
     }
+    transformMergeQuery(node) {
+        return requireAllProps({
+            kind: 'MergeQueryNode',
+            into: this.transformNode(node.into),
+            using: this.transformNode(node.using),
+            whens: this.transformNodeList(node.whens),
+            with: this.transformNode(node.with),
+            top: this.transformNode(node.top),
+        });
+    }
+    transformMatched(node) {
+        return requireAllProps({
+            kind: 'MatchedNode',
+            not: node.not,
+            bySource: node.bySource,
+        });
+    }
     transformAddIndex(node) {
         return requireAllProps({
             kind: 'AddIndexNode',
@@ -782,6 +811,27 @@ export class OperationNodeTransformer {
             ifNotExists: node.ifNotExists,
         });
     }
+    transformCast(node) {
+        return requireAllProps({
+            kind: 'CastNode',
+            expression: this.transformNode(node.expression),
+            dataType: this.transformNode(node.dataType),
+        });
+    }
+    transformFetch(node) {
+        return requireAllProps({
+            kind: 'FetchNode',
+            rowCount: this.transformNode(node.rowCount),
+            modifier: node.modifier,
+        });
+    }
+    transformTop(node) {
+        return requireAllProps({
+            kind: 'TopNode',
+            expression: node.expression,
+            modifiers: node.modifiers,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -85,7 +85,12 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { MatchedNode } from './matched-node.js';
 import { AddIndexNode } from './add-index-node.js';
+import { CastNode } from './cast-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -177,5 +182,10 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
     protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
     protected abstract visitTuple(node: TupleNode): void;
+    protected abstract visitMergeQuery(node: MergeQueryNode): void;
+    protected abstract visitMatched(node: MatchedNode): void;
     protected abstract visitAddIndex(node: AddIndexNode): void;
+    protected abstract visitCast(node: CastNode): void;
+    protected abstract visitFetch(node: FetchNode): void;
+    protected abstract visitTop(node: TopNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -92,7 +92,12 @@ export class OperationNodeVisitor {
         JSONPathLegNode: this.visitJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
         TupleNode: this.visitTuple.bind(this),
+        MergeQueryNode: this.visitMergeQuery.bind(this),
+        MatchedNode: this.visitMatched.bind(this),
         AddIndexNode: this.visitAddIndex.bind(this),
+        CastNode: this.visitCast.bind(this),
+        FetchNode: this.visitFetch.bind(this),
+        TopNode: this.visitTop.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'AddIndexNode';
+export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/query-node.d.ts

@@ -10,7 +10,9 @@ import { OperationNode } from './operation-node.js';
 import { ExplainNode } from './explain-node.js';
 import { ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
-export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
+import { MergeQueryNode } from './merge-query-node.js';
+import { TopNode } from './top-node.js';
+export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
 };
@@ -23,6 +25,9 @@ type HasReturning = {
 type HasExplain = {
     explain?: ExplainNode;
 };
+type HasTop = {
+    top?: TopNode;
+};
 /**
  * @internal
  */
@@ -31,7 +36,9 @@ export declare const QueryNode: Readonly<{
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
     cloneWithJoin<T_1 extends HasJoins>(node: T_1, join: JoinNode): T_1;
     cloneWithReturning<T_2 extends HasReturning>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
-    cloneWithoutWhere<T_3 extends HasWhere>(node: T_3): T_3;
-    cloneWithExplain<T_4 extends HasExplain>(node: T_4, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_4;
+    cloneWithoutReturning<T_3 extends HasReturning>(node: T_3): T_3;
+    cloneWithoutWhere<T_4 extends HasWhere>(node: T_4): T_4;
+    cloneWithExplain<T_5 extends HasExplain>(node: T_5, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_5;
+    cloneWithTop<T_6 extends HasTop>(node: T_6, top: TopNode): T_6;
 }>;
 export {};

package/dist/esm/operation-node/query-node.js

@@ -7,6 +7,7 @@ import { WhereNode } from './where-node.js';
 import { freeze } from '../util/object-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { ExplainNode } from './explain-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
 /**
  * @internal
  */
@@ -15,7 +16,8 @@ export const QueryNode = freeze({
         return (SelectQueryNode.is(node) ||
             InsertQueryNode.is(node) ||
             UpdateQueryNode.is(node) ||
-            DeleteQueryNode.is(node));
+            DeleteQueryNode.is(node) ||
+            MergeQueryNode.is(node));
     },
     cloneWithWhere(node, operation) {
         return freeze({
@@ -39,6 +41,12 @@ export const QueryNode = freeze({
                 : ReturningNode.create(selections),
         });
     },
+    cloneWithoutReturning(node) {
+        return freeze({
+            ...node,
+            returning: undefined,
+        });
+    },
     cloneWithoutWhere(node) {
         return freeze({
             ...node,
@@ -51,4 +59,10 @@ export const QueryNode = freeze({
             explain: ExplainNode.create(format, options?.toOperationNode()),
         });
     },
+    cloneWithTop(node, top) {
+        return freeze({
+            ...node,
+            top,
+        });
+    },
 });

package/dist/esm/operation-node/select-query-node.d.ts

@@ -14,6 +14,8 @@ import { WithNode } from './with-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { ExplainNode } from './explain-node.js';
 import { SetOperationNode } from './set-operation-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from?: FromNode;
@@ -31,6 +33,8 @@ export interface SelectQueryNode extends OperationNode {
     readonly having?: HavingNode;
     readonly explain?: ExplainNode;
     readonly setOperations?: ReadonlyArray<SetOperationNode>;
+    readonly fetch?: FetchNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -47,6 +51,7 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
+    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;

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

@@ -84,6 +84,12 @@ export const SelectQueryNode = freeze({
             offset,
         });
     },
+    cloneWithFetch(selectNode, fetch) {
+        return freeze({
+            ...selectNode,
+            fetch,
+        });
+    },
     cloneWithHaving(selectNode, operation) {
         return freeze({
             ...selectNode,

package/dist/esm/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/esm/operation-node/top-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./top-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const TopNode = freeze({
+    is(node) {
+        return node.kind === 'TopNode';
+    },
+    create(expression, modifiers) {
+        return freeze({
+            kind: 'TopNode',
+            expression,
+            modifiers,
+        });
+    },
+});

package/dist/esm/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/esm/operation-node/update-query-node.js

@@ -15,6 +15,11 @@ export const UpdateQueryNode = freeze({
             ...(withNode && { with: withNode }),
         });
     },
+    createWithoutTable() {
+        return freeze({
+            kind: 'UpdateQueryNode',
+        });
+    },
     cloneWithFromItems(updateQuery, fromItems) {
         return freeze({
             ...updateQuery,
@@ -31,4 +36,10 @@ export const UpdateQueryNode = freeze({
                 : updates,
         });
     },
+    cloneWithLimit(updateQuery, limit) {
+        return freeze({
+            ...updateQuery,
+            limit,
+        });
+    },
 });

package/dist/esm/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/esm/parser/binary-operation-parser.js

@@ -32,7 +32,7 @@ export function parseFilterObject(obj, combinator) {
         .filter(([, v]) => !isUndefined(v))
         .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
-export function parseFilterList(list, combinator) {
+export function parseFilterList(list, combinator, withParens = true) {
     const combine = combinator === 'and' ? AndNode.create : OrNode.create;
     if (list.length === 0) {
         return BinaryOperationNode.create(ValueNode.createImmediate(1), OperatorNode.create('='), ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
@@ -41,7 +41,7 @@ export 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 ParensNode.create(node);
     }
     return node;

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

@@ -1,8 +1,12 @@
 /// <reference types="./data-type-parser.d.ts" />
-import { DataTypeNode, } from '../operation-node/data-type-node.js';
+import { DataTypeNode, isColumnDataType, } from '../operation-node/data-type-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 export function parseDataTypeExpression(dataType) {
-    return isOperationNodeSource(dataType)
-        ? dataType.toOperationNode()
-        : DataTypeNode.create(dataType);
+    if (isOperationNodeSource(dataType)) {
+        return dataType.toOperationNode();
+    }
+    if (isColumnDataType(dataType)) {
+        return DataTypeNode.create(dataType);
+    }
+    throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
 }

package/dist/esm/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/esm/parser/fetch-parser.js

@@ -0,0 +1,15 @@
+/// <reference types="./fetch-parser.d.ts" />
+import { FetchNode } from '../operation-node/fetch-node.js';
+import { isBigInt, isNumber } from '../util/object-utils.js';
+export function parseFetch(rowCount, modifier) {
+    if (!isNumber(rowCount) && !isBigInt(rowCount)) {
+        throw new Error(`Invalid fetch row count: ${rowCount}`);
+    }
+    if (!isFetchModifier(modifier)) {
+        throw new Error(`Invalid fetch modifier: ${modifier}`);
+    }
+    return FetchNode.create(rowCount, modifier);
+}
+function isFetchModifier(value) {
+    return value === 'only' || value === 'with ties';
+}

package/dist/esm/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/esm/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/esm/parser/merge-parser.js

@@ -0,0 +1,28 @@
+/// <reference types="./merge-parser.d.ts" />
+import { MatchedNode } from '../operation-node/matched-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+import { isString } from '../util/object-utils.js';
+import { parseFilterList, parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from './binary-operation-parser.js';
+export function parseMergeWhen(type, args, refRight) {
+    return WhenNode.create(parseFilterList([
+        MatchedNode.create(!type.isMatched, type.bySource),
+        ...(args && args.length > 0
+            ? [
+                args.length === 3 && refRight
+                    ? parseReferentialBinaryOperation(args[0], args[1], args[2])
+                    : parseValueBinaryOperationOrExpression(args),
+            ]
+            : []),
+    ], 'and', false));
+}
+export function parseMergeThen(result) {
+    if (isString(result)) {
+        return RawNode.create([result], []);
+    }
+    if (isOperationNodeSource(result)) {
+        return result.toOperationNode();
+    }
+    return result;
+}

package/dist/esm/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/esm/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/esm/parser/top-parser.js

@@ -0,0 +1,17 @@
+/// <reference types="./top-parser.d.ts" />
+import { TopNode } from '../operation-node/top-node.js';
+import { isBigInt, isNumber, isUndefined } from '../util/object-utils.js';
+export function parseTop(expression, modifiers) {
+    if (!isNumber(expression) && !isBigInt(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!isUndefined(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return TopNode.create(expression, modifiers);
+}
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}

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

@@ -27,6 +27,7 @@ const ROOT_OPERATION_NODES = freeze({
     RawNode: true,
     SelectQueryNode: true,
     UpdateQueryNode: true,
+    MergeQueryNode: true,
 });
 export class WithSchemaTransformer extends OperationNodeTransformer {
     #schema;
@@ -101,6 +102,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
                 this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
             }
         }
+        if ('using' in node && node.using) {
+            this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
+        }
         return schemableIds;
     }
     #collectCTEs(node) {

package/dist/esm/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.
      *