kysely 0.21.6 → 0.22.0

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -0,0 +1,19 @@
+import { OperationNode } from './operation-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { PartitionByItemNode } from './partition-by-item-node.js';
+import { PartitionByNode } from './partition-by-node.js';
+export interface OverNode extends OperationNode {
+    readonly kind: 'OverNode';
+    readonly orderBy?: OrderByNode;
+    readonly partitionBy?: PartitionByNode;
+}
+/**
+ * @internal
+ */
+export declare const OverNode: Readonly<{
+    is(node: OperationNode): node is OverNode;
+    create(): OverNode;
+    cloneWithOrderByItem(overNode: OverNode, item: OrderByItemNode): OverNode;
+    cloneWithPartitionByItems(overNode: OverNode, items: ReadonlyArray<PartitionByItemNode>): OverNode;
+}>;

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

@@ -0,0 +1,33 @@
+/// <reference types="./over-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { OrderByNode } from './order-by-node.js';
+import { PartitionByNode } from './partition-by-node.js';
+/**
+ * @internal
+ */
+export const OverNode = freeze({
+    is(node) {
+        return node.kind === 'OverNode';
+    },
+    create() {
+        return freeze({
+            kind: 'OverNode',
+        });
+    },
+    cloneWithOrderByItem(overNode, item) {
+        return freeze({
+            ...overNode,
+            orderBy: overNode.orderBy
+                ? OrderByNode.cloneWithItem(overNode.orderBy, item)
+                : OrderByNode.create(item),
+        });
+    },
+    cloneWithPartitionByItems(overNode, items) {
+        return freeze({
+            ...overNode,
+            partitionBy: overNode.partitionBy
+                ? PartitionByNode.cloneWithItems(overNode.partitionBy, items)
+                : PartitionByNode.create(items),
+        });
+    },
+});

package/dist/esm/operation-node/partition-by-item-node.d.ts

@@ -0,0 +1,14 @@
+import { ColumnNode } from './column-node.js';
+import { OperationNode } from './operation-node.js';
+import { ReferenceNode } from './reference-node.js';
+export interface PartitionByItemNode extends OperationNode {
+    readonly kind: 'PartitionByItemNode';
+    readonly partitionBy: ColumnNode | ReferenceNode;
+}
+/**
+ * @internal
+ */
+export declare const PartitionByItemNode: Readonly<{
+    is(node: OperationNode): node is PartitionByItemNode;
+    create(partitionBy: ColumnNode | ReferenceNode): PartitionByItemNode;
+}>;

package/dist/esm/operation-node/partition-by-item-node.js

@@ -0,0 +1,16 @@
+/// <reference types="./partition-by-item-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const PartitionByItemNode = freeze({
+    is(node) {
+        return node.kind === 'PartitionByItemNode';
+    },
+    create(partitionBy) {
+        return freeze({
+            kind: 'PartitionByItemNode',
+            partitionBy,
+        });
+    },
+});

package/dist/esm/operation-node/partition-by-node.d.ts

@@ -0,0 +1,14 @@
+import { PartitionByItemNode } from './partition-by-item-node.js';
+import { OperationNode } from './operation-node.js';
+export interface PartitionByNode extends OperationNode {
+    readonly kind: 'PartitionByNode';
+    readonly items: ReadonlyArray<PartitionByItemNode>;
+}
+/**
+ * @internal
+ */
+export declare const PartitionByNode: Readonly<{
+    is(node: OperationNode): node is PartitionByNode;
+    create(items: ReadonlyArray<PartitionByItemNode>): PartitionByNode;
+    cloneWithItems(partitionBy: PartitionByNode, items: ReadonlyArray<PartitionByItemNode>): PartitionByNode;
+}>;

package/dist/esm/operation-node/partition-by-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./partition-by-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const PartitionByNode = freeze({
+    is(node) {
+        return node.kind === 'PartitionByNode';
+    },
+    create(items) {
+        return freeze({
+            kind: 'PartitionByNode',
+            items: freeze(items),
+        });
+    },
+    cloneWithItems(partitionBy, items) {
+        return freeze({
+            ...partitionBy,
+            items: freeze([...partitionBy.items, ...items]),
+        });
+    },
+});

package/dist/esm/operation-node/select-query-node.d.ts

@@ -12,9 +12,9 @@ import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
-import { UnionNode } from './union-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { ExplainNode } from './explain-node.js';
+import { SetOperationNode } from './set-operation-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
@@ -30,8 +30,8 @@ export interface SelectQueryNode extends OperationNode {
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
     readonly having?: HavingNode;
-    readonly union?: ReadonlyArray<UnionNode>;
     readonly explain?: ExplainNode;
+    readonly setOperations?: ReadonlyArray<SetOperationNode>;
 }
 /**
  * @internal
@@ -49,6 +49,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
+    cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -94,12 +94,12 @@ export const SelectQueryNode = freeze({
                 : HavingNode.create(filter),
         });
     },
-    cloneWithUnion(selectNode, union) {
+    cloneWithSetOperation(selectNode, setOperation) {
         return freeze({
             ...selectNode,
-            union: selectNode.union
-                ? freeze([...selectNode.union, union])
-                : freeze([union]),
+            setOperations: selectNode.setOperations
+                ? freeze([...selectNode.setOperations, setOperation])
+                : freeze([setOperation]),
         });
     },
     cloneWithExplain(selectNode, explain) {

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

@@ -0,0 +1,18 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+import { SelectQueryNode } from './select-query-node.js';
+export declare type SetOperationExpressionNode = SelectQueryNode | RawNode;
+export declare type SetOperator = 'union' | 'intersect' | 'except';
+export interface SetOperationNode extends OperationNode {
+    kind: 'SetOperationNode';
+    operator: SetOperator;
+    expression: SetOperationExpressionNode;
+    all: boolean;
+}
+/**
+ * @internal
+ */
+export declare const SetOperationNode: Readonly<{
+    is(node: OperationNode): node is SetOperationNode;
+    create(operator: SetOperator, expression: SetOperationExpressionNode, all: boolean): SetOperationNode;
+}>;

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

@@ -0,0 +1,18 @@
+/// <reference types="./set-operation-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const SetOperationNode = freeze({
+    is(node) {
+        return node.kind === 'SetOperationNode';
+    },
+    create(operator, expression, all) {
+        return freeze({
+            kind: 'SetOperationNode',
+            operator,
+            expression,
+            all,
+        });
+    },
+});

package/dist/esm/operation-node/value-list-node.d.ts

@@ -1,10 +1,11 @@
+import { AggregateFunctionNode } from './aggregate-function-node.js';
 import { DefaultInsertValueNode } from './default-insert-value-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferenceNode } from './reference-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { ValueNode } from './value-node.js';
-export declare type ListNodeItem = ValueNode | ReferenceNode | DefaultInsertValueNode | SelectQueryNode | RawNode;
+export declare type ListNodeItem = ValueNode | ReferenceNode | DefaultInsertValueNode | SelectQueryNode | RawNode | AggregateFunctionNode;
 export interface ValueListNode extends OperationNode {
     readonly kind: 'ValueListNode';
     readonly values: ReadonlyArray<ListNodeItem>;

package/dist/esm/parser/complex-expression-parser.d.ts

@@ -1,10 +1,12 @@
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { AggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-export declare type ComplexExpression<DB, TB extends keyof DB, V = any> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | RawBuilder<V> | RawBuilderFactory<DB, TB, V>;
-export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
-export declare function parseComplexExpression(exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory, AggregateFunctionBuilderFactory, AliasedAggregateFunctionBuilderFactory, AnyAliasedAggregateFunctionBuilder } from '../util/type-utils.js';
+export declare type ComplexExpression<DB, TB extends keyof DB, V = any> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | RawBuilder<V> | RawBuilderFactory<DB, TB, V> | AggregateFunctionBuilder<DB, TB, V> | AggregateFunctionBuilderFactory<DB, TB, V>;
+export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB> | AnyAliasedAggregateFunctionBuilder | AliasedAggregateFunctionBuilderFactory<DB, TB>;
+export declare function parseComplexExpression(exp: ComplexExpression<any, any>): SelectQueryNode | RawNode | AggregateFunctionNode;
 export declare function parseAliasedComplexExpression(exp: AliasedComplexExpression<any, any>): AliasNode;
 export declare function isComplexExpression(obj: unknown): obj is ComplexExpression<any, any>;

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

@@ -2,4 +2,4 @@ import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
 export declare type GroupByExpressionOrList<DB, TB extends keyof DB, O> = ReadonlyArray<GroupByExpression<DB, TB, O>> | GroupByExpression<DB, TB, O>;
-export declare function parseGroupBy(orderBy: GroupByExpressionOrList<any, any, any>): GroupByItemNode[];
+export declare function parseGroupBy(groupBy: GroupByExpressionOrList<any, any, any>): GroupByItemNode[];

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

@@ -1,6 +1,6 @@
 /// <reference types="./group-by-parser.d.ts" />
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { parseReferenceExpressionOrList, } from './reference-parser.js';
-export function parseGroupBy(orderBy) {
-    return parseReferenceExpressionOrList(orderBy).map(GroupByItemNode.create);
+export function parseGroupBy(groupBy) {
+    return parseReferenceExpressionOrList(groupBy).map(GroupByItemNode.create);
 }

package/dist/esm/parser/parse-utils.d.ts

@@ -1,6 +1,7 @@
 import { JoinType } from '../operation-node/join-node.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { TableExpression } from './table-parser.js';
@@ -8,3 +9,4 @@ export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any,
 export declare function createExpressionBuilder(): ExpressionBuilder<any, any>;
 export declare function createQueryCreator(): QueryCreator<any>;
 export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+export declare function createOverBuilder(): OverBuilder<any, any>;

package/dist/esm/parser/parse-utils.js

@@ -1,8 +1,10 @@
 /// <reference types="./parse-utils.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
+import { OverNode } from '../operation-node/over-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
@@ -30,3 +32,8 @@ export function createJoinBuilder(joinType, table) {
         joinNode: JoinNode.create(joinType, parseTableExpression(table)),
     });
 }
+export function createOverBuilder() {
+    return new OverBuilder({
+        overNode: OverNode.create(),
+    });
+}

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

@@ -0,0 +1,6 @@
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { StringReference } from './reference-parser.js';
+export declare type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
+export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

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

@@ -0,0 +1,6 @@
+/// <reference types="./partition-by-parser.d.ts" />
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parsePartitionBy(partitionBy) {
+    return parseReferenceExpressionOrList(partitionBy).map(PartitionByItemNode.create);
+}

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

@@ -8,10 +8,11 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
+import { AggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<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 ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : unknown;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends AggregateFunctionBuilder<any, any, infer O> ? O : RE extends (qb: any) => AggregateFunctionBuilder<any, any, infer O> ? O : unknown;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : unknown;
 export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): ReferenceExpressionNode;

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

@@ -5,7 +5,8 @@ import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTa
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
+import { AliasedAggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB> | AliasedAggregateFunctionBuilder<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
  * Given a selection expression returns a query builder type that
@@ -19,9 +20,9 @@ export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends
 export declare type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
-declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
+declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : SE extends AliasedAggregateFunctionBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedAggregateFunctionBuilder<any, any, any, infer QA> ? QA : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
+declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : SE extends AliasedAggregateFunctionBuilder<any, any, infer O, infer FA> ? FA extends A ? O : never : SE extends (qb: any) => AliasedAggregateFunctionBuilder<any, any, infer O, infer FA> ? FA extends A ? O : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
 declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {

package/dist/esm/parser/set-operation-parser.d.ts

@@ -0,0 +1,5 @@
+import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type SetOperationExpression<DB, O> = SelectQueryBuilder<DB, any, O> | RawBuilder<O>;
+export declare function parseSetOperation(operator: SetOperator, expression: SetOperationExpression<any, any>, all: boolean): SetOperationNode;

package/dist/esm/parser/set-operation-parser.js

@@ -0,0 +1,5 @@
+/// <reference types="./set-operation-parser.d.ts" />
+import { SetOperationNode, } from '../operation-node/set-operation-node.js';
+export function parseSetOperation(operator, expression, all) {
+    return SetOperationNode.create(operator, expression.toOperationNode(), all);
+}

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

@@ -3,7 +3,8 @@ import { ValueNode } from '../operation-node/value-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { ComplexExpression } from './complex-expression-parser.js';
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
 export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode | AggregateFunctionNode;

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

@@ -0,0 +1,117 @@
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OverBuilder } from './over-builder.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements OperationNodeSource {
+    #private;
+    constructor(props: AggregateFunctionBuilderProps);
+    /**
+     * Returns an aliased version of the function.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('id').as('person_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `person_count: number` field exists in the result type.
+     * console.log(result.person_count)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("id") as "person_count"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedAggregateFunctionBuilder<DB, TB, O, A>;
+    /**
+     * Adds a distinct clause inside the function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('first_name').distinct().as('first_name_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count(distinct "first_name") as "first_name_count"
+     * from "person"
+     * ```
+     */
+    distinct(): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an over clause (window functions) after the function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over().as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over() as "average_age"
+     * from "person"
+     * ```
+     *
+     * Also supports passing a callback that returns an over builder,
+     * allowing to add partition by and sort by clauses inside over.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name" order by "first_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    toOperationNode(): AggregateFunctionNode;
+}
+/**
+ * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
+ */
+export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown, A extends string = never> implements OperationNodeSource {
+    #private;
+    constructor(aggregateFunctionBuilder: AggregateFunctionBuilder<DB, TB, O>, alias: A);
+    /**
+     * @private
+     *
+     * This needs to be here just so that the typings work. Without this
+     * the generated .d.ts file contains no reference to the type param A
+     * which causes this type to be equal to AliasedAggregateFunctionBuilder with any A
+     * as long as O is the same.
+     */
+    protected get alias(): A;
+    toOperationNode(): AliasNode;
+}
+export interface AggregateFunctionBuilderProps {
+    aggregateFunctionNode: AggregateFunctionNode;
+}
+export declare type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<DB, TB>;