kysely 0.21.5 → 0.22.0

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

@@ -0,0 +1,22 @@
+import { ColumnNode } from './column-node.js';
+import { OperationNode } from './operation-node.js';
+import { OverNode } from './over-node.js';
+import { ReferenceNode } from './reference-node.js';
+declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
+export interface AggregateFunctionNode extends OperationNode {
+    readonly kind: 'AggregateFunctionNode';
+    readonly func: AggregateFunction;
+    readonly column: ColumnNode | ReferenceNode;
+    readonly distinct?: boolean;
+    readonly over?: OverNode;
+}
+/**
+ * @internal
+ */
+export declare const AggregateFunctionNode: Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, column: ColumnNode | ReferenceNode): AggregateFunctionNode;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
+}>;
+export {};

package/dist/esm/operation-node/aggregate-function-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./aggregate-function-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AggregateFunctionNode = freeze({
+    is(node) {
+        return node.kind === 'AggregateFunctionNode';
+    },
+    create(aggregateFunction, column) {
+        return freeze({
+            kind: 'AggregateFunctionNode',
+            func: aggregateFunction,
+            column,
+        });
+    },
+    cloneWithDistinct(aggregateFunctionNode) {
+        return freeze({
+            ...aggregateFunctionNode,
+            distinct: true,
+        });
+    },
+    cloneWithOver(aggregateFunctionNode, over) {
+        return freeze({
+            ...aggregateFunctionNode,
+            over,
+        });
+    },
+});

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

@@ -1,3 +1,4 @@
+import { AggregateFunctionNode } from './aggregate-function-node.js';
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
@@ -5,7 +6,7 @@ import { RawNode } from './raw-node.js';
 import { ReferenceNode } from './reference-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
-export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | SelectQueryNode | RawNode;
+export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | SelectQueryNode | RawNode | AggregateFunctionNode;
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: AliasNodeChild;

package/dist/esm/operation-node/default-insert-value-node.d.ts

@@ -0,0 +1,11 @@
+import { OperationNode } from './operation-node.js';
+export interface DefaultInsertValueNode extends OperationNode {
+    readonly kind: 'DefaultInsertValueNode';
+}
+/**
+ * @internal
+ */
+export declare const DefaultInsertValueNode: Readonly<{
+    is(node: OperationNode): node is DefaultInsertValueNode;
+    create(): DefaultInsertValueNode;
+}>;

package/dist/esm/operation-node/default-insert-value-node.js

@@ -0,0 +1,15 @@
+/// <reference types="./default-insert-value-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DefaultInsertValueNode = freeze({
+    is(node) {
+        return node.kind === 'DefaultInsertValueNode';
+    },
+    create() {
+        return freeze({
+            kind: 'DefaultInsertValueNode',
+        });
+    },
+});

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

@@ -10,5 +10,5 @@ export interface GroupByNode extends OperationNode {
 export declare const GroupByNode: Readonly<{
     is(node: OperationNode): node is GroupByNode;
     create(items: ReadonlyArray<GroupByItemNode>): GroupByNode;
-    cloneWithItems(orderBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): GroupByNode;
+    cloneWithItems(groupBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): GroupByNode;
 }>;

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

@@ -13,10 +13,10 @@ export const GroupByNode = freeze({
             items: freeze(items),
         });
     },
-    cloneWithItems(orderBy, items) {
+    cloneWithItems(groupBy, items) {
         return freeze({
-            ...orderBy,
-            items: freeze([...orderBy.items, ...items]),
+            ...groupBy,
+            items: freeze([...groupBy.items, ...items]),
         });
     },
 });

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

@@ -1,3 +1,4 @@
+import { AggregateFunctionNode } from './aggregate-function-node.js';
 import { ColumnNode } from './column-node.js';
 import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
@@ -14,7 +15,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
-    readonly values?: ValuesNode | SelectQueryNode | RawNode;
+    readonly values?: ValuesNode | SelectQueryNode | RawNode | AggregateFunctionNode;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;

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

@@ -58,7 +58,6 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
-import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
 import { GeneratedNode } from './generated-node.js';
@@ -70,6 +69,12 @@ import { CreateTypeNode } from './create-type-node.js';
 import { DropTypeNode } from './drop-type-node.js';
 import { ExplainNode } from './explain-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import { DefaultInsertValueNode } from './default-insert-value-node.js';
+import { AggregateFunctionNode } from './aggregate-function-node.js';
+import { OverNode } from './over-node.js';
+import { PartitionByNode } from './partition-by-node.js';
+import { PartitionByItemNode } from './partition-by-item-node.js';
+import { SetOperationNode } from './set-operation-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -144,7 +149,7 @@ export declare class OperationNodeTransformer {
     protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): PrimaryKeyConstraintNode;
     protected transformUniqueConstraint(node: UniqueConstraintNode): UniqueConstraintNode;
     protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode): ForeignKeyConstraintNode;
-    protected transformUnion(node: UnionNode): UnionNode;
+    protected transformSetOperation(node: SetOperationNode): SetOperationNode;
     protected transformReferences(node: ReferencesNode): ReferencesNode;
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;
@@ -170,10 +175,15 @@ export declare class OperationNodeTransformer {
     protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformExplain(node: ExplainNode): ExplainNode;
     protected transformSchemableIdentifier(node: SchemableIdentifierNode): SchemableIdentifierNode;
+    protected transformAggregateFunction(node: AggregateFunctionNode): AggregateFunctionNode;
+    protected transformOver(node: OverNode): OverNode;
+    protected transformPartitionBy(node: PartitionByNode): PartitionByNode;
+    protected transformPartitionByItem(node: PartitionByItemNode): PartitionByItemNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;
     protected transformValue(node: ValueNode): ValueNode;
     protected transformPrimitiveValueList(node: PrimitiveValueListNode): PrimitiveValueListNode;
     protected transformOperator(node: OperatorNode): OperatorNode;
+    protected transformDefaultInsertValue(node: DefaultInsertValueNode): DefaultInsertValueNode;
 }

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

@@ -93,7 +93,6 @@ export class OperationNodeTransformer {
         AddConstraintNode: this.transformAddConstraint.bind(this),
         DropConstraintNode: this.transformDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
-        UnionNode: this.transformUnion.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
         GeneratedNode: this.transformGenerated.bind(this),
@@ -104,6 +103,12 @@ export class OperationNodeTransformer {
         CreateTypeNode: this.transformCreateType.bind(this),
         DropTypeNode: this.transformDropType.bind(this),
         ExplainNode: this.transformExplain.bind(this),
+        DefaultInsertValueNode: this.transformDefaultInsertValue.bind(this),
+        AggregateFunctionNode: this.transformAggregateFunction.bind(this),
+        OverNode: this.transformOver.bind(this),
+        PartitionByNode: this.transformPartitionBy.bind(this),
+        PartitionByItemNode: this.transformPartitionByItem.bind(this),
+        SetOperationNode: this.transformSetOperation.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -139,8 +144,8 @@ export class OperationNodeTransformer {
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
-            union: this.transformNodeList(node.union),
             explain: this.transformNode(node.explain),
+            setOperations: this.transformNodeList(node.setOperations),
         });
     }
     transformSelection(node) {
@@ -443,10 +448,11 @@ export class OperationNodeTransformer {
             onUpdate: node.onUpdate,
         });
     }
-    transformUnion(node) {
+    transformSetOperation(node) {
         return requireAllProps({
-            kind: 'UnionNode',
-            union: this.transformNode(node.union),
+            kind: 'SetOperationNode',
+            operator: node.operator,
+            expression: this.transformNode(node.expression),
             all: node.all,
         });
     }
@@ -646,6 +652,34 @@ export class OperationNodeTransformer {
             identifier: this.transformNode(node.identifier),
         });
     }
+    transformAggregateFunction(node) {
+        return requireAllProps({
+            kind: 'AggregateFunctionNode',
+            column: this.transformNode(node.column),
+            distinct: node.distinct,
+            func: node.func,
+            over: this.transformNode(node.over),
+        });
+    }
+    transformOver(node) {
+        return requireAllProps({
+            kind: 'OverNode',
+            orderBy: this.transformNode(node.orderBy),
+            partitionBy: this.transformNode(node.partitionBy),
+        });
+    }
+    transformPartitionBy(node) {
+        return requireAllProps({
+            kind: 'PartitionByNode',
+            items: this.transformNodeList(node.items),
+        });
+    }
+    transformPartitionByItem(node) {
+        return requireAllProps({
+            kind: 'PartitionByItemNode',
+            partitionBy: this.transformNode(node.partitionBy),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;
@@ -670,4 +704,8 @@ export class OperationNodeTransformer {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
+    transformDefaultInsertValue(node) {
+        // An Object.freezed leaf node. No need to clone.
+        return node;
+    }
 }

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

@@ -1,3 +1,4 @@
+import { AggregateFunctionNode } from './aggregate-function-node.js';
 import { AliasNode } from './alias-node.js';
 import { AndNode } from './and-node.js';
 import { ColumnNode } from './column-node.js';
@@ -11,7 +12,7 @@ import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { ValueNode } from './value-node.js';
-export declare type ReferenceExpressionNode = ColumnNode | ReferenceNode | SelectQueryNode | RawNode;
+export declare type ReferenceExpressionNode = ColumnNode | ReferenceNode | SelectQueryNode | RawNode | AggregateFunctionNode;
 export declare type ValueExpressionNode = ValueNode | ValueListNode | PrimitiveValueListNode | ReferenceExpressionNode;
 export declare type TableExpressionNode = TableNode | AliasNode;
 export declare type FilterExpressionNode = FilterNode | AndNode | OrNode | ParensNode | RawNode;

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

@@ -58,7 +58,6 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
-import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
 import { GeneratedNode } from './generated-node.js';
@@ -70,6 +69,12 @@ import { CreateTypeNode } from './create-type-node.js';
 import { DropTypeNode } from './drop-type-node.js';
 import { ExplainNode } from './explain-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import { DefaultInsertValueNode } from './default-insert-value-node.js';
+import { AggregateFunctionNode } from './aggregate-function-node.js';
+import { OverNode } from './over-node.js';
+import { PartitionByNode } from './partition-by-node.js';
+import { PartitionByItemNode } from './partition-by-item-node.js';
+import { SetOperationNode } from './set-operation-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -128,7 +133,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitAddConstraint(node: AddConstraintNode): void;
     protected abstract visitDropConstraint(node: DropConstraintNode): void;
     protected abstract visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
-    protected abstract visitUnion(node: UnionNode): void;
     protected abstract visitDataType(node: DataTypeNode): void;
     protected abstract visitSelectAll(node: SelectAllNode): void;
     protected abstract visitIdentifier(node: IdentifierNode): void;
@@ -146,4 +150,10 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitCreateType(node: CreateTypeNode): void;
     protected abstract visitDropType(node: DropTypeNode): void;
     protected abstract visitExplain(node: ExplainNode): void;
+    protected abstract visitDefaultInsertValue(node: DefaultInsertValueNode): void;
+    protected abstract visitAggregateFunction(node: AggregateFunctionNode): void;
+    protected abstract visitOver(node: OverNode): void;
+    protected abstract visitPartitionBy(node: PartitionByNode): void;
+    protected abstract visitPartitionByItem(node: PartitionByItemNode): void;
+    protected abstract visitSetOperation(node: SetOperationNode): void;
 }

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

@@ -66,7 +66,6 @@ export class OperationNodeVisitor {
         AddConstraintNode: this.visitAddConstraint.bind(this),
         DropConstraintNode: this.visitDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
-        UnionNode: this.visitUnion.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
         GeneratedNode: this.visitGenerated.bind(this),
@@ -77,6 +76,12 @@ export class OperationNodeVisitor {
         CreateTypeNode: this.visitCreateType.bind(this),
         DropTypeNode: this.visitDropType.bind(this),
         ExplainNode: this.visitExplain.bind(this),
+        DefaultInsertValueNode: this.visitDefaultInsertValue.bind(this),
+        AggregateFunctionNode: this.visitAggregateFunction.bind(this),
+        OverNode: this.visitOver.bind(this),
+        PartitionByNode: this.visitPartitionBy.bind(this),
+        PartitionByItemNode: this.visitPartitionByItem.bind(this),
+        SetOperationNode: this.visitSetOperation.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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';
+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,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/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>;
-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);
 }