kysely 0.27.1 → 0.27.3

package/dist/esm/query-builder/select-query-builder.js

@@ -19,6 +19,8 @@ import { parseSetOperations, } from '../parser/set-operation-parser.js';
 import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { parseValueExpression, } from '../parser/value-parser.js';
+import { parseFetch } from '../parser/fetch-parser.js';
+import { parseTop } from '../parser/top-parser.js';
 class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
@@ -186,6 +188,18 @@ class SelectQueryBuilderImpl {
             queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(parseValueExpression(offset))),
         });
     }
+    fetch(rowCount, modifier = 'only') {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithFetch(this.#props.queryNode, parseFetch(rowCount, modifier)),
+        });
+    }
+    top(expression, modifiers) {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers)),
+        });
+    }
     union(expression) {
         return new SelectQueryBuilderImpl({
             ...this.#props,

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

@@ -8,7 +8,7 @@ import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { UpdateObject, UpdateObjectFactory, ExtractUpdateTypeFromReferenceExpression } from '../parser/update-set-parser.js';
+import { UpdateObjectExpression, ExtractUpdateTypeFromReferenceExpression } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -400,6 +400,46 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ```
      */
     clearWhere(): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Changes an `update` query into a `update top` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Update the first row:
+     *
+     * ```ts
+     * await db.updateTable('person')
+     *   .top(1)
+     *   .set({ first_name: 'Foo' })
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * update top(1) "person" set "first_name" = @1 where "age" > @2
+     * ```
+     *
+     * Update the 50% first rows:
+     *
+     * ```ts
+     * await db.updateTable('person')
+     *   .top(50, 'percent')
+     *   .set({ first_name: 'Foo' })
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * update top(50) percent "person" set "first_name" = @1 where "age" > @2
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: 'percent'): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a from clause to the update query.
      *
@@ -555,6 +595,26 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
     fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
+    /**
+     * Adds a limit clause to the update query for supported databases, such as MySQL.
+     *
+     * ### Examples
+     *
+     * Update the first 2 rows in the 'person' table:
+     *
+     * ```ts
+     * return await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'Foo' })
+     *   .limit(2);
+     * ```
+     *
+     * The generated SQL (MySQL):
+     * ```sql
+     * update `person` set `first_name` = 'Foo' limit 2
+     * ```
+     */
+    limit(limit: ValueExpression<DB, TB, number>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -695,8 +755,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "id" = $5
      * ```
      */
-    set(update: UpdateObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
-    set(update: UpdateObjectFactory<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
+    set(update: UpdateObjectExpression<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     set<RE extends ReferenceExpression<DB, UT>>(key: RE, value: ValueExpression<DB, TB, ExtractUpdateTypeFromReferenceExpression<DB, UT, RE>>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
@@ -765,6 +824,26 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * that support `returning` such as PostgreSQL.
      */
     returningAll(): UpdateQueryBuilder<DB, UT, TB, Selectable<DB[TB]>>;
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .returningAll()
+     *   .set({ age: 39 })
+     *   .where('first_name', '=', 'John')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * update "person" set "age" = 39 where "first_name" = "John"
+     * ```
+     */
+    clearReturning(): UpdateQueryBuilder<DB, UT, TB, UpdateResult>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

package/dist/esm/query-builder/update-query-builder.js

@@ -10,6 +10,9 @@ import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
 import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
 import { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
+import { parseValueExpression, } from '../parser/value-parser.js';
+import { LimitNode } from '../operation-node/limit-node.js';
+import { parseTop } from '../parser/top-parser.js';
 export class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -33,6 +36,51 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
         });
     }
+    /**
+     * Changes an `update` query into a `update top` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Update the first row:
+     *
+     * ```ts
+     * await db.updateTable('person')
+     *   .top(1)
+     *   .set({ first_name: 'Foo' })
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * update top(1) "person" set "first_name" = @1 where "age" > @2
+     * ```
+     *
+     * Update the 50% first rows:
+     *
+     * ```ts
+     * await db.updateTable('person')
+     *   .top(50, 'percent')
+     *   .set({ first_name: 'Foo' })
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * update top(50) percent "person" set "first_name" = @1 where "age" > @2
+     * ```
+     */
+    top(expression, modifiers) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers)),
+        });
+    }
     from(from) {
         return new UpdateQueryBuilder({
             ...this.#props,
@@ -63,6 +111,31 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
+    /**
+     * Adds a limit clause to the update query for supported databases, such as MySQL.
+     *
+     * ### Examples
+     *
+     * Update the first 2 rows in the 'person' table:
+     *
+     * ```ts
+     * return await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'Foo' })
+     *   .limit(2);
+     * ```
+     *
+     * The generated SQL (MySQL):
+     * ```sql
+     * update `person` set `first_name` = 'Foo' limit 2
+     * ```
+     */
+    limit(limit) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: UpdateQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit))),
+        });
+    }
     set(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
@@ -81,6 +154,31 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll()),
         });
     }
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .returningAll()
+     *   .set({ age: 39 })
+     *   .where('first_name', '=', 'John')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * update "person" set "age" = 39 where "first_name" = "John"
+     * ```
+     */
+    clearReturning() {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithoutReturning(this.#props.queryNode),
+        });
+    }
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -88,7 +88,12 @@ import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONPathLegNode } from '../operation-node/json-path-leg-node.js';
 import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
 import { TupleNode } from '../operation-node/tuple-node.js';
+import { MergeQueryNode } from '../operation-node/merge-query-node.js';
+import { MatchedNode } from '../operation-node/matched-node.js';
 import { AddIndexNode } from '../operation-node/add-index-node.js';
+import { CastNode } from '../operation-node/cast-node.js';
+import { FetchNode } from '../operation-node/fetch-node.js';
+import { TopNode } from '../operation-node/top-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -185,7 +190,12 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitJSONPath(node: JSONPathNode): void;
     protected visitJSONPathLeg(node: JSONPathLegNode): void;
     protected visitJSONOperatorChain(node: JSONOperatorChainNode): void;
+    protected visitMergeQuery(node: MergeQueryNode): void;
+    protected visitMatched(node: MatchedNode): void;
     protected visitAddIndex(node: AddIndexNode): void;
+    protected visitCast(node: CastNode): void;
+    protected visitFetch(node: FetchNode): void;
+    protected visitTop(node: TopNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -8,6 +8,7 @@ import { QueryNode } from '../operation-node/query-node.js';
 import { freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { SetOperationNode } from '../operation-node/set-operation-node.js';
+import { MergeQueryNode } from '../operation-node/merge-query-node.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sql = '';
     #parameters = [];
@@ -54,6 +55,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.compileList(node.frontModifiers, ' ');
         }
+        if (node.top) {
+            this.append(' ');
+            this.visitNode(node.top);
+        }
         if (node.selections) {
             this.append(' ');
             this.compileList(node.selections);
@@ -94,6 +99,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.offset);
         }
+        if (node.fetch) {
+            this.append(' ');
+            this.visitNode(node.fetch);
+        }
         if (node.endModifiers?.length) {
             this.append(' ');
             this.compileList(this.sortSelectModifiers([...node.endModifiers]), ' ');
@@ -135,12 +144,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.having);
     }
     visitInsertQuery(node) {
-        const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        const rootQueryNode = this.nodeStack.find(QueryNode.is);
+        const isSubQuery = rootQueryNode !== node;
         if (!isSubQuery && node.explain) {
             this.visitNode(node.explain);
             this.append(' ');
         }
-        if (isSubQuery) {
+        if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
             this.append('(');
         }
         if (node.with) {
@@ -151,8 +161,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.ignore) {
             this.append(' ignore');
         }
-        this.append(' into ');
-        this.visitNode(node.into);
+        if (node.top) {
+            this.append(' ');
+            this.visitNode(node.top);
+        }
+        if (node.into) {
+            this.append(' into ');
+            this.visitNode(node.into);
+        }
         if (node.columns) {
             this.append(' (');
             this.compileList(node.columns);
@@ -178,7 +194,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.returning);
         }
-        if (isSubQuery) {
+        if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
             this.append(')');
         }
     }
@@ -200,6 +216,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append('delete ');
+        if (node.top) {
+            this.visitNode(node.top);
+            this.append(' ');
+        }
         this.visitNode(node.from);
         if (node.using) {
             this.append(' ');
@@ -385,6 +405,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.generated);
         }
+        if (node.identity) {
+            this.append(' identity');
+        }
         if (node.defaultTo) {
             this.append(' ');
             this.visitNode(node.defaultTo);
@@ -468,12 +491,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.groupBy);
     }
     visitUpdateQuery(node) {
-        const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        const rootQueryNode = this.nodeStack.find(QueryNode.is);
+        const isSubQuery = rootQueryNode !== node;
         if (!isSubQuery && node.explain) {
             this.visitNode(node.explain);
             this.append(' ');
         }
-        if (isSubQuery) {
+        if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
             this.append('(');
         }
         if (node.with) {
@@ -481,8 +505,15 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append('update ');
-        this.visitNode(node.table);
-        this.append(' set ');
+        if (node.top) {
+            this.visitNode(node.top);
+            this.append(' ');
+        }
+        if (node.table) {
+            this.visitNode(node.table);
+            this.append(' ');
+        }
+        this.append('set ');
         if (node.updates) {
             this.compileList(node.updates);
         }
@@ -498,11 +529,15 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.where);
         }
+        if (node.limit) {
+            this.append(' ');
+            this.visitNode(node.limit);
+        }
         if (node.returning) {
             this.append(' ');
             this.visitNode(node.returning);
         }
-        if (isSubQuery) {
+        if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
             this.append(')');
         }
     }
@@ -1038,6 +1073,36 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.values[i]);
         }
     }
+    visitMergeQuery(node) {
+        if (node.with) {
+            this.visitNode(node.with);
+            this.append(' ');
+        }
+        this.append('merge ');
+        if (node.top) {
+            this.visitNode(node.top);
+            this.append(' ');
+        }
+        this.append('into ');
+        this.visitNode(node.into);
+        if (node.using) {
+            this.append(' ');
+            this.visitNode(node.using);
+        }
+        if (node.whens) {
+            this.append(' ');
+            this.compileList(node.whens);
+        }
+    }
+    visitMatched(node) {
+        if (node.not) {
+            this.append('not ');
+        }
+        this.append('matched');
+        if (node.bySource) {
+            this.append(' by source');
+        }
+    }
     visitAddIndex(node) {
         this.append('add ');
         if (node.unique) {
@@ -1055,6 +1120,24 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.using);
         }
     }
+    visitCast(node) {
+        this.append('cast(');
+        this.visitNode(node.expression);
+        this.append(' as ');
+        this.visitNode(node.dataType);
+        this.append(')');
+    }
+    visitFetch(node) {
+        this.append('fetch next ');
+        this.visitNode(node.rowCount);
+        this.append(` rows ${node.modifier}`);
+    }
+    visitTop(node) {
+        this.append(`top(${node.expression})`);
+        if (node.modifiers) {
+            this.append(` ${node.modifiers}`);
+        }
+    }
     append(str) {
         this.#sql += str;
     }
@@ -1164,4 +1247,5 @@ const JOIN_TYPE_SQL = freeze({
     FullJoin: 'full join',
     LateralInnerJoin: 'inner join lateral',
     LateralLeftJoin: 'left join lateral',
+    Using: 'using',
 });

package/dist/esm/query-compiler/query-compiler.d.ts

@@ -9,10 +9,11 @@ import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
 import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
+import { MergeQueryNode } from '../operation-node/merge-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
-export type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
+export type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode | MergeQueryNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

package/dist/esm/query-creator.d.ts

@@ -12,6 +12,8 @@ import { UpdateResult } from './query-builder/update-result.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { CTEBuilderCallback } from './query-builder/cte-builder.js';
 import { CallbackSelection, SelectCallback, SelectExpression, Selection } from './parser/select-parser.js';
+import { MergeQueryBuilder } from './query-builder/merge-query-builder.js';
+import { MergeResult } from './query-builder/merge-result.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -125,7 +127,7 @@ export declare class QueryCreator<DB> {
     selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB, TE>, {}>;
+    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB & PickTableWithAlias<DB, TE>, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates a `select` query builder without a `from` clause.
@@ -320,8 +322,44 @@ export declare class QueryCreator<DB> {
      * ```
      */
     updateTable<TR extends keyof DB & string>(table: TR): UpdateQueryBuilder<DB, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>;
-    updateTable<TR extends AnyAliasedTable<DB>>(table: TR): UpdateQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>;
+    updateTable<TR extends AnyAliasedTable<DB>>(table: TR): UpdateQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, UpdateResult>;
     updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
+    /**
+     * Creates a merge query.
+     *
+     * The return value of the query is a {@link MergeResult}.
+     *
+     * See the {@link MergeQueryBuilder.using} method for examples on how to specify
+     * the other table.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched((and) => and('has_pets', '!=', 'Y'))
+     *   .thenUpdateSet({ has_pets: 'Y' })
+     *   .whenNotMatched()
+     *   .thenDoNothing()
+     *   .executeTakeFirstOrThrow()
+     *
+     * console.log(result.numChangedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "pet"."owner_id" = "person"."id"
+     * when matched and "has_pets" != $1 then
+     *   update set "has_pets" = $2
+     * when not matched then
+     *   do nothing
+     * ```
+     */
+    mergeInto<TR extends keyof DB & string>(targetTable: TR): MergeQueryBuilder<DB, TR, MergeResult>;
+    mergeInto<TR extends AnyAliasedTable<DB>>(targetTable: TR): MergeQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, MergeResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/esm/query-creator.js

@@ -7,13 +7,15 @@ import { DeleteQueryNode } from './operation-node/delete-query-node.js';
 import { InsertQueryNode } from './operation-node/insert-query-node.js';
 import { SelectQueryNode } from './operation-node/select-query-node.js';
 import { UpdateQueryNode } from './operation-node/update-query-node.js';
-import { parseTable, parseTableExpression, parseTableExpressionOrList, } from './parser/table-parser.js';
+import { parseTable, parseTableExpression, parseTableExpressionOrList, parseAliasedTable, } from './parser/table-parser.js';
 import { parseCommonTableExpression, } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
 import { freeze } from './util/object-utils.js';
 import { parseSelectArg, } from './parser/select-parser.js';
+import { MergeQueryBuilder } from './query-builder/merge-query-builder.js';
+import { MergeQueryNode } from './operation-node/merge-query-node.js';
 export class QueryCreator {
     #props;
     constructor(props) {
@@ -125,6 +127,13 @@ export class QueryCreator {
             queryNode: UpdateQueryNode.create(parseTableExpression(table), this.#props.withNode),
         });
     }
+    mergeInto(targetTable) {
+        return new MergeQueryBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            queryNode: MergeQueryNode.create(parseAliasedTable(targetTable), this.#props.withNode),
+        });
+    }
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/esm/schema/alter-table-add-index-builder.js

@@ -2,7 +2,7 @@
 import { AddIndexNode } from '../operation-node/add-index-node.js';
 import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseOrderedColumnName } from '../parser/reference-parser.js';
+import { parseOrderedColumnName, } from '../parser/reference-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class AlterTableAddIndexBuilder {
@@ -50,7 +50,9 @@ export class AlterTableAddIndexBuilder {
         return new AlterTableAddIndexBuilder({
             ...this.#props,
             node: AlterTableNode.cloneWithTableProps(this.#props.node, {
-                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [parseOrderedColumnName(column)]),
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    parseOrderedColumnName(column),
+                ]),
             }),
         });
     }
@@ -109,7 +111,9 @@ export class AlterTableAddIndexBuilder {
         return new AlterTableAddIndexBuilder({
             ...this.#props,
             node: AlterTableNode.cloneWithTableProps(this.#props.node, {
-                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [expression.toOperationNode()]),
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    expression.toOperationNode(),
+                ]),
             }),
         });
     }

package/dist/esm/schema/column-definition-builder.d.ts

@@ -14,6 +14,14 @@ export declare class ColumnDefinitionBuilder implements OperationNodeSource {
      * you can use the `serial` or `bigserial` data type instead.
      */
     autoIncrement(): ColumnDefinitionBuilder;
+    /**
+     * Makes the column an identity column.
+     *
+     * This only works on some dialects like MS SQL Server (MSSQL).
+     *
+     * For PostgreSQL's `generated always as identity` use {@link generatedAlwaysAsIdentity}.
+     */
+    identity(): ColumnDefinitionBuilder;
     /**
      * Makes the column the primary key.
      *
@@ -137,7 +145,11 @@ export declare class ColumnDefinitionBuilder implements OperationNodeSource {
      */
     generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder;
     /**
-     * Adds the `generated always as identity` specifier on supported dialects.
+     * Adds the `generated always as identity` specifier.
+     *
+     * This only works on some dialects like PostgreSQL.
+     *
+     * For MS SQL Server (MSSQL)'s identity column use {@link identity}.
      */
     generatedAlwaysAsIdentity(): ColumnDefinitionBuilder;
     /**