kysely 0.27.2 → 0.27.3

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

@@ -21,6 +21,8 @@ const set_operation_parser_js_1 = require("../parser/set-operation-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
+const fetch_parser_js_1 = require("../parser/fetch-parser.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
 class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
@@ -188,6 +190,18 @@ class SelectQueryBuilderImpl {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create((0, value_parser_js_1.parseValueExpression)(offset))),
         });
     }
+    fetch(rowCount, modifier = 'only') {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithFetch(this.#props.queryNode, (0, fetch_parser_js_1.parseFetch)(rowCount, modifier)),
+        });
+    }
+    top(expression, modifiers) {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
     union(expression) {
         return new SelectQueryBuilderImpl({
             ...this.#props,

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

@@ -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.
      *
@@ -764,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/cjs/query-builder/update-query-builder.js

@@ -12,6 +12,9 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const update_result_js_1 = require("./update-result.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
+const limit_node_js_1 = require("../operation-node/limit-node.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
 class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -35,6 +38,51 @@ class UpdateQueryBuilder {
             queryNode: query_node_js_1.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: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
     from(from) {
         return new UpdateQueryBuilder({
             ...this.#props,
@@ -65,6 +113,31 @@ class UpdateQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.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: update_query_node_js_1.UpdateQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create((0, value_parser_js_1.parseValueExpression)(limit))),
+        });
+    }
     set(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
@@ -83,6 +156,31 @@ class UpdateQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.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: query_node_js_1.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/cjs/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/cjs/query-compiler/default-query-compiler.js

@@ -10,6 +10,7 @@ const query_node_js_1 = require("../operation-node/query-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
 const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
+const merge_query_node_js_1 = require("../operation-node/merge-query-node.js");
 class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisitor {
     #sql = '';
     #parameters = [];
@@ -56,6 +57,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.compileList(node.frontModifiers, ' ');
         }
+        if (node.top) {
+            this.append(' ');
+            this.visitNode(node.top);
+        }
         if (node.selections) {
             this.append(' ');
             this.compileList(node.selections);
@@ -96,6 +101,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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]), ' ');
@@ -137,12 +146,13 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.visitNode(node.having);
     }
     visitInsertQuery(node) {
-        const isSubQuery = this.nodeStack.find(query_node_js_1.QueryNode.is) !== node;
+        const rootQueryNode = this.nodeStack.find(query_node_js_1.QueryNode.is);
+        const isSubQuery = rootQueryNode !== node;
         if (!isSubQuery && node.explain) {
             this.visitNode(node.explain);
             this.append(' ');
         }
-        if (isSubQuery) {
+        if (isSubQuery && !merge_query_node_js_1.MergeQueryNode.is(rootQueryNode)) {
             this.append('(');
         }
         if (node.with) {
@@ -153,8 +163,14 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         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);
@@ -180,7 +196,7 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.returning);
         }
-        if (isSubQuery) {
+        if (isSubQuery && !merge_query_node_js_1.MergeQueryNode.is(rootQueryNode)) {
             this.append(')');
         }
     }
@@ -202,6 +218,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
         }
         this.append('delete ');
+        if (node.top) {
+            this.visitNode(node.top);
+            this.append(' ');
+        }
         this.visitNode(node.from);
         if (node.using) {
             this.append(' ');
@@ -387,6 +407,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.generated);
         }
+        if (node.identity) {
+            this.append(' identity');
+        }
         if (node.defaultTo) {
             this.append(' ');
             this.visitNode(node.defaultTo);
@@ -470,12 +493,13 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.visitNode(node.groupBy);
     }
     visitUpdateQuery(node) {
-        const isSubQuery = this.nodeStack.find(query_node_js_1.QueryNode.is) !== node;
+        const rootQueryNode = this.nodeStack.find(query_node_js_1.QueryNode.is);
+        const isSubQuery = rootQueryNode !== node;
         if (!isSubQuery && node.explain) {
             this.visitNode(node.explain);
             this.append(' ');
         }
-        if (isSubQuery) {
+        if (isSubQuery && !merge_query_node_js_1.MergeQueryNode.is(rootQueryNode)) {
             this.append('(');
         }
         if (node.with) {
@@ -483,8 +507,15 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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);
         }
@@ -500,11 +531,15 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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 && !merge_query_node_js_1.MergeQueryNode.is(rootQueryNode)) {
             this.append(')');
         }
     }
@@ -1040,6 +1075,36 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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) {
@@ -1057,6 +1122,24 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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;
     }
@@ -1167,4 +1250,5 @@ const JOIN_TYPE_SQL = (0, object_utils_js_1.freeze)({
     FullJoin: 'full join',
     LateralInnerJoin: 'inner join lateral',
     LateralLeftJoin: 'left join lateral',
+    Using: 'using',
 });

package/dist/cjs/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/cjs/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/cjs/query-creator.js

@@ -16,6 +16,8 @@ const query_id_js_1 = require("./util/query-id.js");
 const with_schema_plugin_js_1 = require("./plugin/with-schema/with-schema-plugin.js");
 const object_utils_js_1 = require("./util/object-utils.js");
 const select_parser_js_1 = require("./parser/select-parser.js");
+const merge_query_builder_js_1 = require("./query-builder/merge-query-builder.js");
+const merge_query_node_js_1 = require("./operation-node/merge-query-node.js");
 class QueryCreator {
     #props;
     constructor(props) {
@@ -127,6 +129,13 @@ class QueryCreator {
             queryNode: update_query_node_js_1.UpdateQueryNode.create((0, table_parser_js_1.parseTableExpression)(table), this.#props.withNode),
         });
     }
+    mergeInto(targetTable) {
+        return new merge_query_builder_js_1.MergeQueryBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#props.executor,
+            queryNode: merge_query_node_js_1.MergeQueryNode.create((0, table_parser_js_1.parseAliasedTable)(targetTable), this.#props.withNode),
+        });
+    }
     /**
      * Creates a `with` query (Common Table Expression).
      *

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

@@ -52,7 +52,9 @@ class AlterTableAddIndexBuilder {
         return new AlterTableAddIndexBuilder({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [(0, reference_parser_js_1.parseOrderedColumnName)(column)]),
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    (0, reference_parser_js_1.parseOrderedColumnName)(column),
+                ]),
             }),
         });
     }
@@ -111,7 +113,9 @@ class AlterTableAddIndexBuilder {
         return new AlterTableAddIndexBuilder({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [expression.toOperationNode()]),
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    expression.toOperationNode(),
+                ]),
             }),
         });
     }

package/dist/cjs/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;
     /**

package/dist/cjs/schema/column-definition-builder.js

@@ -26,6 +26,16 @@ class ColumnDefinitionBuilder {
     autoIncrement() {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));
     }
+    /**
+     * 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() {
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { identity: true }));
+    }
     /**
      * Makes the column the primary key.
      *
@@ -193,7 +203,11 @@ class 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() {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {