kysely 0.26.3 → 0.27.1

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

@@ -25,6 +25,7 @@ import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { SelectQueryBuilderExpression } from './select-query-builder-expression.js';
+import { ValueExpression } from '../parser/value-parser.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.
@@ -325,8 +326,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.
@@ -378,18 +379,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.
      *
@@ -468,14 +469,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()
      * ```
@@ -485,8 +486,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) -->
@@ -674,19 +675,19 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Adds the `for update` modifier to a select query on supported databases.
      */
-    forUpdate(): SelectQueryBuilder<DB, TB, O>;
+    forUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for share` modifier to a select query on supported databases.
      */
-    forShare(): SelectQueryBuilder<DB, TB, O>;
+    forShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for key share` modifier to a select query on supported databases.
      */
-    forKeyShare(): SelectQueryBuilder<DB, TB, O>;
+    forKeyShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for no key update` modifier to a select query on supported databases.
      */
-    forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O>;
+    forNoKeyUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `skip locked` modifier to a select query on supported databases.
      */
@@ -1035,9 +1036,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.
      *
@@ -1136,7 +1137,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.
      *
@@ -1161,7 +1162,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .limit(10)
      * ```
      */
-    limit(limit: number): SelectQueryBuilder<DB, TB, O>;
+    limit(limit: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an offset clause to the query.
      *
@@ -1177,7 +1178,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .limit(10)
      * ```
      */
-    offset(offset: number): SelectQueryBuilder<DB, TB, O>;
+    offset(offset: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union`.
      *
@@ -1204,7 +1205,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`.
      *
@@ -1231,7 +1232,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`.
      *
@@ -1258,7 +1259,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`.
      *
@@ -1285,7 +1286,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`.
      *
@@ -1312,7 +1313,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`.
      *
@@ -1339,7 +1340,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.
      *
@@ -1545,14 +1546,14 @@ 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.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `SelectQueryBuilder` with a new output type.
      */
-    $castTo<T>(): SelectQueryBuilder<DB, TB, T>;
+    $castTo<C>(): SelectQueryBuilder<DB, TB, C>;
     /**
      * Changes the output type from an object to a tuple.
      *
@@ -1640,6 +1641,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>>;
     /**
@@ -1815,4 +1832,5 @@ type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = Se
 type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
+type TableOrList<TB extends keyof any> = (TB & string) | ReadonlyArray<TB & string>;
 export {};

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

@@ -2,6 +2,7 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { parseJoin, } from '../parser/join-parser.js';
+import { parseTable } from '../parser/table-parser.js';
 import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
 import { parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
@@ -10,13 +11,14 @@ import { parseOrderBy, } from '../parser/order-by-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { OffsetNode } from '../operation-node/offset-node.js';
-import { freeze } from '../util/object-utils.js';
+import { asArray, freeze } from '../util/object-utils.js';
 import { parseGroupBy } from '../parser/group-by-parser.js';
 import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { parseSetOperations, } from '../parser/set-operation-parser.js';
 import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { parseValueExpression, } from '../parser/value-parser.js';
 class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
@@ -82,28 +84,28 @@ class SelectQueryBuilderImpl {
             queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.create('Distinct')),
         });
     }
-    forUpdate() {
+    forUpdate(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForUpdate')),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForUpdate', of ? asArray(of).map(parseTable) : undefined)),
         });
     }
-    forShare() {
+    forShare(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForShare')),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForShare', of ? asArray(of).map(parseTable) : undefined)),
         });
     }
-    forKeyShare() {
+    forKeyShare(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForKeyShare')),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForKeyShare', of ? asArray(of).map(parseTable) : undefined)),
         });
     }
-    forNoKeyUpdate() {
+    forNoKeyUpdate(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForNoKeyUpdate')),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForNoKeyUpdate', of ? asArray(of).map(parseTable) : undefined)),
         });
     }
     skipLocked() {
@@ -175,13 +177,13 @@ class SelectQueryBuilderImpl {
     limit(limit) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(limit)),
+            queryNode: SelectQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit))),
         });
     }
     offset(offset) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(offset)),
+            queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(parseValueExpression(offset))),
         });
     }
     union(expression) {

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

@@ -8,7 +8,7 @@ import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { UpdateObject, UpdateObjectFactory } 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.
      *
@@ -813,10 +829,10 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * 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.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `UpdateQueryBuilder` with a new output type.
      */
-    $castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
+    $castTo<C>(): UpdateQueryBuilder<DB, UT, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

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) {
@@ -154,8 +154,8 @@ export class UpdateQueryBuilder {
     /**
      * 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.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `UpdateQueryBuilder` with a new output type.
      */
     $castTo() {
         return new UpdateQueryBuilder(this.#props);

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) {
@@ -160,6 +162,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.values);
         }
+        if (node.defaultValues) {
+            this.append(' ');
+            this.append('default values');
+        }
         if (node.onConflict) {
             this.append(' ');
             this.visitNode(node.onConflict);
@@ -346,16 +352,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 +395,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 +578,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 +633,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 +718,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 +746,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 ');
@@ -841,6 +871,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         else {
             this.append(SELECT_MODIFIER_SQL[node.modifier]);
         }
+        if (node.of) {
+            this.append(' of ');
+            this.compileList(node.of, ', ');
+        }
     }
     visitCreateType(node) {
         this.append('create type ');
@@ -1004,6 +1038,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 +1128,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',