kysely 0.22.0 → 0.23.1

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

@@ -3,10 +3,9 @@ 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 } from '../parser/select-parser.js';
-import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -18,10 +17,11 @@ import { WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
-import { AliasedQueryBuilder } from './select-query-builder.js';
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { Explainable, ExplainFormat } from '../util/explainable.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, Explainable {
+import { AliasedExpression, Expression } from '../expression/expression.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ExistsExpression } from '../parser/unary-operation-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 {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -208,16 +208,16 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
     where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(expression: Expression<any>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
      *
      * 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 correclated subqueries.
+     * expecially useful with joins and correlated subqueries.
      *
      * ### Examples
      *
@@ -262,7 +262,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -326,15 +326,15 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
     orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
-    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(expression: Expression<any>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -401,11 +401,11 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `or exists` clause.
+     * Just like {@link whereExists} but creates an `or exists` clause.
      */
     orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `or not exists` clause.
+     * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
@@ -789,7 +789,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, UT, TB, O>;
     toOperationNode(): UpdateQueryNode;
-    compile(): CompiledQuery;
+    compile(): CompiledQuery<O>;
     /**
      * Executes the query and returns an array of rows.
      *
@@ -827,29 +827,29 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * explain format=json update `person` set `first_name` = ?, `last_name` = ? where `id` = ?
      * ```
      */
-    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<ER[]>;
 }
 export interface UpdateQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: UpdateQueryNode;
     readonly executor: QueryExecutor;
 }
-export declare type UpdateQueryBuilderWithInnerJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? UpdateQueryBuilder<DB, UT, TB | TE, O> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+export declare type UpdateQueryBuilderWithInnerJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? UpdateQueryBuilder<DB, UT, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
 declare type InnerJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? UpdateQueryBuilder<InnerJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, R>, UT, TB | A, O>;
 declare type InnerJoinedDB<DB, A extends string, R> = {
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
 };
-export declare type UpdateQueryBuilderWithLeftJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+export declare type UpdateQueryBuilderWithLeftJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
 declare type LeftJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? UpdateQueryBuilder<LeftJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, Nullable<R>>, UT, TB | A, O>;
 declare type LeftJoinedDB<DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
 };
-export declare type UpdateQueryBuilderWithRightJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+export declare type UpdateQueryBuilderWithRightJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
 declare type RightJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<RightJoinedDB<DB, TB, A, R>, UT, TB | A, O>;
 declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 };
-export declare type UpdateQueryBuilderWithFullJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+export declare type UpdateQueryBuilderWithFullJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
 declare type OuterJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, UT, TB | A, O>;
 declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;

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

@@ -2,7 +2,6 @@
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
-import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { parseUpdateObject, } from '../parser/update-set-parser.js';
@@ -11,6 +10,8 @@ import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
 import { NoResultError } from './no-result-error.js';
 import { ExplainNode } from '../operation-node/explain-node.js';
+import { parseReferentialFilter, parseWhere, } from '../parser/binary-operation-parser.js';
+import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 export class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -19,49 +20,49 @@ export class UpdateQueryBuilder {
     where(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhere(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(args)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhere(args)),
         });
     }
     orWhereRef(lhs, op, rhs) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     whereExists(arg) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExists(arg)),
         });
     }
     whereNotExists(arg) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExists(arg)),
         });
     }
     orWhereExists(arg) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExists(arg)),
         });
     }
     orWhereNotExists(arg) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExists(arg)),
         });
     }
     from(from) {
@@ -298,15 +299,17 @@ export class UpdateQueryBuilder {
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
     async execute() {
-        const compildQuery = this.compile();
-        const query = compildQuery.query;
-        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        const compiledQuery = this.compile();
+        const query = compiledQuery.query;
+        const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
         if (this.#props.executor.adapter.supportsReturning && query.returning) {
             return result.rows;
         }
-        else {
-            return [new UpdateResult(result.numUpdatedOrDeletedRows)];
-        }
+        return [
+            new UpdateResult(
+            // TODO: remove numUpdatedOrDeletedRows.
+            (result.numAffectedRows ?? result.numUpdatedOrDeletedRows)),
+        ];
     }
     /**
      * Executes the query and returns the first result or undefined if
@@ -351,7 +354,7 @@ export class UpdateQueryBuilder {
     async explain(format, options) {
         const builder = new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options)),
+            queryNode: UpdateQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options?.toOperationNode())),
         });
         return await builder.execute();
     }

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

@@ -1,6 +1,7 @@
-import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
+import { Expression } from '../expression/expression.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
 export interface WhereInterface<DB, TB extends keyof DB> {
     /**
      * Adds a `where` clause to the query.
@@ -186,16 +187,16 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
     where(grouper: WhereGrouper<DB, TB>): WhereInterface<DB, TB>;
-    where(raw: AnyRawBuilder): WhereInterface<DB, TB>;
+    where(expression: Expression<any>): WhereInterface<DB, TB>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
      *
      * 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 correclated subqueries.
+     * expecially useful with joins and correlated subqueries.
      *
      * ### Examples
      *
@@ -240,7 +241,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -304,15 +305,15 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
     orWhere(grouper: WhereGrouper<DB, TB>): WhereInterface<DB, TB>;
-    orWhere(raw: AnyRawBuilder): WhereInterface<DB, TB>;
+    orWhere(expression: Expression<any>): WhereInterface<DB, TB>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -379,11 +380,11 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      */
     whereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Just like {@link whereExists} but creates a `or exists` clause.
+     * Just like {@link whereExists} but creates an `or exists` clause.
      */
     orWhereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Just like {@link whereExists} but creates a `or not exists` clause.
+     * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
 }

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

@@ -1,5 +1,5 @@
 import { RootOperationNode } from './query-compiler.js';
-export interface CompiledQuery {
+export interface CompiledQuery<O = unknown> {
     readonly query: RootOperationNode;
     readonly sql: string;
     readonly parameters: ReadonlyArray<unknown>;

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

@@ -9,7 +9,6 @@ import { DataTypeNode } from '../operation-node/data-type-node.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
-import { FilterNode } from '../operation-node/filter-node.js';
 import { FromNode } from '../operation-node/from-node.js';
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { GroupByNode } from '../operation-node/group-by-node.js';
@@ -78,6 +77,8 @@ import { OverNode } from '../operation-node/over-node.js';
 import { PartitionByNode } from '../operation-node/partition-by-node.js';
 import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
 import { SetOperationNode } from '../operation-node/set-operation-node.js';
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -87,7 +88,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitFrom(node: FromNode): void;
     protected visitSelection(node: SelectionNode): void;
     protected visitColumn(node: ColumnNode): void;
-    protected compileDistinctOn(selections: ReadonlyArray<SelectionNode>): void;
+    protected compileDistinctOn(expressions: ReadonlyArray<OperationNode>): void;
     protected compileList(nodes: ReadonlyArray<OperationNode>, separator?: string): void;
     protected visitWhere(node: WhereNode): void;
     protected visitHaving(node: HavingNode): void;
@@ -100,7 +101,6 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitSelectAll(_: SelectAllNode): void;
     protected visitIdentifier(node: IdentifierNode): void;
     protected compileUnwrappedIdentifier(node: IdentifierNode): void;
-    protected visitFilter(node: FilterNode): void;
     protected visitAnd(node: AndNode): void;
     protected visitOr(node: OrNode): void;
     protected visitValue(node: ValueNode): void;
@@ -163,6 +163,8 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitOver(node: OverNode): void;
     protected visitPartitionBy(node: PartitionByNode): void;
     protected visitPartitionByItem(node: PartitionByItemNode): void;
+    protected visitBinaryOperation(node: BinaryOperationNode): void;
+    protected visitUnaryOperation(node: UnaryOperationNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -2,7 +2,7 @@
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
+import { freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { SetOperationNode } from '../operation-node/set-operation-node.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
@@ -41,8 +41,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append('select ');
-        if (node.distinctOnSelections) {
-            this.compileDistinctOn(node.distinctOnSelections);
+        if (node.distinctOn) {
+            this.compileDistinctOn(node.distinctOn);
             this.append(' ');
         }
         if (node.frontModifiers && node.frontModifiers.length > 0) {
@@ -104,16 +104,16 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     visitColumn(node) {
         this.visitNode(node.column);
     }
-    compileDistinctOn(selections) {
+    compileDistinctOn(expressions) {
         this.append('distinct on (');
-        this.compileList(selections);
+        this.compileList(expressions);
         this.append(')');
     }
     compileList(nodes, separator = ', ') {
-        const lastNode = getLast(nodes);
-        for (const node of nodes) {
-            this.visitNode(node);
-            if (node !== lastNode) {
+        const lastIndex = nodes.length - 1;
+        for (let i = 0; i <= lastIndex; i++) {
+            this.visitNode(nodes[i]);
+            if (i < lastIndex) {
                 this.append(separator);
             }
         }
@@ -241,15 +241,6 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.append(this.sanitizeIdentifier(node.name));
     }
-    visitFilter(node) {
-        if (node.left) {
-            this.visitNode(node.left);
-            this.append(' ');
-        }
-        this.visitNode(node.op);
-        this.append(' ');
-        this.visitNode(node.right);
-    }
     visitAnd(node) {
         this.visitNode(node.left);
         this.append(' and ');
@@ -326,7 +317,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitCreateTable(node) {
         this.append('create ');
-        if (node.frontModifiers) {
+        if (node.frontModifiers && node.frontModifiers.length > 0) {
             this.compileList(node.frontModifiers, ' ');
             this.append(' ');
         }
@@ -345,7 +336,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on commit ');
             this.append(node.onCommit);
         }
-        if (node.endModifiers) {
+        if (node.endModifiers && node.endModifiers.length > 0) {
             this.append(' ');
             this.compileList(node.endModifiers, ' ');
         }
@@ -357,6 +348,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.unsigned) {
             this.append(' unsigned');
         }
+        if (node.frontModifiers && node.frontModifiers.length > 0) {
+            this.append(' ');
+            this.compileList(node.frontModifiers, ' ');
+        }
         if (node.generated) {
             this.append(' ');
             this.visitNode(node.generated);
@@ -386,6 +381,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.check);
         }
+        if (node.endModifiers && node.endModifiers.length > 0) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
+        }
     }
     getAutoIncrement() {
         return 'auto_increment';
@@ -666,20 +665,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.dropConstraint) {
             this.visitNode(node.dropConstraint);
         }
-        if (node.renameColumn) {
-            this.visitNode(node.renameColumn);
-        }
-        if (node.addColumn) {
-            this.visitNode(node.addColumn);
-        }
-        if (node.dropColumn) {
-            this.visitNode(node.dropColumn);
-        }
-        if (node.alterColumn) {
-            this.visitNode(node.alterColumn);
-        }
-        if (node.modifyColumn) {
-            this.visitNode(node.modifyColumn);
+        if (node.columnAlterations) {
+            this.compileList(node.columnAlterations);
         }
     }
     visitAddColumn(node) {
@@ -870,6 +857,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.visitNode(node.column);
         this.append(')');
+        if (node.filter) {
+            this.append(' filter(');
+            this.visitNode(node.filter);
+            this.append(')');
+        }
         if (node.over) {
             this.append(' ');
             this.visitNode(node.over);
@@ -895,6 +887,18 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     visitPartitionByItem(node) {
         this.visitNode(node.partitionBy);
     }
+    visitBinaryOperation(node) {
+        this.visitNode(node.leftOperand);
+        this.append(' ');
+        this.visitNode(node.operator);
+        this.append(' ');
+        this.visitNode(node.rightOperand);
+    }
+    visitUnaryOperation(node) {
+        this.visitNode(node.operator);
+        this.append(' ');
+        this.visitNode(node.operand);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/esm/query-executor/query-executor-base.js

@@ -1,6 +1,7 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { Deferred } from '../util/deferred.js';
+import { logOnce } from '../util/log-once.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
     #plugins;
@@ -32,7 +33,10 @@ export class QueryExecutorBase {
     async executeQuery(compiledQuery, queryId) {
         return await this.provideConnection(async (connection) => {
             const result = await connection.executeQuery(compiledQuery);
-            return this.#transformResult(result, queryId);
+            const transformedResult = await this.#transformResult(result, queryId);
+            // TODO: remove.
+            warnOfOutdatedDriverOrPlugins(result, transformedResult);
+            return transformedResult;
         });
     }
     async *stream(compiledQuery, chunkSize, queryId) {
@@ -60,3 +64,14 @@ export class QueryExecutorBase {
         return result;
     }
 }
+// TODO: remove.
+function warnOfOutdatedDriverOrPlugins(result, transformedResult) {
+    const { numAffectedRows } = result;
+    if ((numAffectedRows === undefined &&
+        result.numUpdatedOrDeletedRows === undefined) ||
+        (numAffectedRows !== undefined &&
+            transformedResult.numAffectedRows !== undefined)) {
+        return;
+    }
+    logOnce('kysely:warning: outdated driver/plugin detected! QueryResult.numUpdatedOrDeletedRows is deprecated and will be removed in a future release.');
+}