kysely 0.26.2 → 0.27.0

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

@@ -3,7 +3,7 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
 import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
-import { parseUpdateExpression, } from '../parser/update-set-parser.js';
+import { parseUpdateObjectExpression, } from '../parser/update-set-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class OnConflictBuilder {
@@ -81,11 +81,6 @@ export class OnConflictBuilder {
             onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, 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,
@@ -173,7 +168,7 @@ export class OnConflictBuilder {
         return new OnConflictUpdateBuilder({
             ...this.#props,
             onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
-                updates: parseUpdateExpression(update),
+                updates: parseUpdateObjectExpression(update),
             }),
         });
     }

package/dist/esm/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/esm/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/esm/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/esm/query-builder/select-query-builder-expression.js

@@ -0,0 +1,2 @@
+/// <reference types="./select-query-builder-expression.d.ts" />
+export {};

package/dist/esm/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/esm/query-builder/select-query-builder.js

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

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

@@ -4,7 +4,7 @@ import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { parseUpdateExpression, } from '../parser/update-set-parser.js';
+import { parseUpdate, } from '../parser/update-set-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
@@ -63,10 +63,10 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
-    set(update) {
+    set(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateExpression(update)),
+            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdate(...args)),
         });
     }
     returning(selection) {

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

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

@@ -48,7 +48,7 @@ import { RootOperationNode, QueryCompiler } from './query-compiler.js';
 import { HavingNode } from '../operation-node/having-node.js';
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
-import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { AlterTableColumnAlterationNode, AlterTableNode } from '../operation-node/alter-table-node.js';
 import { DropColumnNode } from '../operation-node/drop-column-node.js';
 import { RenameColumnNode } from '../operation-node/rename-column-node.js';
 import { AlterColumnNode } from '../operation-node/alter-column-node.js';
@@ -88,6 +88,7 @@ import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONPathLegNode } from '../operation-node/json-path-leg-node.js';
 import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
 import { TupleNode } from '../operation-node/tuple-node.js';
+import { AddIndexNode } from '../operation-node/add-index-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -184,6 +185,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitJSONPath(node: JSONPathNode): void;
     protected visitJSONPathLeg(node: JSONPathLegNode): void;
     protected visitJSONOperatorChain(node: JSONOperatorChainNode): void;
+    protected visitAddIndex(node: AddIndexNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
@@ -197,4 +199,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
     protected sortSelectModifiers(arr: SelectModifierNode[]): ReadonlyArray<SelectModifierNode>;
+    protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
+    /**
+     * controls whether the dialect adds a "type" keyword before a column's new data
+     * type in an ALTER TABLE statement.
+     */
+    protected announcesNewColumnDataType(): boolean;
 }

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

@@ -1,4 +1,5 @@
 /// <reference types="./default-query-compiler.d.ts" />
+import { CreateTableNode } from '../operation-node/create-table-node.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { OperatorNode } from '../operation-node/operator-node.js';
@@ -30,6 +31,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         const wrapInParens = this.parentNode !== undefined &&
             !ParensNode.is(this.parentNode) &&
             !InsertQueryNode.is(this.parentNode) &&
+            !CreateTableNode.is(this.parentNode) &&
             !CreateViewNode.is(this.parentNode) &&
             !SetOperationNode.is(this.parentNode);
         if (this.parentNode === undefined && node.explain) {
@@ -346,16 +348,22 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append('if not exists ');
         }
         this.visitNode(node.table);
-        this.append(' (');
-        this.compileList([...node.columns, ...(node.constraints ?? [])]);
-        this.append(')');
-        if (node.onCommit) {
-            this.append(' on commit ');
-            this.append(node.onCommit);
+        if (node.selectQuery) {
+            this.append(' as ');
+            this.visitNode(node.selectQuery);
         }
-        if (node.endModifiers && node.endModifiers.length > 0) {
-            this.append(' ');
-            this.compileList(node.endModifiers, ' ');
+        else {
+            this.append(' (');
+            this.compileList([...node.columns, ...(node.constraints ?? [])]);
+            this.append(')');
+            if (node.onCommit) {
+                this.append(' on commit ');
+                this.append(node.onCommit);
+            }
+            if (node.endModifiers && node.endModifiers.length > 0) {
+                this.append(' ');
+                this.compileList(node.endModifiers, ' ');
+            }
         }
     }
     visitColumnDefinition(node) {
@@ -383,6 +391,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.unique) {
             this.append(' unique');
         }
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
         if (node.primaryKey) {
             this.append(' primary key');
         }
@@ -563,6 +574,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileList(node.columns);
             this.append(')');
         }
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
         if (node.where) {
             this.append(' ');
             this.visitNode(node.where);
@@ -615,7 +629,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.name);
             this.append(' ');
         }
-        this.append('unique (');
+        this.append('unique');
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
+        this.append(' (');
         this.compileList(node.columns);
         this.append(')');
     }
@@ -696,7 +714,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.dropConstraint);
         }
         if (node.columnAlterations) {
-            this.compileList(node.columnAlterations);
+            this.compileColumnAlterations(node.columnAlterations);
+        }
+        if (node.addIndex) {
+            this.visitNode(node.addIndex);
+        }
+        if (node.dropIndex) {
+            this.visitNode(node.dropIndex);
         }
     }
     visitAddColumn(node) {
@@ -718,7 +742,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.column);
         this.append(' ');
         if (node.dataType) {
-            this.append('type ');
+            if (this.announcesNewColumnDataType()) {
+                this.append('type ');
+            }
             this.visitNode(node.dataType);
             if (node.dataTypeExpression) {
                 this.append('using ');
@@ -1004,6 +1030,23 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.values[i]);
         }
     }
+    visitAddIndex(node) {
+        this.append('add ');
+        if (node.unique) {
+            this.append('unique ');
+        }
+        this.append('index ');
+        this.visitNode(node.name);
+        if (node.columns) {
+            this.append(' (');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+        if (node.using) {
+            this.append(' using ');
+            this.visitNode(node.using);
+        }
+    }
     append(str) {
         this.#sql += str;
     }
@@ -1077,6 +1120,16 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             : 1);
         return freeze(arr);
     }
+    compileColumnAlterations(columnAlterations) {
+        this.compileList(columnAlterations);
+    }
+    /**
+     * controls whether the dialect adds a "type" keyword before a column's new data
+     * type in an ALTER TABLE statement.
+     */
+    announcesNewColumnDataType() {
+        return true;
+    }
 }
 const SELECT_MODIFIER_SQL = freeze({
     ForKeyShare: 'for key share',