kysely 0.8.1 → 0.9.3

package/dist/esm/operation-node/union-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+import { SelectQueryNode } from './select-query-node.js';
+export declare type UnionExpressionNode = SelectQueryNode | RawNode;
+export interface UnionNode extends OperationNode {
+    readonly kind: 'UnionNode';
+    readonly union: UnionExpressionNode;
+    readonly all: boolean;
+}
+/**
+ * @internal
+ */
+export declare const UnionNode: Readonly<{
+    is(node: OperationNode): node is UnionNode;
+    create(union: UnionExpressionNode, all: boolean): UnionNode;
+}>;

package/dist/esm/operation-node/union-node.js

@@ -0,0 +1,16 @@
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const UnionNode = freeze({
+    is(node) {
+        return node.kind === 'UnionNode';
+    },
+    create(union, all) {
+        return freeze({
+            kind: 'UnionNode',
+            union,
+            all,
+        });
+    },
+});

package/dist/esm/parser/group-by-parser.d.ts

@@ -0,0 +1,4 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { ParseContext } from './parse-context.js';
+import { ReferenceExpressionOrList } from './reference-parser.js';
+export declare function parseGroupBy(ctx: ParseContext, orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];

package/dist/esm/parser/group-by-parser.js

@@ -0,0 +1,5 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parseGroupBy(ctx, orderBy) {
+    return parseReferenceExpressionOrList(ctx, orderBy).map(GroupByItemNode.create);
+}

package/dist/esm/parser/insert-values-parser.d.ts

@@ -8,7 +8,7 @@ import { PrimitiveValue } from '../util/object-utils.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
 };
-export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | InsertObject<DB, TB>[];
+export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
 declare type InsertValueExpression<T> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
 export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
 export declare function parseInsertValueExpression(value: InsertValueExpression<PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

package/dist/esm/parser/join-parser.d.ts

@@ -1,8 +1,11 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
-import { ExtractAliasFromTableExpression, TableExpressionDatabaseType } from './table-parser.js';
+import { ExtractAliasFromTableExpression, TableExpressionDatabase } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
+export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyJoinColumn<DB, TB, F> | AnyJoinColumnWithTable<DB, TB, F>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, F> = AnyColumnWithTable<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
 export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
+export {};

package/dist/esm/parser/order-by-parser.d.ts

@@ -1,10 +1,8 @@
-import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
-import { RawNode } from '../operation-node/raw-node.js';
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';
 export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | keyof O;
 export declare type OrderByDirectionExpression = OrderByDirection | AnyRawBuilder;
-export declare function parseOrderByExpression(ctx: ParseContext, expr: OrderByExpression<any, any, any>): ReferenceExpressionNode;
-export declare function parseOrderByDirectionExpression(expr?: OrderByDirectionExpression): RawNode | undefined;
+export declare function parseOrderBy(ctx: ParseContext, orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

package/dist/esm/parser/order-by-parser.js

@@ -1,9 +1,13 @@
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
-export function parseOrderByExpression(ctx, expr) {
+export function parseOrderBy(ctx, orderBy, direction) {
+    return OrderByItemNode.create(parseOrderByExpression(ctx, orderBy), parseOrderByDirectionExpression(direction));
+}
+function parseOrderByExpression(ctx, expr) {
     return parseReferenceExpression(ctx, expr);
 }
-export function parseOrderByDirectionExpression(expr) {
+function parseOrderByDirectionExpression(expr) {
     if (!expr) {
         return undefined;
     }

package/dist/esm/parser/reference-parser.d.ts

@@ -9,7 +9,7 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { ParseContext } from './parse-context.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
-export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReferenceExpression<DB, TB>[];
+export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
 export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;

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

@@ -3,10 +3,10 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { isFunction, isString } from '../util/object-utils.js';
+import { isFunction, isReadonlyArray, isString, } from '../util/object-utils.js';
 import { QueryNode } from '../operation-node/query-node.js';
 export function parseReferenceExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(ctx, it));
     }
     else {

package/dist/esm/parser/table-parser.d.ts

@@ -7,20 +7,20 @@ import { ParseContext } from './parse-context.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AnyAliasedRawBuilder;
-export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type TableExpressionDatabaseType<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type TableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
-export declare type QueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<LeftJoinTableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type LeftJoinTableExpressionDatabaseType<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type LeftJoinTableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? DB[C] : never;
 };
-export declare type QueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<RightJoinTableExpressionDatabaseType<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type RightJoinTableExpressionDatabaseType<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type RightJoinTableExpressionDatabase<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
 };
-export declare type QueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<FullJoinTableExpressionDatabaseType<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type FullJoinTableExpressionDatabaseType<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type FullJoinTableExpressionDatabase<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
 };
 export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;

package/dist/esm/parser/union-parser.d.ts

@@ -0,0 +1,5 @@
+import { UnionNode } from '../operation-node/union-node.js';
+import { QueryBuilder } from '../query-builder/query-builder.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type UnionExpression<DB, O> = QueryBuilder<DB, any, O> | RawBuilder<O>;
+export declare function parseUnion(union: UnionExpression<any, any>, all: boolean): UnionNode;

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

@@ -0,0 +1,9 @@
+import { QueryNode } from '../operation-node/query-node.js';
+import { UnionNode } from '../operation-node/union-node.js';
+export function parseUnion(union, all) {
+    const node = union.toOperationNode();
+    if (QueryNode.isMutating(node)) {
+        throw new Error("can't combine insert, update or delete queries using union");
+    }
+    return UnionNode.create(node, all);
+}

package/dist/esm/parser/value-parser.d.ts

@@ -3,6 +3,6 @@ import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory
 import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
 import { ParseContext } from './parse-context.js';
 export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
-export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ValueExpression<DB, TB, RE>[];
+export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ReadonlyArray<ValueExpression<DB, TB, RE>>;
 export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, any>): ValueExpressionNode;
 export declare function parseValueExpression(ctx: ParseContext, arg: ValueExpression<any, any, any>): ValueExpressionNode;

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

@@ -66,9 +66,9 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * 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` 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
+     * 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
      * know if you've done so.
      *
@@ -88,9 +88,9 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * 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` 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
+     * 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
      * know if you've done so.
      *

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

@@ -79,9 +79,9 @@ export class FunctionBuilder {
      * 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` 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
+     * 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
      * know if you've done so.
      *
@@ -103,9 +103,9 @@ export class FunctionBuilder {
      * 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` 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
+     * 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
      * know if you've done so.
      *

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

@@ -10,13 +10,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -28,7 +28,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -40,7 +40,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -52,7 +52,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -64,7 +64,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -76,7 +76,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -88,7 +88,7 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {

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

@@ -18,6 +18,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { OnConflictConstraintTarget } from '../parser/on-conflict-parser.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { UnionExpression } from '../parser/union-parser.js';
 /**
  * The main query builder class.
  *
@@ -998,7 +999,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     values(row: InsertObject<DB, TB>): QueryBuilder<DB, TB, O>;
-    values(row: InsertObject<DB, TB>[]): QueryBuilder<DB, TB, O>;
+    values(row: ReadonlyArray<InsertObject<DB, TB>>): QueryBuilder<DB, TB, O>;
     /**
      * Ignores the insert if the column or constraint given as the first
      * argument conflicts with the current rows in the database. The
@@ -1553,6 +1554,34 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     offset(offset: number): QueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `union`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .union(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    union(expression: UnionExpression<DB, O>): QueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `union all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .unionAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    unionAll(expression: UnionExpression<DB, O>): QueryBuilder<DB, TB, O>;
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *

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

@@ -3,13 +3,10 @@ import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
 import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
-import { parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
-import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode, } from '../operation-node/query-node.js';
-import { parseOrderByDirectionExpression, parseOrderByExpression, } from '../parser/order-by-parser.js';
-import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { parseOrderBy, } from '../parser/order-by-parser.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { parseUpdateObject, } from '../parser/update-set-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -19,6 +16,8 @@ import { parseOnConflictDoNothing, parseOnConflictUpdate, } from '../parser/on-c
 import { freeze } from '../util/object-utils.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
+import { parseGroupBy } from '../parser/group-by-parser.js';
+import { parseUnion } from '../parser/union-parser.js';
 /**
  * The main query builder class.
  *
@@ -43,7 +42,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseWhereFilter(this.#props.parseContext, args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -101,14 +100,14 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseWhereFilter(this.#props.parseContext, args)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -121,7 +120,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -187,7 +186,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -197,7 +196,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -207,7 +206,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -217,14 +216,14 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     having(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseHavingFilter(this.#props.parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -235,14 +234,14 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orHaving(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseHavingFilter(this.#props.parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -253,7 +252,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -264,7 +263,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -275,7 +274,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -286,7 +285,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -297,7 +296,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     select(selection) {
@@ -714,14 +713,14 @@ export class QueryBuilder {
         assertCanHaveOrderByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, OrderByItemNode.create(parseOrderByExpression(this.#props.parseContext, orderBy), parseOrderByDirectionExpression(direction))),
+            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, parseOrderBy(this.#props.parseContext, orderBy, direction)),
         });
     }
     groupBy(orderBy) {
         assertCanHaveGroupByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseReferenceExpressionOrList(this.#props.parseContext, orderBy).map(GroupByItemNode.create)),
+            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseGroupBy(this.#props.parseContext, orderBy)),
         });
     }
     /**
@@ -776,6 +775,46 @@ export class QueryBuilder {
             queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(offset)),
         });
     }
+    /**
+     * Combines another select query or raw expression to this query using `union`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .union(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    union(expression) {
+        assertCanHaveUnion(this.#props.queryNode);
+        return new QueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithUnion(this.#props.queryNode, parseUnion(expression, false)),
+        });
+    }
+    /**
+     * Combines another select query or raw expression to this query using `union all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .unionAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    unionAll(expression) {
+        assertCanHaveUnion(this.#props.queryNode);
+        return new QueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithUnion(this.#props.queryNode, parseUnion(expression, true)),
+        });
+    }
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -958,7 +997,7 @@ function assertCanHaveUpdates(node) {
 }
 function assertCanHaveReturningClause(node) {
     if (!QueryNode.isMutating(node)) {
-        throw new Error('only an insert, delete and update queries can have a returning clause');
+        throw new Error('only insert, delete and update queries can have a returning clause');
     }
 }
 function assertCanHaveOrderByClause(node) {
@@ -981,3 +1020,8 @@ function assertCanHaveOffset(node) {
         throw new Error('only a select query can have an offset');
     }
 }
+function assertCanHaveUnion(node) {
+    if (!SelectQueryNode.is(node)) {
+        throw new Error('only a select query can have an union');
+    }
+}

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

@@ -1,4 +1,4 @@
 export interface CompiledQuery {
     readonly sql: string;
-    readonly parameters: ReadonlyArray<any>;
+    readonly parameters: ReadonlyArray<unknown>;
 }