kysely 0.21.6 → 0.23.0

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

@@ -1,14 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { ValueNode } from './value-node.js';
 export interface DefaultValueNode extends OperationNode {
     readonly kind: 'DefaultValueNode';
-    readonly defaultValue: ValueNode | RawNode;
+    readonly defaultValue: OperationNode;
 }
 /**
  * @internal
  */
 export declare const DefaultValueNode: Readonly<{
     is(node: OperationNode): node is DefaultValueNode;
-    create(defaultValue: ValueNode | RawNode): DefaultValueNode;
+    create(defaultValue: OperationNode): DefaultValueNode;
 }>;

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

@@ -1,7 +1,6 @@
 import { FromNode } from './from-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
@@ -25,7 +24,7 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: TableExpressionNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItem: OperationNode, withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;

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

@@ -11,6 +11,6 @@ export interface DropTypeNode extends OperationNode {
  */
 export declare const DropTypeNode: Readonly<{
     is(node: OperationNode): node is DropTypeNode;
-    create(name: string): DropTypeNode;
+    create(name: SchemableIdentifierNode): DropTypeNode;
     cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
 }>;

package/dist/esm/operation-node/drop-type-node.js

@@ -1,6 +1,5 @@
 /// <reference types="./drop-type-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 /**
  * @internal
  */
@@ -11,7 +10,7 @@ export const DropTypeNode = freeze({
     create(name) {
         return freeze({
             kind: 'DropTypeNode',
-            name: SchemableIdentifierNode.create(name),
+            name,
         });
     },
     cloneWith(dropType, params) {

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

@@ -1,16 +1,14 @@
 import { ExplainFormat } from '../util/explainable.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export interface ExplainNode extends OperationNode {
     readonly kind: 'ExplainNode';
     readonly format?: ExplainFormat;
-    readonly options?: RawNode;
+    readonly options?: OperationNode;
 }
 /**
  * @internal
  */
 export declare const ExplainNode: Readonly<{
     is(node: OperationNode): node is ExplainNode;
-    create(format?: ExplainFormat, options?: AnyRawBuilder): ExplainNode;
+    create(format?: ExplainFormat, options?: OperationNode): ExplainNode;
 }>;

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

@@ -11,7 +11,7 @@ export const ExplainNode = freeze({
         return freeze({
             kind: 'ExplainNode',
             format,
-            options: options?.toOperationNode(),
+            options,
         });
     },
 });

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

@@ -1,14 +1,13 @@
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 export interface FromNode extends OperationNode {
     readonly kind: 'FromNode';
-    readonly froms: ReadonlyArray<TableExpressionNode>;
+    readonly froms: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const FromNode: Readonly<{
     is(node: OperationNode): node is FromNode;
-    create(froms: ReadonlyArray<TableExpressionNode>): FromNode;
-    cloneWithFroms(from: FromNode, froms: ReadonlyArray<TableExpressionNode>): FromNode;
+    create(froms: ReadonlyArray<OperationNode>): FromNode;
+    cloneWithFroms(from: FromNode, froms: ReadonlyArray<OperationNode>): FromNode;
 }>;

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

@@ -1,5 +1,4 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export declare type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
 export interface GeneratedNode extends OperationNode {
     readonly kind: 'GeneratedNode';
@@ -7,7 +6,7 @@ export interface GeneratedNode extends OperationNode {
     readonly always?: boolean;
     readonly identity?: boolean;
     readonly stored?: boolean;
-    readonly expression?: RawNode;
+    readonly expression?: OperationNode;
 }
 /**
  * @internal
@@ -15,6 +14,6 @@ export interface GeneratedNode extends OperationNode {
 export declare const GeneratedNode: Readonly<{
     is(node: OperationNode): node is GeneratedNode;
     create(params: GeneratedNodeParams): GeneratedNode;
-    createWithExpression(expression: RawNode): GeneratedNode;
+    createWithExpression(expression: OperationNode): GeneratedNode;
     cloneWith(node: GeneratedNode, params: GeneratedNodeParams): GeneratedNode;
 }>;

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

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ReferenceExpressionNode } from './operation-node-utils.js';
 export interface GroupByItemNode extends OperationNode {
     readonly kind: 'GroupByItemNode';
-    readonly groupBy: ReferenceExpressionNode;
+    readonly groupBy: OperationNode;
 }
 /**
  * @internal
  */
 export declare const GroupByItemNode: Readonly<{
     is(node: OperationNode): node is GroupByItemNode;
-    create(groupBy: ReferenceExpressionNode): GroupByItemNode;
+    create(groupBy: OperationNode): GroupByItemNode;
 }>;

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/having-node.d.ts

@@ -1,14 +1,13 @@
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
-    readonly having: FilterExpressionNode;
+    readonly having: OperationNode;
 }
 /**
  * @internal
  */
 export declare const HavingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
-    create(filter: FilterExpressionNode): HavingNode;
-    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', filter: FilterExpressionNode): HavingNode;
+    create(filter: OperationNode): HavingNode;
+    cloneWithOperation(havingNode: HavingNode, operator: 'And' | 'Or', operation: OperationNode): HavingNode;
 }>;

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

@@ -15,12 +15,12 @@ export const HavingNode = freeze({
             having: filter,
         });
     },
-    cloneWithFilter(havingNode, op, filter) {
+    cloneWithOperation(havingNode, operator, operation) {
         return freeze({
             ...havingNode,
-            having: op === 'And'
-                ? AndNode.create(havingNode.having, filter)
-                : OrNode.create(havingNode.having, filter),
+            having: operator === 'And'
+                ? AndNode.create(havingNode.having, operation)
+                : OrNode.create(havingNode.having, operation),
         });
     },
 });

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

@@ -3,18 +3,15 @@ import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { ReturningNode } from './returning-node.js';
-import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
-import { ValuesNode } from './values-node.js';
 import { WithNode } from './with-node.js';
 export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
-    readonly values?: ValuesNode | SelectQueryNode | RawNode;
+    readonly values?: OperationNode;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;

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

@@ -1,14 +1,10 @@
-import { AliasNode } from './alias-node.js';
 import { OnNode } from './on-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { TableNode } from './table-node.js';
-export declare type JoinTableNode = TableNode | AliasNode;
 export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;
-    readonly table: JoinTableNode;
+    readonly table: OperationNode;
     readonly on?: OnNode;
 }
 /**
@@ -16,8 +12,8 @@ export interface JoinNode extends OperationNode {
  */
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
-    create(joinType: JoinType, table: JoinTableNode): JoinNode;
-    createWithOn(joinType: JoinType, table: JoinTableNode, on: FilterExpressionNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
-    cloneWithOrOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
+    create(joinType: JoinType, table: OperationNode): JoinNode;
+    createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
 }>;

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

@@ -24,20 +24,20 @@ export const JoinNode = freeze({
             on: OnNode.create(on),
         });
     },
-    cloneWithOn(joinNode, filter) {
+    cloneWithOn(joinNode, operation) {
         return freeze({
             ...joinNode,
             on: joinNode.on
-                ? OnNode.cloneWithFilter(joinNode.on, 'And', filter)
-                : OnNode.create(filter),
+                ? OnNode.cloneWithOperation(joinNode.on, 'And', operation)
+                : OnNode.create(operation),
         });
     },
-    cloneWithOrOn(joinNode, filter) {
+    cloneWithOrOn(joinNode, operation) {
         return freeze({
             ...joinNode,
             on: joinNode.on
-                ? OnNode.cloneWithFilter(joinNode.on, 'Or', filter)
-                : OnNode.create(filter),
+                ? OnNode.cloneWithOperation(joinNode.on, 'Or', operation)
+                : OnNode.create(operation),
         });
     },
 });

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

@@ -1,16 +1,14 @@
 import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { WhereNode } from './where-node.js';
 export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly constraint?: IdentifierNode;
-    readonly indexExpression?: RawNode;
+    readonly indexExpression?: OperationNode;
     readonly indexWhere?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
     readonly updateWhere?: WhereNode;
@@ -23,8 +21,8 @@ export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
     create(): OnConflictNode;
     cloneWith(node: OnConflictNode, props: OnConflictNodeProps): OnConflictNode;
-    cloneWithIndexWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
-    cloneWithIndexOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
-    cloneWithUpdateWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
-    cloneWithUpdateOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithIndexWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
 }>;

package/dist/esm/operation-node/on-conflict-node.js

@@ -19,36 +19,36 @@ export const OnConflictNode = freeze({
             ...props,
         });
     },
-    cloneWithIndexWhere(node, filter) {
+    cloneWithIndexWhere(node, operation) {
         return freeze({
             ...node,
             indexWhere: node.indexWhere
-                ? WhereNode.cloneWithFilter(node.indexWhere, 'And', filter)
-                : WhereNode.create(filter),
+                ? WhereNode.cloneWithOperation(node.indexWhere, 'And', operation)
+                : WhereNode.create(operation),
         });
     },
-    cloneWithIndexOrWhere(node, filter) {
+    cloneWithIndexOrWhere(node, operation) {
         return freeze({
             ...node,
             indexWhere: node.indexWhere
-                ? WhereNode.cloneWithFilter(node.indexWhere, 'Or', filter)
-                : WhereNode.create(filter),
+                ? WhereNode.cloneWithOperation(node.indexWhere, 'Or', operation)
+                : WhereNode.create(operation),
         });
     },
-    cloneWithUpdateWhere(node, filter) {
+    cloneWithUpdateWhere(node, operation) {
         return freeze({
             ...node,
             updateWhere: node.updateWhere
-                ? WhereNode.cloneWithFilter(node.updateWhere, 'And', filter)
-                : WhereNode.create(filter),
+                ? WhereNode.cloneWithOperation(node.updateWhere, 'And', operation)
+                : WhereNode.create(operation),
         });
     },
-    cloneWithUpdateOrWhere(node, filter) {
+    cloneWithUpdateOrWhere(node, operation) {
         return freeze({
             ...node,
             updateWhere: node.updateWhere
-                ? WhereNode.cloneWithFilter(node.updateWhere, 'Or', filter)
-                : WhereNode.create(filter),
+                ? WhereNode.cloneWithOperation(node.updateWhere, 'Or', operation)
+                : WhereNode.create(operation),
         });
     },
 });

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

@@ -1,14 +1,13 @@
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface OnNode extends OperationNode {
     readonly kind: 'OnNode';
-    readonly on: FilterExpressionNode;
+    readonly on: OperationNode;
 }
 /**
  * @internal
  */
 export declare const OnNode: Readonly<{
     is(node: OperationNode): node is OnNode;
-    create(filter: FilterExpressionNode): OnNode;
-    cloneWithFilter(onNode: OnNode, op: 'And' | 'Or', filter: FilterExpressionNode): OnNode;
+    create(filter: OperationNode): OnNode;
+    cloneWithOperation(onNode: OnNode, operator: 'And' | 'Or', operation: OperationNode): OnNode;
 }>;

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

@@ -15,12 +15,12 @@ export const OnNode = freeze({
             on: filter,
         });
     },
-    cloneWithFilter(onNode, op, filter) {
+    cloneWithOperation(onNode, operator, operation) {
         return freeze({
             ...onNode,
-            on: op === 'And'
-                ? AndNode.create(onNode.on, filter)
-                : OrNode.create(onNode.on, filter),
+            on: operator === 'And'
+                ? AndNode.create(onNode.on, operation)
+                : OrNode.create(onNode.on, operation),
         });
     },
 });

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

@@ -15,7 +15,6 @@ import { RawNode } from './raw-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { ValueNode } from './value-node.js';
-import { FilterNode } from './filter-node.js';
 import { OperatorNode } from './operator-node.js';
 import { FromNode } from './from-node.js';
 import { WhereNode } from './where-node.js';
@@ -58,7 +57,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';
@@ -71,6 +69,13 @@ 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';
+import { BinaryOperationNode } from './binary-operation-node.js';
+import { UnaryOperationNode } from './unary-operation-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -113,7 +118,6 @@ export declare class OperationNodeTransformer {
     protected transformTable(node: TableNode): TableNode;
     protected transformFrom(node: FromNode): FromNode;
     protected transformReference(node: ReferenceNode): ReferenceNode;
-    protected transformFilter(node: FilterNode): FilterNode;
     protected transformAnd(node: AndNode): AndNode;
     protected transformOr(node: OrNode): OrNode;
     protected transformValueList(node: ValueListNode): ValueListNode;
@@ -145,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;
@@ -171,6 +175,12 @@ 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 transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
+    protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -44,7 +44,6 @@ export class OperationNodeTransformer {
         TableNode: this.transformTable.bind(this),
         FromNode: this.transformFrom.bind(this),
         SelectAllNode: this.transformSelectAll.bind(this),
-        FilterNode: this.transformFilter.bind(this),
         AndNode: this.transformAnd.bind(this),
         OrNode: this.transformOr.bind(this),
         ValueNode: this.transformValue.bind(this),
@@ -93,7 +92,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),
@@ -105,6 +103,13 @@ export class OperationNodeTransformer {
         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),
+        BinaryOperationNode: this.transformBinaryOperation.bind(this),
+        UnaryOperationNode: this.transformUnaryOperation.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -129,7 +134,7 @@ export class OperationNodeTransformer {
             kind: 'SelectQueryNode',
             from: this.transformNode(node.from),
             selections: this.transformNodeList(node.selections),
-            distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
+            distinctOn: this.transformNodeList(node.distinctOn),
             joins: this.transformNodeList(node.joins),
             groupBy: this.transformNode(node.groupBy),
             orderBy: this.transformNode(node.orderBy),
@@ -140,8 +145,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) {
@@ -182,14 +187,6 @@ export class OperationNodeTransformer {
             column: this.transformNode(node.column),
         });
     }
-    transformFilter(node) {
-        return requireAllProps({
-            kind: 'FilterNode',
-            left: this.transformNode(node.left),
-            op: this.transformNode(node.op),
-            right: this.transformNode(node.right),
-        });
-    }
     transformAnd(node) {
         return requireAllProps({
             kind: 'AndNode',
@@ -304,6 +301,8 @@ export class OperationNodeTransformer {
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
             generated: this.transformNode(node.generated),
+            frontModifiers: this.transformNodeList(node.frontModifiers),
+            endModifiers: this.transformNodeList(node.endModifiers),
         });
     }
     transformAddColumn(node) {
@@ -444,10 +443,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,
         });
     }
@@ -515,11 +515,7 @@ export class OperationNodeTransformer {
             table: this.transformNode(node.table),
             renameTo: this.transformNode(node.renameTo),
             setSchema: this.transformNode(node.setSchema),
-            renameColumn: this.transformNode(node.renameColumn),
-            addColumn: this.transformNode(node.addColumn),
-            dropColumn: this.transformNode(node.dropColumn),
-            alterColumn: this.transformNode(node.alterColumn),
-            modifyColumn: this.transformNode(node.modifyColumn),
+            columnAlterations: this.transformNodeList(node.columnAlterations),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
         });
@@ -647,6 +643,50 @@ export class OperationNodeTransformer {
             identifier: this.transformNode(node.identifier),
         });
     }
+    transformAggregateFunction(node) {
+        return requireAllProps({
+            kind: 'AggregateFunctionNode',
+            column: this.transformNode(node.column),
+            distinct: node.distinct,
+            filter: this.transformNode(node.filter),
+            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),
+        });
+    }
+    transformBinaryOperation(node) {
+        return requireAllProps({
+            kind: 'BinaryOperationNode',
+            leftOperand: this.transformNode(node.leftOperand),
+            operator: this.transformNode(node.operator),
+            rightOperand: this.transformNode(node.rightOperand),
+        });
+    }
+    transformUnaryOperation(node) {
+        return requireAllProps({
+            kind: 'UnaryOperationNode',
+            operator: this.transformNode(node.operator),
+            operand: this.transformNode(node.operand),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;