kysely 0.26.0 → 0.26.2

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

@@ -1,10 +1,22 @@
 /// <reference types="./with-parser.d.ts" />
-import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 import { createQueryCreator } from './parse-utils.js';
-export function parseCommonTableExpression(name, expression) {
-    const builder = expression(createQueryCreator());
-    return CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
+import { isFunction } from '../util/object-utils.js';
+import { CTEBuilder } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = expression(createQueryCreator()).toOperationNode();
+    if (isFunction(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
+}
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new CTEBuilder({
+            node: CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
+        });
+    };
 }
 function parseCommonTableExpressionName(name) {
     if (name.includes('(')) {

package/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -75,9 +75,9 @@ export interface CamelCasePluginOptions {
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: the table names, the columns,
- * schemas, __everything__. When using the `CamelCasePlugin` Kysely
- * works as if the database was defined in camelCase.
+ * in camelCase in the typescript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
  *
  * There are various options you can give to the plugin to modify
  * the way identifiers are converted. See {@link CamelCasePluginOptions}.

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -1,5 +1,5 @@
 /// <reference types="./camel-case-plugin.d.ts" />
-import { isArrayBufferOrView, isBuffer, isDate, isObject, } from '../../util/object-utils.js';
+import { isPlainObject } from '../../util/object-utils.js';
 import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
@@ -44,9 +44,9 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: the table names, the columns,
- * schemas, __everything__. When using the `CamelCasePlugin` Kysely
- * works as if the database was defined in camelCase.
+ * in camelCase in the typescript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
  *
  * There are various options you can give to the plugin to modify
  * the way identifiers are converted. See {@link CamelCasePluginOptions}.
@@ -110,9 +110,5 @@ export class CamelCasePlugin {
     }
 }
 function canMap(obj, opt) {
-    return (isObject(obj) &&
-        !isDate(obj) &&
-        !isBuffer(obj) &&
-        !isArrayBufferOrView(obj) &&
-        !opt?.maintainNestedObjectKeys);
+    return isPlainObject(obj) && !opt?.maintainNestedObjectKeys;
 }

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.d.ts

@@ -2,6 +2,19 @@ import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
 import { UnknownRow } from '../../util/type-utils.js';
 import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+/**
+ * Parses JSON strings in query results into JSON objects.
+ *
+ * This plugin can be useful with dialects that don't automatically parse
+ * JSON into objects and arrays but return JSON strings instead.
+ *
+ * ```ts
+ * const db = new Kysely<DB>({
+ *   ...
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ */
 export declare class ParseJSONResultsPlugin implements KyselyPlugin {
     /**
      * This is called for each query before it is executed. You can modify the query by

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.js

@@ -1,29 +1,65 @@
 /// <reference types="./parse-json-results-plugin.d.ts" />
-import { isString } from '../../util/object-utils.js';
+import { isPlainObject, isString } from '../../util/object-utils.js';
+/**
+ * Parses JSON strings in query results into JSON objects.
+ *
+ * This plugin can be useful with dialects that don't automatically parse
+ * JSON into objects and arrays but return JSON strings instead.
+ *
+ * ```ts
+ * const db = new Kysely<DB>({
+ *   ...
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ */
 export class ParseJSONResultsPlugin {
     // noop
     transformQuery(args) {
         return args.node;
     }
     async transformResult(args) {
-        const { result } = args;
         return {
             ...args.result,
-            rows: result.rows.map(parseRow),
+            rows: parseArray(args.result.rows),
         };
     }
 }
-function parseRow(row) {
-    return Object.entries(row).reduce((row, [key, value]) => {
-        if (isString(value) && value.match(/^[\[\{]/) != null) {
-            try {
-                value = JSON.parse(value);
-            }
-            catch (err) {
-                // this catch block is intentionally empty.
-            }
+function parseArray(arr) {
+    for (let i = 0; i < arr.length; ++i) {
+        arr[i] = parse(arr[i]);
+    }
+    return arr;
+}
+function parse(obj) {
+    if (isString(obj)) {
+        return parseString(obj);
+    }
+    if (Array.isArray(obj)) {
+        return parseArray(obj);
+    }
+    if (isPlainObject(obj)) {
+        return parseObject(obj);
+    }
+    return obj;
+}
+function parseString(str) {
+    if (maybeJson(str)) {
+        try {
+            return parse(JSON.parse(str));
         }
-        row[key] = value;
-        return row;
-    }, {});
+        catch (err) {
+            // this catch block is intentionally empty.
+        }
+    }
+    return str;
+}
+function maybeJson(value) {
+    return value.match(/^[\[\{]/) != null;
+}
+function parseObject(obj) {
+    for (const key in obj) {
+        obj[key] = parse(obj[key]);
+    }
+    return obj;
 }

package/dist/esm/query-builder/aggregate-function-builder.d.ts

@@ -1,11 +1,12 @@
 import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OverBuilder } from './over-builder.js';
-import { AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
-import { WhereExpressionFactory } from './where-interface.js';
-export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
+import { SqlBool } from '../util/type-utils.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements AliasableExpression<O> {
     #private;
     constructor(props: AggregateFunctionBuilderProps);
     /** @private */
@@ -116,8 +117,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(expression: ExpressionOrFactory<DB, TB, SqlBool>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds a `filter` clause with a nested `where` clause after the function, where
      * both sides of the operator are references to columns.

package/dist/esm/query-builder/aggregate-function-builder.js

@@ -5,7 +5,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { createOverBuilder } from '../parser/parse-utils.js';
-import { parseReferentialComparison, parseFilter, } from '../parser/binary-operation-parser.js';
+import { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
 export class AggregateFunctionBuilder {
     #props;
     constructor(props) {
@@ -73,7 +73,7 @@ export class AggregateFunctionBuilder {
     filterWhere(...args) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseFilter(args)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     /**
@@ -111,7 +111,7 @@ export class AggregateFunctionBuilder {
     filterWhereRef(lhs, op, rhs) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialComparison(lhs, op, rhs)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     /**

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

@@ -3,8 +3,8 @@ import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { freeze } from '../util/object-utils.js';
 import { CaseNode } from '../operation-node/case-node.js';
 import { WhenNode } from '../operation-node/when-node.js';
-import { parseFilter, } from '../parser/binary-operation-parser.js';
-import { parseValueExpression } from '../parser/value-parser.js';
+import { parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
+import { isSafeImmediateValue, parseSafeImmediateValue, parseValueExpression, } from '../parser/value-parser.js';
 export class CaseBuilder {
     #props;
     constructor(props) {
@@ -13,7 +13,7 @@ export class CaseBuilder {
     when(...args) {
         return new CaseThenBuilder({
             ...this.#props,
-            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseFilter(args))),
+            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args))),
         });
     }
 }
@@ -25,7 +25,9 @@ export class CaseThenBuilder {
     then(valueExpression) {
         return new CaseWhenBuilder({
             ...this.#props,
-            node: CaseNode.cloneWithThen(this.#props.node, parseValueExpression(valueExpression)),
+            node: CaseNode.cloneWithThen(this.#props.node, isSafeImmediateValue(valueExpression)
+                ? parseSafeImmediateValue(valueExpression)
+                : parseValueExpression(valueExpression)),
         });
     }
 }
@@ -37,14 +39,16 @@ export class CaseWhenBuilder {
     when(...args) {
         return new CaseThenBuilder({
             ...this.#props,
-            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseFilter(args))),
+            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args))),
         });
     }
     else(valueExpression) {
         return new CaseEndBuilder({
             ...this.#props,
             node: CaseNode.cloneWith(this.#props.node, {
-                else: parseValueExpression(valueExpression),
+                else: isSafeImmediateValue(valueExpression)
+                    ? parseSafeImmediateValue(valueExpression)
+                    : parseValueExpression(valueExpression),
             }),
         });
     }

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

@@ -0,0 +1,20 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export declare class CTEBuilder<N extends string> implements OperationNodeSource {
+    #private;
+    constructor(props: CTEBuilderProps);
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized(): CTEBuilder<N>;
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized(): CTEBuilder<N>;
+    toOperationNode(): CommonTableExpressionNode;
+}
+interface CTEBuilderProps {
+    readonly node: CommonTableExpressionNode;
+}
+export type CTEBuilderCallback<N extends string> = (cte: <N2 extends string>(name: N2) => CTEBuilder<N2>) => CTEBuilder<N>;
+export {};

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

@@ -0,0 +1,36 @@
+/// <reference types="./cte-builder.d.ts" />
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+export class CTEBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: true,
+            }),
+        });
+    }
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: false,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.node;
+    }
+}
+preventAwait(CTEBuilder, "don't await CTEBuilder instances. They are never executed directly and are always just a part of a query.");

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

@@ -6,12 +6,12 @@ import { SelectExpression, SelectArg } from '../parser/select-parser.js';
 import { ReturningAllRow, 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 } from '../util/type-utils.js';
+import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { WhereExpressionFactory, WhereInterface } from './where-interface.js';
+import { WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
@@ -22,6 +22,7 @@ import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -78,24 +79,53 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "OR where", 30) -->
+     * <!-- siteExample("where", "Object filter", 30) -->
      *
-     * To combine conditions using `OR`, you can use the expression builder:
+     * You can use the `and` function to create a simple equality
+     * filter using an object
      *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where(({ or, and, cmpr }) => or([
-     *     and([
-     *       cmpr('first_name', '=', 'Jennifer'),
-     *       cmpr('last_name', '=', 'Aniston')
-     *     ]),
-     *     and([
-     *       cmpr('first_name', '=', 'Sylvester'),
-     *       cmpr('last_name', '=', 'Stallone')
-     *     ])
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: eb.ref('first_name')
+     *   }))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = "first_name"
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 40) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
      *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
      *   .execute()
      * ```
      *
@@ -105,19 +135,23 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select *
      * from "person"
      * where (
-     *   ("first_name" = $1 AND "last_name" = $2)
-     *   OR
-     *   ("first_name" = $3 AND "last_name" = $4)
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
      * const firstName: string | undefined = 'Jennifer'
      * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
      *
      * let query = db
      *   .selectFrom('person')
@@ -133,6 +167,23 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -185,7 +236,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "Complex where clause", 50) -->
+     * <!-- siteExample("where", "Complex where clause", 60) -->
      *
      * For complex `where` expressions you can pass in a single callback and
      * use the `ExpressionBuilder` to build your expression:
@@ -197,10 +248,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
      *       selectFrom('pet')
@@ -275,8 +326,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
-    where(factory: WhereExpressionFactory<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
-    where(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -821,7 +871,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): O2 extends DeleteResult ? DeleteQueryBuilder<DB, TB, DeleteResult> : O2 extends O & infer E ? DeleteQueryBuilder<DB, TB, O & Partial<E>> : DeleteQueryBuilder<DB, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<any, any, O2>): O2 extends DeleteResult ? DeleteQueryBuilder<DB, TB, DeleteResult> : O2 extends O & infer E ? DeleteQueryBuilder<DB, TB, O & Partial<E>> : DeleteQueryBuilder<DB, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

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

@@ -10,7 +10,7 @@ import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { parseOrderBy, } from '../parser/order-by-parser.js';
-import { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 export class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -19,13 +19,13 @@ export class DeleteQueryBuilder {
     where(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseFilter(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     clearWhere() {
@@ -113,7 +113,7 @@ export class DeleteQueryBuilder {
     orderBy(orderBy, direction) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, parseOrderBy(orderBy, direction)),
+            queryNode: DeleteQueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy([orderBy, direction])),
         });
     }
     /**

package/dist/esm/query-builder/function-module.d.ts

@@ -1,9 +1,12 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { Expression } from '../expression/expression.js';
 import { CoalesceReferenceExpressionList } from '../parser/coalesce-parser.js';
-import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference, ExtractTypeFromStringReference } from '../parser/reference-parser.js';
+import { KyselyTypeError } from '../util/type-error.js';
 import { Equals, IsAny } from '../util/type-utils.js';
 import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
+import { SelectQueryBuilder } from './select-query-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -109,7 +112,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      */
     agg<O>(name: string, args?: ReadonlyArray<ReferenceExpression<DB, TB>>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `avg` function for the column given as the argument.
+     * Calls the `avg` function for the column or expression given as the argument.
      *
      * This sql function calculates the average value for a given column.
      *
@@ -229,7 +232,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      */
     coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<DB, TB, CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
     /**
-     * Calls the `count` function for the column given as the argument.
+     * Calls the `count` function for the column or expression given as the argument.
      *
      * When called with a column as argument, this sql function counts the number of rows where there
      * is a non-null value in that column.
@@ -351,7 +354,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     countAll<O extends number | string | bigint, T extends TB = TB>(table: T): AggregateFunctionBuilder<DB, TB, O>;
     countAll<O extends number | string | bigint>(): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `max` function for the column given as the argument.
+     * Calls the `max` function for the column or expression given as the argument.
      *
      * This sql function calculates the maximum value for a given column.
      *
@@ -399,7 +402,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     max<O extends number | string | bigint | null = any, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: OutputBoundStringReference<DB, TB, C, O>): StringReferenceBoundAggregateFunctionBuilder<DB, TB, C, O>;
     max<O extends number | string | bigint | null = number | string | bigint>(column: DynamicReferenceBuilder): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `min` function for the column given as the argument.
+     * Calls the `min` function for the column or expression given as the argument.
      *
      * This sql function calculates the minimum value for a given column.
      *
@@ -447,7 +450,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     min<O extends number | string | bigint | null = any, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: OutputBoundStringReference<DB, TB, C, O>): StringReferenceBoundAggregateFunctionBuilder<DB, TB, C, O>;
     min<O extends number | string | bigint | null = number | string | bigint>(column: DynamicReferenceBuilder): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `sum` function for the column given as the argument.
+     * Calls the `sum` function for the column or expression given as the argument.
      *
      * This sql function sums the values of a given column.
      *
@@ -505,6 +508,38 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ```
      */
     sum<O extends number | string | bigint | null = number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Calls the `any` function for the column or expression given as the argument.
+     *
+     * The argument must be a subquery or evaluate to an array.
+     *
+     * ### Examples
+     *
+     * In the following example, `nicknames` is assumed to be a column of type `string[]`:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where((eb) => eb(
+     *     eb.val('Jen'), '=', eb.fn.any('person.nicknames')
+     *   ))
+     * ```
+     *
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   "person".*
+     * from
+     *   "person"
+     * where
+     *  $1 = any("person"."nicknames")
+     * ```
+     */
+    any<RE extends StringReference<DB, TB>>(expr: RE): Exclude<ExtractTypeFromStringReference<DB, TB, RE>, null> extends ReadonlyArray<infer I> ? ExpressionWrapper<DB, TB, I> : KyselyTypeError<'any(expr) call failed: expr must be an array'>;
+    any<T>(subquery: SelectQueryBuilder<any, any, Record<string, T>>): ExpressionWrapper<DB, TB, T>;
+    any<T>(expr: Expression<ReadonlyArray<T>>): ExpressionWrapper<DB, TB, T>;
 }
 export declare function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<DB, TB>;
 type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsAny<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;