kysely 0.21.6 → 0.22.0

package/dist/cjs/query-builder/{function-builder.d.ts → function-module.d.ts}

@@ -1,5 +1,5 @@
 import { StringReference, ExtractTypeFromReferenceExpression } from '../parser/reference-parser.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -32,38 +32,8 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
  * having count("pet"."id") > $1
  * ```
  */
-export declare class FunctionBuilder<DB, TB extends keyof DB> {
-    #private;
+export declare class FunctionModule<DB, TB extends keyof DB> {
     constructor();
-    /**
-     * Calls the `max` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { max } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(max('price').as('max_price'))
-     *   .execute()
-     * ```
-     */
-    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
-    /**
-     * Calls the `min` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { min } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(min('price').as('min_price'))
-     *   .execute()
-     * ```
-     *
-     */
-    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
     /**
      * Calls the `avg` function for the column given as the argument.
      *
@@ -85,9 +55,9 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    avg<O extends number | string, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
+    avg<O extends number | string, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `sum` function for the column given as the argument.
+     * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
      * will be `number | string | bigint` by default. This is because Kysely can't
@@ -100,19 +70,56 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { sum } = db.fn
+     * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price').as('total_price'))
+     *   .select(count<number>('id').as('num_toys'))
+     *   .execute()
+     * ```
+     *
+     * You can limit column range:
+     *
+     * ```ts
+     * db.selectFrom('toy')
+     *   .select(qb => qb.fn.count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */
-    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
+    count<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `count` function for the column given as the argument.
+     * Calls the `max` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max('price').as('max_price'))
+     *   .execute()
+     * ```
+     */
+    max<C extends StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    /**
+     * Calls the `min` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min('price').as('min_price'))
+     *   .execute()
+     * ```
+     *
+     */
+    min<C extends StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    /**
+     * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string |bigint` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -122,12 +129,12 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { count } = db.fn
+     * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('id').as('num_toys'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
-    count<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
+    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
 }

package/dist/cjs/query-builder/{function-builder.js → function-module.js}

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionBuilder = void 0;
-const raw_node_js_1 = require("../operation-node/raw-node.js");
+exports.FunctionModule = void 0;
+const aggregate_function_node_js_1 = require("../operation-node/aggregate-function-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
-const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
-const query_id_js_1 = require("../util/query-id.js");
+const aggregate_function_builder_js_1 = require("./aggregate-function-builder.js");
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -37,46 +36,13 @@ const query_id_js_1 = require("../util/query-id.js");
  * having count("pet"."id") > $1
  * ```
  */
-class FunctionBuilder {
+class FunctionModule {
     constructor() {
-        this.min = this.min.bind(this);
-        this.max = this.max.bind(this);
         this.avg = this.avg.bind(this);
-        this.sum = this.sum.bind(this);
         this.count = this.count.bind(this);
-    }
-    /**
-     * Calls the `max` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { max } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(max('price').as('max_price'))
-     *   .execute()
-     * ```
-     */
-    max(column) {
-        return this.#oneArgFunction('max', column);
-    }
-    /**
-     * Calls the `min` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { min } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(min('price').as('min_price'))
-     *   .execute()
-     * ```
-     *
-     */
-    min(column) {
-        return this.#oneArgFunction('min', column);
+        this.max = this.max.bind(this);
+        this.min = this.min.bind(this);
+        this.sum = this.sum.bind(this);
     }
     /**
      * Calls the `avg` function for the column given as the argument.
@@ -100,10 +66,12 @@ class FunctionBuilder {
      * ```
      */
     avg(column) {
-        return this.#oneArgFunction('avg', column);
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('avg', (0, reference_parser_js_1.parseStringReference)(column)),
+        });
     }
     /**
-     * Calls the `sum` function for the column given as the argument.
+     * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
      * will be `number | string | bigint` by default. This is because Kysely can't
@@ -116,21 +84,68 @@ class FunctionBuilder {
      * the type as the first type argument:
      *
      * ```ts
-     * const { sum } = db.fn
+     * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price').as('total_price'))
+     *   .select(count<number>('id').as('num_toys'))
+     *   .execute()
+     * ```
+     *
+     * You can limit column range:
+     *
+     * ```ts
+     * db.selectFrom('toy')
+     *   .select(qb => qb.fn.count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */
-    sum(column) {
-        return this.#oneArgFunction('sum', column);
+    count(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('count', (0, reference_parser_js_1.parseStringReference)(column)),
+        });
     }
     /**
-     * Calls the `count` function for the column given as the argument.
+     * Calls the `max` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max('price').as('max_price'))
+     *   .execute()
+     * ```
+     */
+    max(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('max', (0, reference_parser_js_1.parseStringReference)(column)),
+        });
+    }
+    /**
+     * Calls the `min` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min('price').as('min_price'))
+     *   .execute()
+     * ```
+     *
+     */
+    min(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('min', (0, reference_parser_js_1.parseStringReference)(column)),
+        });
+    }
+    /**
+     * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string |bigint` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -140,21 +155,17 @@ class FunctionBuilder {
      * the type as the first type argument:
      *
      * ```ts
-     * const { count } = db.fn
+     * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('id').as('num_toys'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
-    count(column) {
-        return this.#oneArgFunction('count', column);
-    }
-    #oneArgFunction(fn, column) {
-        return new raw_builder_js_1.RawBuilder({
-            queryId: (0, query_id_js_1.createQueryId)(),
-            rawNode: raw_node_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
+    sum(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('sum', (0, reference_parser_js_1.parseStringReference)(column)),
         });
     }
 }
-exports.FunctionBuilder = FunctionBuilder;
+exports.FunctionModule = FunctionModule;

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

@@ -0,0 +1,59 @@
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OverNode } from '../operation-node/over-node.js';
+import { OrderByDirectionExpression } from '../parser/order-by-parser.js';
+import { PartitionByExpression } from '../parser/partition-by-parser.js';
+import { StringReference } from '../parser/reference-parser.js';
+export declare class OverBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
+    #private;
+    constructor(props: OverBuilderProps);
+    /**
+     * Adds an order by clause item inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.orderBy('first_name', 'asc').orderBy('last_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(order by "first_name" asc, "last_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    orderBy(orderBy: StringReference<DB, TB> | DynamicReferenceBuilder<any>, direction?: OrderByDirectionExpression): OverBuilder<DB, TB>;
+    /**
+     * Adds partition by clause item/s inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy(['last_name', 'first_name'])
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name", "first_name") as "average_age"
+     * from "person"
+     * ```
+     */
+    partitionBy(partitionBy: ReadonlyArray<PartitionByExpression<DB, TB>>): OverBuilder<DB, TB>;
+    partitionBy(partitionBy: PartitionByExpression<DB, TB>): OverBuilder<DB, TB>;
+    toOperationNode(): OverNode;
+}
+export interface OverBuilderProps {
+    readonly overNode: OverNode;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverBuilder = void 0;
+const over_node_js_1 = require("../operation-node/over-node.js");
+const order_by_parser_js_1 = require("../parser/order-by-parser.js");
+const partition_by_parser_js_1 = require("../parser/partition-by-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+class OverBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Adds an order by clause item inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.orderBy('first_name', 'asc').orderBy('last_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(order by "first_name" asc, "last_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    orderBy(orderBy, direction) {
+        return new OverBuilder({
+            overNode: over_node_js_1.OverNode.cloneWithOrderByItem(this.#props.overNode, (0, order_by_parser_js_1.parseOrderBy)(orderBy, direction)),
+        });
+    }
+    partitionBy(partitionBy) {
+        return new OverBuilder({
+            overNode: over_node_js_1.OverNode.cloneWithPartitionByItems(this.#props.overNode, (0, partition_by_parser_js_1.parsePartitionBy)(partitionBy)),
+        });
+    }
+    toOperationNode() {
+        return this.#props.overNode;
+    }
+}
+exports.OverBuilder = OverBuilder;
+(0, prevent_await_js_1.preventAwait)(OverBuilder, "don't await OverBuilder instances. They are never executed directly and are always just a part of a query.");

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

@@ -13,13 +13,13 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { GroupByExpression } from '../parser/group-by-parser.js';
-import { UnionExpression } from '../parser/union-parser.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { HavingInterface } from './having-interface.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
+import { SetOperationExpression } from '../parser/set-operation-parser.js';
 export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, OperationNodeSource, Compilable, Explainable {
     #private;
     constructor(props: SelectQueryBuilderProps);
@@ -1202,7 +1202,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    union(expression: UnionExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    union(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union all`.
      *
@@ -1217,7 +1217,67 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    unionAll(expression: UnionExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    unionAll(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `intersect`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .intersect(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    intersect(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `intersect all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .intersectAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    intersectAll(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `except`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .except(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    except(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `except all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .exceptAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    exceptAll(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *

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

@@ -14,10 +14,10 @@ const limit_node_js_1 = require("../operation-node/limit-node.js");
 const offset_node_js_1 = require("../operation-node/offset-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const group_by_parser_js_1 = require("../parser/group-by-parser.js");
-const union_parser_js_1 = require("../parser/union-parser.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const explain_node_js_1 = require("../operation-node/explain-node.js");
+const set_operation_parser_js_1 = require("../parser/set-operation-parser.js");
 class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -472,7 +472,7 @@ class SelectQueryBuilder {
     union(expression) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithUnion(this.#props.queryNode, (0, union_parser_js_1.parseUnion)(expression, false)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('union', expression, false)),
         });
     }
     /**
@@ -492,7 +492,87 @@ class SelectQueryBuilder {
     unionAll(expression) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithUnion(this.#props.queryNode, (0, union_parser_js_1.parseUnion)(expression, true)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('union', expression, true)),
+        });
+    }
+    /**
+     * Combines another select query or raw expression to this query using `intersect`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .intersect(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    intersect(expression) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('intersect', expression, false)),
+        });
+    }
+    /**
+     * Combines another select query or raw expression to this query using `intersect all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .intersectAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    intersectAll(expression) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('intersect', expression, true)),
+        });
+    }
+    /**
+     * Combines another select query or raw expression to this query using `except`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .except(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    except(expression) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('except', expression, false)),
+        });
+    }
+    /**
+     * Combines another select query or raw expression to this query using `except all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .exceptAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    exceptAll(expression) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('except', expression, true)),
         });
     }
     /**

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

@@ -60,7 +60,6 @@ import { ColumnDefinitionNode } from '../operation-node/column-definition-node.j
 import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { UnionNode } from '../operation-node/union-node.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { GeneratedNode } from '../operation-node/generated-node.js';
@@ -74,6 +73,11 @@ import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { ExplainNode } from '../operation-node/explain-node.js';
 import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
 import { DefaultInsertValueNode } from '../operation-node/default-insert-value-node.js';
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+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';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -145,7 +149,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitModifyColumn(node: ModifyColumnNode): void;
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
-    protected visitUnion(node: UnionNode): void;
+    protected visitSetOperation(node: SetOperationNode): void;
     protected visitCreateView(node: CreateViewNode): void;
     protected visitDropView(node: DropViewNode): void;
     protected visitGenerated(node: GeneratedNode): void;
@@ -155,6 +159,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitDropType(node: DropTypeNode): void;
     protected visitExplain(node: ExplainNode): void;
     protected visitDefaultInsertValue(_: DefaultInsertValueNode): void;
+    protected visitAggregateFunction(node: AggregateFunctionNode): void;
+    protected visitOver(node: OverNode): void;
+    protected visitPartitionBy(node: PartitionByNode): void;
+    protected visitPartitionByItem(node: PartitionByItemNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;