kysely 0.21.5 → 0.22.0

package/dist/cjs/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/cjs/operation-node/partition-by-item-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartitionByItemNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.PartitionByItemNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'PartitionByItemNode';
+    },
+    create(partitionBy) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'PartitionByItemNode',
+            partitionBy,
+        });
+    },
+});

package/dist/cjs/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/cjs/operation-node/partition-by-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartitionByNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.PartitionByNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'PartitionByNode';
+    },
+    create(items) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'PartitionByNode',
+            items: (0, object_utils_js_1.freeze)(items),
+        });
+    },
+    cloneWithItems(partitionBy, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...partitionBy,
+            items: (0, object_utils_js_1.freeze)([...partitionBy.items, ...items]),
+        });
+    },
+});

package/dist/cjs/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/cjs/operation-node/select-query-node.js

@@ -96,12 +96,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : having_node_js_1.HavingNode.create(filter),
         });
     },
-    cloneWithUnion(selectNode, union) {
+    cloneWithSetOperation(selectNode, setOperation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
-            union: selectNode.union
-                ? (0, object_utils_js_1.freeze)([...selectNode.union, union])
-                : (0, object_utils_js_1.freeze)([union]),
+            setOperations: selectNode.setOperations
+                ? (0, object_utils_js_1.freeze)([...selectNode.setOperations, setOperation])
+                : (0, object_utils_js_1.freeze)([setOperation]),
         });
     },
     cloneWithExplain(selectNode, explain) {

package/dist/cjs/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/cjs/operation-node/set-operation-node.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetOperationNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.SetOperationNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'SetOperationNode';
+    },
+    create(operator, expression, all) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SetOperationNode',
+            operator,
+            expression,
+            all,
+        });
+    },
+});

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

@@ -1,9 +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 | 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/cjs/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>;
-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/cjs/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/cjs/parser/group-by-parser.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGroupBy = void 0;
 const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
-function parseGroupBy(orderBy) {
-    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
+function parseGroupBy(groupBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(groupBy).map(group_by_item_node_js_1.GroupByItemNode.create);
 }
 exports.parseGroupBy = parseGroupBy;

package/dist/cjs/parser/insert-values-parser.js

@@ -8,6 +8,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
 const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const default_insert_value_node_js_1 = require("../operation-node/default-insert-value-node.js");
 function parseInsertObjectOrList(args) {
     return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
@@ -33,16 +34,24 @@ function parseColumnNamesAndIndexes(rows) {
 }
 function parseRowValues(row, columns) {
     const rowColumns = Object.keys(row);
-    const rowValues = new Array(columns.size).fill(null);
+    const rowValues = Array.from({
+        length: columns.size,
+    });
+    let complexColumn = false;
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
-        const value = row[col];
         if (columnIdx !== undefined) {
+            const value = row[col];
+            if ((0, complex_expression_parser_js_1.isComplexExpression)(value)) {
+                complexColumn = true;
+            }
             rowValues[columnIdx] = value;
         }
     }
-    if (rowValues.some(complex_expression_parser_js_1.isComplexExpression)) {
-        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(it)));
+    const columnMissing = rowColumns.length < columns.size;
+    if (columnMissing || complexColumn) {
+        const defaultValue = default_insert_value_node_js_1.DefaultInsertValueNode.create();
+        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, object_utils_js_1.isUndefined)(it) ? defaultValue : (0, value_parser_js_1.parseValueExpression)(it)));
     }
     return primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues);
 }

package/dist/cjs/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/cjs/parser/parse-utils.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJoinBuilder = exports.createQueryCreator = exports.createExpressionBuilder = exports.createSelectQueryBuilder = void 0;
+exports.createOverBuilder = exports.createJoinBuilder = exports.createQueryCreator = exports.createExpressionBuilder = exports.createSelectQueryBuilder = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
+const over_node_js_1 = require("../operation-node/over-node.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const expression_builder_js_1 = require("../query-builder/expression-builder.js");
 const join_builder_js_1 = require("../query-builder/join-builder.js");
+const over_builder_js_1 = require("../query-builder/over-builder.js");
 const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
 const query_creator_js_1 = require("../query-creator.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
@@ -36,3 +38,9 @@ function createJoinBuilder(joinType, table) {
     });
 }
 exports.createJoinBuilder = createJoinBuilder;
+function createOverBuilder() {
+    return new over_builder_js_1.OverBuilder({
+        overNode: over_node_js_1.OverNode.create(),
+    });
+}
+exports.createOverBuilder = createOverBuilder;

package/dist/cjs/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/cjs/parser/partition-by-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePartitionBy = void 0;
+const partition_by_item_node_js_1 = require("../operation-node/partition-by-item-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parsePartitionBy(partitionBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(partitionBy).map(partition_by_item_node_js_1.PartitionByItemNode.create);
+}
+exports.parsePartitionBy = parsePartitionBy;

package/dist/cjs/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/cjs/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/cjs/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/cjs/parser/set-operation-parser.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSetOperation = void 0;
+const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
+function parseSetOperation(operator, expression, all) {
+    return set_operation_node_js_1.SetOperationNode.create(operator, expression.toOperationNode(), all);
+}
+exports.parseSetOperation = parseSetOperation;

package/dist/cjs/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/cjs/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>;