kysely 0.26.2 → 0.27.0

package/dist/cjs/query-builder/json-path-builder.d.ts

@@ -1,10 +1,11 @@
 import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 import { AliasNode } from '../operation-node/alias-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 export declare class JSONPathBuilder<S, O = S> {
     #private;
-    constructor(node: JSONReferenceNode);
+    constructor(node: JSONReferenceNode | JSONPathNode);
     /**
      * Access an element of a JSON array in a specific location.
      *
@@ -123,7 +124,7 @@ export declare class JSONPathBuilder<S, O = S> {
 }
 export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O> implements AliasableExpression<O> {
     #private;
-    constructor(node: JSONReferenceNode);
+    constructor(node: JSONReferenceNode | JSONPathNode);
     /** @private */
     /**
      * All expressions need to have this getter for complicated type-related reasons.

package/dist/cjs/query-builder/json-path-builder.js

@@ -134,9 +134,12 @@ class JSONPathBuilder {
         return this.#createBuilderWithPathLeg('Member', key);
     }
     #createBuilderWithPathLeg(legType, value) {
-        return new TraversedJSONPathBuilder(json_reference_node_js_1.JSONReferenceNode.cloneWithTraversal(this.#node, json_path_node_js_1.JSONPathNode.is(this.#node.traversal)
-            ? json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node.traversal, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value))
-            : json_operator_chain_node_js_1.JSONOperatorChainNode.cloneWithValue(this.#node.traversal, value_node_js_1.ValueNode.createImmediate(value))));
+        if (json_reference_node_js_1.JSONReferenceNode.is(this.#node)) {
+            return new TraversedJSONPathBuilder(json_reference_node_js_1.JSONReferenceNode.cloneWithTraversal(this.#node, json_path_node_js_1.JSONPathNode.is(this.#node.traversal)
+                ? json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node.traversal, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value))
+                : json_operator_chain_node_js_1.JSONOperatorChainNode.cloneWithValue(this.#node.traversal, value_node_js_1.ValueNode.createImmediate(value))));
+        }
+        return new TraversedJSONPathBuilder(json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value)));
     }
 }
 exports.JSONPathBuilder = JSONPathBuilder;

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

@@ -4,7 +4,8 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { UpdateExpression } from '../parser/update-set-parser.js';
+import { UpdateObjectExpression } from '../parser/update-set-parser.js';
+import { Updateable } from '../util/column-type.js';
 import { AnyColumn, SqlBool } from '../util/type-utils.js';
 import { WhereInterface } from './where-interface.js';
 export declare class OnConflictBuilder<DB, TB extends keyof DB> implements WhereInterface<DB, TB> {
@@ -40,12 +41,6 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * methods for alternative ways to specify the conflict target.
      */
     expression(expression: Expression<any>): OnConflictBuilder<DB, TB>;
-    /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.where} for more info.
-     */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
     /**
      * Adds a `where` expression to the query.
      *
@@ -345,13 +340,60 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   .execute()
      * ```
      */
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): OnConflictBuilder<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): OnConflictBuilder<DB, TB>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
+     * Adds a `where` clause where both sides of the operator are references
+     * to columns.
      *
-     * See {@link WhereInterface.whereRef} for more info.
+     * The normal `where` method treats the right hand side argument as a
+     * value by default. `whereRef` treats it as a column reference. This method is
+     * expecially useful with joins and correlated subqueries.
+     *
+     * ### Examples
+     *
+     * Usage with a join:
+     *
+     * ```ts
+     * db.selectFrom(['person', 'pet'])
+     *   .selectAll()
+     *   .whereRef('person.first_name', '=', 'pet.name')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person", "pet" where "person"."first_name" = "pet"."name"
+     * ```
+     *
+     * Usage in a subquery:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll('person')
+     *   .select((eb) => eb
+     *     .selectFrom('pet')
+     *     .select('name')
+     *     .whereRef('pet.owner_id', '=', 'person.id')
+     *     .limit(1)
+     *     .as('pet_name')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*, (
+     *   select "name"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     *   limit $1
+     * ) as "pet_name"
+     * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): OnConflictBuilder<DB, TB>;
     /**
      * Clears all where expressions from the query.
      *
@@ -435,7 +477,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   )
      * ```
      */
-    doUpdateSet(update: UpdateExpression<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(update: UpdateObjectExpression<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -446,7 +488,7 @@ export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
 }
 export type OnConflictDatabase<DB, TB extends keyof DB> = {
-    [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
+    [K in keyof DB | 'excluded']: Updateable<K extends keyof DB ? DB[K] : DB[TB]>;
 };
 export type OnConflictTables<TB> = TB | 'excluded';
 export declare class OnConflictDoNothingBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -462,7 +504,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *
      * See {@link WhereInterface.where} for more info.
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Adds a `where` expression to the query.
      *
@@ -762,13 +804,13 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   .execute()
      * ```
      */
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): OnConflictUpdateBuilder<DB, TB>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.whereRef} for more info.
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Clears all where expressions from the query.
      *

package/dist/cjs/query-builder/on-conflict-builder.js

@@ -83,11 +83,6 @@ class OnConflictBuilder {
             onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
-    /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.whereRef} for more info.
-     */
     whereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
@@ -175,7 +170,7 @@ class OnConflictBuilder {
         return new OnConflictUpdateBuilder({
             ...this.#props,
             onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
-                updates: (0, update_set_parser_js_1.parseUpdateExpression)(update),
+                updates: (0, update_set_parser_js_1.parseUpdateObjectExpression)(update),
             }),
         });
     }

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

@@ -28,7 +28,7 @@ export declare class OverBuilder<DB, TB extends keyof DB> implements OperationNo
      * from "person"
      * ```
      */
-    orderBy(orderBy: StringReference<DB, TB> | DynamicReferenceBuilder<any>, direction?: OrderByDirectionExpression): OverBuilder<DB, TB>;
+    orderBy<OE extends StringReference<DB, TB> | DynamicReferenceBuilder<any>>(orderBy: OE, direction?: OrderByDirectionExpression): OverBuilder<DB, TB>;
     /**
      * Adds partition by clause item/s inside the over function.
      *
@@ -51,7 +51,7 @@ export declare class OverBuilder<DB, TB extends keyof DB> implements OperationNo
      * ```
      */
     partitionBy(partitionBy: ReadonlyArray<PartitionByExpression<DB, TB>>): OverBuilder<DB, TB>;
-    partitionBy(partitionBy: PartitionByExpression<DB, TB>): OverBuilder<DB, TB>;
+    partitionBy<PE extends PartitionByExpression<DB, TB>>(partitionBy: PE): OverBuilder<DB, TB>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

package/dist/cjs/query-builder/returning-interface.d.ts

@@ -1,5 +1,5 @@
-import { ReturningRow } from '../parser/returning-parser.js';
-import { SelectExpression } from '../parser/select-parser.js';
+import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { SelectCallback, SelectExpression } from '../parser/select-parser.js';
 import { Selectable } from '../util/column-type.js';
 export interface ReturningInterface<DB, TB extends keyof DB, O> {
     /**
@@ -62,6 +62,7 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      * ```
      */
     returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<CB extends SelectCallback<DB, TB>>(callback: CB): ReturningInterface<DB, TB, ReturningCallbackRow<DB, TB, O, CB>>;
     returning<SE extends SelectExpression<DB, TB>>(selection: SE): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases

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

@@ -0,0 +1,20 @@
+import { AliasableExpression } from '../expression/expression.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+export interface SelectQueryBuilderExpression<O> extends AliasableExpression<O> {
+    get isSelectQueryBuilder(): true;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): SelectQueryNode;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,7 +1,7 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { TableExpression } from '../parser/table-parser.js';
-import { SelectExpression, Selection, SelectArg, AllSelection } from '../parser/select-parser.js';
+import { SelectExpression, Selection, AllSelection, SelectCallback, CallbackSelection } from '../parser/select-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
@@ -17,14 +17,15 @@ import { NoResultErrorConstructor } from './no-result-error.js';
 import { HavingInterface } from './having-interface.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { SetOperandExpression } from '../parser/set-operation-parser.js';
-import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Selectable } from '../util/column-type.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
-export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInterface<DB, TB>, HavingInterface<DB, TB>, AliasableExpression<O>, Compilable<O>, Explainable, Streamable<O> {
+import { SelectQueryBuilderExpression } from './select-query-builder-expression.js';
+export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInterface<DB, TB>, HavingInterface<DB, TB>, SelectQueryBuilderExpression<O>, Compilable<O>, Explainable, Streamable<O> {
     /**
      * Adds a `where` expression to the query.
      *
@@ -324,8 +325,8 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): SelectQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): SelectQueryBuilder<DB, TB, O>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -377,18 +378,18 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
      * instead of a `where` statement.
      */
-    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
-    having(expression: ExpressionOrFactory<DB, TB, SqlBool>): SelectQueryBuilder<DB, TB, O>;
+    having<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): SelectQueryBuilder<DB, TB, O>;
+    having<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.whereRef | whereRef} but adds a `having` statement
      * instead of a `where` statement.
      */
-    havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    havingRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a select statement to the query.
      *
@@ -467,14 +468,14 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *
      * <!-- siteExample("select", "Aliases", 40) -->
      *
-     * You can provide an alias for the selections by appending `as the_alias` to the selection.
+     * You can give an alias for selections and tables by appending `as the_alias` to the name:
      *
      * ```ts
      * const persons = await db
-     *   .selectFrom('person')
+     *   .selectFrom('person as p')
      *   .select([
      *     'first_name as fn',
-     *     'person.last_name as ln'
+     *     'p.last_name as ln'
      *   ])
      *   .execute()
      * ```
@@ -484,8 +485,8 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * ```sql
      * select
      *   "first_name" as "fn",
-     *   "person"."last_name" as "ln"
-     * from "person"
+     *   "p"."last_name" as "ln"
+     * from "person" as "p"
      * ```
      *
      * <!-- siteExample("select", "Complex selections", 50) -->
@@ -575,7 +576,9 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * persons[0].id
      * ```
      */
-    select<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>>;
+    select<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>>;
+    select<CB extends SelectCallback<DB, TB>>(callback: CB): SelectQueryBuilder<DB, TB, O & CallbackSelection<DB, TB, CB>>;
+    select<SE extends SelectExpression<DB, TB>>(selection: SE): SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>>;
     /**
      * Adds `distinct on` expressions to the select clause.
      *
@@ -1032,9 +1035,9 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * order by "fn" asc
      * ```
      */
-    orderBy(orderBy: UndirectedOrderByExpression<DB, TB, O>, direction?: OrderByDirectionExpression): SelectQueryBuilder<DB, TB, O>;
-    orderBy(ref: DirectedOrderByStringReference<DB, TB, O>): SelectQueryBuilder<DB, TB, O>;
-    orderBy(refs: ReadonlyArray<OrderByExpression<DB, TB, O>>): SelectQueryBuilder<DB, TB, O>;
+    orderBy<OE extends UndirectedOrderByExpression<DB, TB, O>>(orderBy: OE, direction?: OrderByDirectionExpression): SelectQueryBuilder<DB, TB, O>;
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, O>>(ref: OE): SelectQueryBuilder<DB, TB, O>;
+    orderBy<OE extends OrderByExpression<DB, TB, O>>(refs: ReadonlyArray<OE>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `group by` clause to the query.
      *
@@ -1133,7 +1136,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * group by "first_name"
      * ```
      */
-    groupBy(groupBy: GroupByArg<DB, TB, O>): SelectQueryBuilder<DB, TB, O>;
+    groupBy<GE extends GroupByArg<DB, TB, O>>(groupBy: GE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a limit clause to the query.
      *
@@ -1201,7 +1204,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    union(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    union<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union all`.
      *
@@ -1228,7 +1231,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    unionAll(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    unionAll<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `intersect`.
      *
@@ -1255,7 +1258,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    intersect(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    intersect<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `intersect all`.
      *
@@ -1282,7 +1285,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    intersectAll(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    intersectAll<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `except`.
      *
@@ -1309,7 +1312,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    except(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    except<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `except all`.
      *
@@ -1336,7 +1339,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    exceptAll(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    exceptAll<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -1356,7 +1359,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * pets[0].owner_first_name
      * ```
      */
-    as<A extends string>(alias: A): AliasedSelectQueryBuilder<DB, TB, O, A>;
+    as<A extends string>(alias: A): AliasedSelectQueryBuilder<O, A>;
     /**
      * Clears all select clauses from the query.
      *
@@ -1542,7 +1545,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   )
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<any, any, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<any, any, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<Omit<O2, keyof O>>>;
     /**
      * Change the output type of the query.
      *
@@ -1637,6 +1640,22 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *
      * functionThatExpectsPersonWithNonNullValue(person)
      * ```
+     *
+     * Giving the explicit narrowed type (`string` in the example above) works fine for
+     * simple types. If the type is complex, for example a JSON column or a subquery,
+     * you can use the special `NotNull` type to make the column not null.
+     *
+     * ```ts
+     * import { NotNull } from 'kysely'
+     *
+     * const person = await db.selectFrom('person')
+     *   .where('nullable_column', 'is not', null)
+     *   .selectAll()
+     *   .$narrowType<{ nullable_column: NotNull }>()
+     *   .executeTakeFirstOrThrow()
+     *
+     * functionThatExpectsPersonWithNonNullValue(person)
+     * ```
      */
     $narrowType<T>(): SelectQueryBuilder<DB, TB, NarrowPartial<O, T>>;
     /**
@@ -1789,8 +1808,8 @@ export interface SelectQueryBuilderProps {
     readonly queryNode: SelectQueryNode;
     readonly executor: QueryExecutor;
 }
-export interface AliasedSelectQueryBuilder<DB, TB extends keyof DB, O = undefined, A extends string = never> extends AliasedExpression<O, A> {
-    get selectQueryBuilder(): SelectQueryBuilder<DB, TB, O>;
+export interface AliasedSelectQueryBuilder<O = undefined, A extends string = never> extends AliasedExpression<O, A> {
+    get isAliasedSelectQueryBuilder(): true;
 }
 export type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
 type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, R>, TB | A, O>;

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

@@ -27,6 +27,9 @@ class SelectQueryBuilderImpl {
     get expressionType() {
         return undefined;
     }
+    get isSelectQueryBuilder() {
+        return true;
+    }
     where(...args) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
@@ -342,8 +345,8 @@ class AliasedSelectQueryBuilderImpl {
     get alias() {
         return this.#alias;
     }
-    get selectQueryBuilder() {
-        return this.#queryBuilder;
+    get isAliasedSelectQueryBuilder() {
+        return true;
     }
     toOperationNode() {
         return alias_node_js_1.AliasNode.create(this.#queryBuilder.toOperationNode(), identifier_node_js_1.IdentifierNode.create(this.#alias));

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

@@ -2,13 +2,13 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { TableExpression, From, FromTables } from '../parser/table-parser.js';
-import { SelectExpression, SelectArg } from '../parser/select-parser.js';
-import { ReturningRow } from '../parser/returning-parser.js';
+import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
+import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
+import { UpdateObject, UpdateObjectFactory, ExtractUpdateTypeFromReferenceExpression } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -24,6 +24,7 @@ import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../p
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
+import { ValueExpression } from '../parser/value-parser.js';
 export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
@@ -326,8 +327,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): UpdateQueryBuilder<DB, UT, TB, O>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -379,7 +380,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Clears all where expressions from the query.
      *
@@ -625,6 +626,20 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   "id" = $4
      * ```
      *
+     * If you provide two arguments the first one is interpreted as the column
+     * (or other target) and the second as the value:
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set('first_name', 'Foo')
+     *   // As always, both arguments can be arbitrary expressions or
+     *   // callbacks that give you access to an expression builder:
+     *   .set(sql`address['postalCode']`, (eb) => eb.val('61710))
+     *   .where('id', '=', '1')
+     *   .executeTakeFirst()
+     * ```
+     *
      * On PostgreSQL you can chain `returning` to the query to get
      * the updated rows' columns (or any other expression) as the
      * return value:
@@ -682,6 +697,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     set(update: UpdateObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     set(update: UpdateObjectFactory<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
+    set<RE extends ReferenceExpression<DB, UT>>(key: RE, value: ValueExpression<DB, TB, ExtractUpdateTypeFromReferenceExpression<DB, UT, RE>>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -741,7 +757,9 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): UpdateQueryBuilder<DB, UT, 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<CB extends SelectCallback<DB, TB>>(callback: CB): UpdateQueryBuilder<DB, UT, TB, ReturningCallbackRow<DB, TB, O, CB>>;
+    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.

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

@@ -65,10 +65,10 @@ class UpdateQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('FullJoin', args)),
         });
     }
-    set(update) {
+    set(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, (0, update_set_parser_js_1.parseUpdateExpression)(update)),
+            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, (0, update_set_parser_js_1.parseUpdate)(...args)),
         });
     }
     returning(selection) {

package/dist/cjs/query-builder/where-interface.d.ts

@@ -302,8 +302,8 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): WhereInterface<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): WhereInterface<DB, TB>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): WhereInterface<DB, TB>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -355,7 +355,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): WhereInterface<DB, TB>;
     /**
      * Clears all where expressions from the query.
      *