kysely 0.17.3 → 0.18.0

package/README.md

@@ -1,3 +1,5 @@
+[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
+
 [![Discord](https://img.shields.io/discord/890118421587578920)](https://discord.gg/C9aJ49mCra)
 [![Tests](https://github.com/koskimas/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/koskimas/kysely)
 

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

@@ -9,12 +9,12 @@ export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | Se
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: AliasNodeChild;
-    readonly alias: IdentifierNode;
+    readonly alias: IdentifierNode | RawNode;
 }
 /**
  * @internal
  */
 export declare const AliasNode: Readonly<{
     is(node: OperationNode): node is AliasNode;
-    create(node: AliasNodeChild, alias: string): AliasNode;
+    create(node: AliasNodeChild, alias: IdentifierNode | RawNode): AliasNode;
 }>;

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const identifier_node_js_1 = require("./identifier-node.js");
 /**
  * @internal
  */
@@ -14,7 +13,7 @@ exports.AliasNode = (0, object_utils_js_1.freeze)({
         return (0, object_utils_js_1.freeze)({
             kind: 'AliasNode',
             node,
-            alias: identifier_node_js_1.IdentifierNode.create(alias),
+            alias,
         });
     },
 });

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

@@ -333,6 +333,7 @@ class OperationNodeTransformer {
         return {
             kind: 'UpdateQueryNode',
             table: this.transformNode(node.table),
+            from: this.transformNode(node.from),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),

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

@@ -7,10 +7,12 @@ import { ReturningNode } from './returning-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { FromNode } from './from-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table: TableExpressionNode;
+    readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
@@ -23,5 +25,6 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: TableExpressionNode, withNode?: WithNode | undefined): UpdateQueryNode;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
 }>;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateQueryNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const from_node_js_1 = require("./from-node.js");
 /**
  * @internal
  */
@@ -10,11 +11,19 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'UpdateQueryNode';
     },
     create(table, withNode) {
-        return {
+        return (0, object_utils_js_1.freeze)({
             kind: 'UpdateQueryNode',
             table,
             ...(withNode && { with: withNode }),
-        };
+        });
+    },
+    cloneWithFromItems(updateQuery, fromItems) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            from: updateQuery.from
+                ? from_node_js_1.FromNode.cloneWithFroms(updateQuery.from, fromItems)
+                : from_node_js_1.FromNode.create(fromItems),
+        });
     },
     cloneWithUpdates(updateQuery, updates) {
         return (0, object_utils_js_1.freeze)({

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

@@ -8,6 +8,7 @@ const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 function parseReferenceExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -50,7 +51,7 @@ function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
     if (ref.includes(ALIAS_SEPARATOR)) {
         const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
-        return alias_node_js_1.AliasNode.create(parseStringReference(columnRef), alias);
+        return alias_node_js_1.AliasNode.create(parseStringReference(columnRef), identifier_node_js_1.IdentifierNode.create(alias));
     }
     else {
         return parseStringReference(ref);

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

@@ -5,6 +5,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
 const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 function parseTableExpressionOrList(table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -27,7 +28,7 @@ function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
         const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
-        return alias_node_js_1.AliasNode.create(parseTable(table), alias);
+        return alias_node_js_1.AliasNode.create(parseTable(table), identifier_node_js_1.IdentifierNode.create(alias));
     }
     else {
         return parseTable(from);

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

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

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

@@ -8,14 +8,14 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

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

@@ -382,7 +382,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .onDuplicateKeyUpdate({ species: 'hamster' })
      * ```
      */
-    onDuplicateKeyUpdate(updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onDuplicateKeyUpdate(updates: MutationObject<DB, TB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -386,7 +386,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;

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

@@ -1212,7 +1212,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -1221,6 +1221,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as<A extends string>(alias: A): AliasedQueryBuilder<DB, TB, O, A>;

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

@@ -15,6 +15,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const group_by_parser_js_1 = require("../parser/group-by-parser.js");
 const union_parser_js_1 = require("../parser/union-parser.js");
 const no_result_error_js_1 = require("./no-result-error.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -515,7 +516,7 @@ class SelectQueryBuilder {
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -524,6 +525,8 @@ class SelectQueryBuilder {
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as(alias) {
@@ -613,10 +616,7 @@ class AliasedQueryBuilder {
     }
     toOperationNode() {
         const node = this.#queryBuilder.toOperationNode();
-        if (select_query_node_js_1.SelectQueryNode.is(node)) {
-            return alias_node_js_1.AliasNode.create(node, this.#alias);
-        }
-        throw new Error('only select queries can be aliased');
+        return alias_node_js_1.AliasNode.create(node, identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
 }
 exports.AliasedQueryBuilder = AliasedQueryBuilder;

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

@@ -19,7 +19,7 @@ import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
-export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -206,9 +206,9 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, TB, O>;
-    where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
-    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -260,7 +260,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -324,15 +324,15 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, TB, O>;
-    orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
-    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -393,19 +393,48 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * )
      * ```
      */
-    whereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `not exists` clause.
      */
-    whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `or exists` clause.
      */
-    orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `or not exists` clause.
      */
-    orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Adds a from clause to the update query.
+     *
+     * This is supported only on some databases like PostgreSQL.
+     *
+     * The API is the same as {@link QueryCreator.selectFrom}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .from('pet')
+     *   .set({
+     *     first_name: (eb) => eb.ref('pet.name')
+     *   })
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = "pet"."name"
+     * from "pet"
+     * where "pet"."owner_id" = "person"."id"
+     * ```
+     */
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -515,23 +544,23 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a left join nstead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -619,7 +648,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * where "id" = $4
      * ```
      */
-    set(row: MutationObject<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    set(row: MutationObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -679,13 +708,13 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
-    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): UpdateQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    returningAll(): UpdateQueryBuilder<DB, UT, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -745,18 +774,18 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      * ```
      */
-    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, TB, O2>): UpdateQueryBuilder<DB, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
+    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): UpdateQueryBuilder<DB, UT, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
-    castTo<T>(): UpdateQueryBuilder<DB, TB, T>;
+    castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
     /**
      * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
      */
-    withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, TB, O>;
+    withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, UT, TB, O>;
     toOperationNode(): UpdateQueryNode;
     compile(): CompiledQuery;
     /**

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateQueryBuilder = void 0;
 const join_parser_js_1 = require("../parser/join-parser.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const filter_parser_js_1 = require("../parser/filter-parser.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
@@ -64,6 +65,12 @@ class UpdateQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
         });
     }
+    from(from) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, (0, table_parser_js_1.parseTableExpressionOrList)(from)),
+        });
+    }
     innerJoin(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,

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

@@ -427,6 +427,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         if (node.updates) {
             this.compileList(node.updates);
         }
+        if (node.from) {
+            this.append(' ');
+            this.visitNode(node.from);
+        }
         if (node.joins) {
             this.append(' ');
             this.compileList(node.joins, ' ');

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

@@ -203,7 +203,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -38,8 +39,37 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * select concat(first_name, ' ', last_name) as "full_name"
      * from "person"
      * ```
+     *
+     * You can also pass in a raw SQL snippet but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    as<A extends string = never>(alias: AnyRawBuilder): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -67,9 +97,9 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
      * which causes this type to be equal to AliasedRawBuilder with any A
      * as long as O is the same.
      */
-    protected get alias(): A;
+    protected get alias(): A | AnyRawBuilder;
     toOperationNode(): AliasNode;
-    constructor(rawBuilder: RawBuilder<O>, alias: A);
+    constructor(rawBuilder: RawBuilder<O>, alias: A | AnyRawBuilder);
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;

package/dist/cjs/raw-builder/raw-builder.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasedRawBuilder = exports.RawBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -16,31 +18,6 @@ class RawBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
-    /**
-     * Returns an aliased version of the SQL expression.
-     *
-     * In addition to slapping `as "the_alias"` to the end of the SQL,
-     * this method also provides strict typing:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select(
-     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     *
-     * // `full_name: string` field exists in the result type.
-     * console.log(result.full_name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```ts
-     * select concat(first_name, ' ', last_name) as "full_name"
-     * from "person"
-     * ```
-     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -103,7 +80,9 @@ class AliasedRawBuilder {
         return this.#alias;
     }
     toOperationNode() {
-        return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), this.#alias);
+        return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
+            ? this.#alias.toOperationNode()
+            : identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;

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

@@ -9,12 +9,12 @@ export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | Se
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: AliasNodeChild;
-    readonly alias: IdentifierNode;
+    readonly alias: IdentifierNode | RawNode;
 }
 /**
  * @internal
  */
 export declare const AliasNode: Readonly<{
     is(node: OperationNode): node is AliasNode;
-    create(node: AliasNodeChild, alias: string): AliasNode;
+    create(node: AliasNodeChild, alias: IdentifierNode | RawNode): AliasNode;
 }>;

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

@@ -1,6 +1,5 @@
 /// <reference types="./alias-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
 /**
  * @internal
  */
@@ -12,7 +11,7 @@ export const AliasNode = freeze({
         return freeze({
             kind: 'AliasNode',
             node,
-            alias: IdentifierNode.create(alias),
+            alias,
         });
     },
 });

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

@@ -331,6 +331,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'UpdateQueryNode',
             table: this.transformNode(node.table),
+            from: this.transformNode(node.from),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),

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

@@ -7,10 +7,12 @@ import { ReturningNode } from './returning-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { FromNode } from './from-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table: TableExpressionNode;
+    readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
@@ -23,5 +25,6 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: TableExpressionNode, withNode?: WithNode | undefined): UpdateQueryNode;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
 }>;

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

@@ -1,5 +1,6 @@
 /// <reference types="./update-query-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { FromNode } from './from-node.js';
 /**
  * @internal
  */
@@ -8,11 +9,19 @@ export const UpdateQueryNode = freeze({
         return node.kind === 'UpdateQueryNode';
     },
     create(table, withNode) {
-        return {
+        return freeze({
             kind: 'UpdateQueryNode',
             table,
             ...(withNode && { with: withNode }),
-        };
+        });
+    },
+    cloneWithFromItems(updateQuery, fromItems) {
+        return freeze({
+            ...updateQuery,
+            from: updateQuery.from
+                ? FromNode.cloneWithFroms(updateQuery.from, fromItems)
+                : FromNode.create(fromItems),
+        });
     },
     cloneWithUpdates(updateQuery, updates) {
         return freeze({

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

@@ -6,6 +6,7 @@ import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseComplexExpression, } from './complex-expression-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseReferenceExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -45,7 +46,7 @@ export function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
     if (ref.includes(ALIAS_SEPARATOR)) {
         const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseStringReference(columnRef), alias);
+        return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
     }
     else {
         return parseStringReference(ref);

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

@@ -3,6 +3,7 @@ import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
 import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -23,7 +24,7 @@ export function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
         const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseTable(table), alias);
+        return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
     }
     else {
         return parseTable(from);

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

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

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

@@ -8,14 +8,14 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

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

@@ -382,7 +382,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .onDuplicateKeyUpdate({ species: 'hamster' })
      * ```
      */
-    onDuplicateKeyUpdate(updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onDuplicateKeyUpdate(updates: MutationObject<DB, TB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -386,7 +386,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;

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

@@ -1212,7 +1212,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -1221,6 +1221,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as<A extends string>(alias: A): AliasedQueryBuilder<DB, TB, O, A>;

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

@@ -13,6 +13,7 @@ import { freeze } from '../util/object-utils.js';
 import { parseGroupBy } from '../parser/group-by-parser.js';
 import { parseUnion } from '../parser/union-parser.js';
 import { NoResultError } from './no-result-error.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -513,7 +514,7 @@ export class SelectQueryBuilder {
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -522,6 +523,8 @@ export class SelectQueryBuilder {
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as(alias) {
@@ -610,9 +613,6 @@ export class AliasedQueryBuilder {
     }
     toOperationNode() {
         const node = this.#queryBuilder.toOperationNode();
-        if (SelectQueryNode.is(node)) {
-            return AliasNode.create(node, this.#alias);
-        }
-        throw new Error('only select queries can be aliased');
+        return AliasNode.create(node, IdentifierNode.create(this.#alias));
     }
 }

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

@@ -19,7 +19,7 @@ import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
-export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -206,9 +206,9 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, TB, O>;
-    where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
-    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -260,7 +260,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -324,15 +324,15 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, TB, O>;
-    orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
-    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -393,19 +393,48 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * )
      * ```
      */
-    whereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `not exists` clause.
      */
-    whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `or exists` clause.
      */
-    orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `or not exists` clause.
      */
-    orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Adds a from clause to the update query.
+     *
+     * This is supported only on some databases like PostgreSQL.
+     *
+     * The API is the same as {@link QueryCreator.selectFrom}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .from('pet')
+     *   .set({
+     *     first_name: (eb) => eb.ref('pet.name')
+     *   })
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = "pet"."name"
+     * from "pet"
+     * where "pet"."owner_id" = "person"."id"
+     * ```
+     */
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -515,23 +544,23 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a left join nstead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -619,7 +648,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * where "id" = $4
      * ```
      */
-    set(row: MutationObject<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    set(row: MutationObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -679,13 +708,13 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
-    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): UpdateQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    returningAll(): UpdateQueryBuilder<DB, UT, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -745,18 +774,18 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      * ```
      */
-    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, TB, O2>): UpdateQueryBuilder<DB, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
+    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): UpdateQueryBuilder<DB, UT, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
-    castTo<T>(): UpdateQueryBuilder<DB, TB, T>;
+    castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
     /**
      * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
      */
-    withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, TB, O>;
+    withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, UT, TB, O>;
     toOperationNode(): UpdateQueryNode;
     compile(): CompiledQuery;
     /**

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

@@ -1,5 +1,6 @@
 /// <reference types="./update-query-builder.d.ts" />
 import { parseJoin, } from '../parser/join-parser.js';
+import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
@@ -62,6 +63,12 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(arg)),
         });
     }
+    from(from) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, parseTableExpressionOrList(from)),
+        });
+    }
     innerJoin(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,

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

@@ -425,6 +425,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.updates) {
             this.compileList(node.updates);
         }
+        if (node.from) {
+            this.append(' ');
+            this.visitNode(node.from);
+        }
         if (node.joins) {
             this.append(' ');
             this.compileList(node.joins, ' ');

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

@@ -203,7 +203,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -38,8 +39,37 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * select concat(first_name, ' ', last_name) as "full_name"
      * from "person"
      * ```
+     *
+     * You can also pass in a raw SQL snippet but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    as<A extends string = never>(alias: AnyRawBuilder): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -67,9 +97,9 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
      * which causes this type to be equal to AliasedRawBuilder with any A
      * as long as O is the same.
      */
-    protected get alias(): A;
+    protected get alias(): A | AnyRawBuilder;
     toOperationNode(): AliasNode;
-    constructor(rawBuilder: RawBuilder<O>, alias: A);
+    constructor(rawBuilder: RawBuilder<O>, alias: A | AnyRawBuilder);
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;

package/dist/esm/raw-builder/raw-builder.js

@@ -1,8 +1,10 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -14,31 +16,6 @@ export class RawBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
-    /**
-     * Returns an aliased version of the SQL expression.
-     *
-     * In addition to slapping `as "the_alias"` to the end of the SQL,
-     * this method also provides strict typing:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select(
-     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     *
-     * // `full_name: string` field exists in the result type.
-     * console.log(result.full_name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```ts
-     * select concat(first_name, ' ', last_name) as "full_name"
-     * from "person"
-     * ```
-     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -100,7 +77,9 @@ export class AliasedRawBuilder {
         return this.#alias;
     }
     toOperationNode() {
-        return AliasNode.create(this.#rawBuilder.toOperationNode(), this.#alias);
+        return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias)
+            ? this.#alias.toOperationNode()
+            : IdentifierNode.create(this.#alias));
     }
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.17.3",
+  "version": "0.18.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",