kysely 0.21.6 → 0.23.0

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

@@ -17,12 +17,12 @@ exports.HavingNode = (0, object_utils_js_1.freeze)({
             having: filter,
         });
     },
-    cloneWithFilter(havingNode, op, filter) {
+    cloneWithOperation(havingNode, operator, operation) {
         return (0, object_utils_js_1.freeze)({
             ...havingNode,
-            having: op === 'And'
-                ? and_node_js_1.AndNode.create(havingNode.having, filter)
-                : or_node_js_1.OrNode.create(havingNode.having, filter),
+            having: operator === 'And'
+                ? and_node_js_1.AndNode.create(havingNode.having, operation)
+                : or_node_js_1.OrNode.create(havingNode.having, operation),
         });
     },
 });

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

@@ -26,20 +26,20 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
             on: on_node_js_1.OnNode.create(on),
         });
     },
-    cloneWithOn(joinNode, filter) {
+    cloneWithOn(joinNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,
             on: joinNode.on
-                ? on_node_js_1.OnNode.cloneWithFilter(joinNode.on, 'And', filter)
-                : on_node_js_1.OnNode.create(filter),
+                ? on_node_js_1.OnNode.cloneWithOperation(joinNode.on, 'And', operation)
+                : on_node_js_1.OnNode.create(operation),
         });
     },
-    cloneWithOrOn(joinNode, filter) {
+    cloneWithOrOn(joinNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,
             on: joinNode.on
-                ? on_node_js_1.OnNode.cloneWithFilter(joinNode.on, 'Or', filter)
-                : on_node_js_1.OnNode.create(filter),
+                ? on_node_js_1.OnNode.cloneWithOperation(joinNode.on, 'Or', operation)
+                : on_node_js_1.OnNode.create(operation),
         });
     },
 });

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

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

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

@@ -17,12 +17,12 @@ exports.OnNode = (0, object_utils_js_1.freeze)({
             on: filter,
         });
     },
-    cloneWithFilter(onNode, op, filter) {
+    cloneWithOperation(onNode, operator, operation) {
         return (0, object_utils_js_1.freeze)({
             ...onNode,
-            on: op === 'And'
-                ? and_node_js_1.AndNode.create(onNode.on, filter)
-                : or_node_js_1.OrNode.create(onNode.on, filter),
+            on: operator === 'And'
+                ? and_node_js_1.AndNode.create(onNode.on, operation)
+                : or_node_js_1.OrNode.create(onNode.on, operation),
         });
     },
 });

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

@@ -46,7 +46,6 @@ 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),
@@ -95,7 +94,6 @@ 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),
@@ -107,6 +105,13 @@ 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) {
@@ -131,7 +136,7 @@ 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),
@@ -142,8 +147,8 @@ 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) {
@@ -184,14 +189,6 @@ class OperationNodeTransformer {
             column: this.transformNode(node.column),
         });
     }
-    transformFilter(node) {
-        return (0, require_all_props_js_1.requireAllProps)({
-            kind: 'FilterNode',
-            left: this.transformNode(node.left),
-            op: this.transformNode(node.op),
-            right: this.transformNode(node.right),
-        });
-    }
     transformAnd(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AndNode',
@@ -306,6 +303,8 @@ 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) {
@@ -446,10 +445,11 @@ class OperationNodeTransformer {
             onUpdate: node.onUpdate,
         });
     }
-    transformUnion(node) {
+    transformSetOperation(node) {
         return (0, require_all_props_js_1.requireAllProps)({
-            kind: 'UnionNode',
-            union: this.transformNode(node.union),
+            kind: 'SetOperationNode',
+            operator: node.operator,
+            expression: this.transformNode(node.expression),
             all: node.all,
         });
     }
@@ -517,11 +517,7 @@ 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),
         });
@@ -649,6 +645,50 @@ class OperationNodeTransformer {
             identifier: this.transformNode(node.identifier),
         });
     }
+    transformAggregateFunction(node) {
+        return (0, require_all_props_js_1.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 (0, require_all_props_js_1.requireAllProps)({
+            kind: 'OverNode',
+            orderBy: this.transformNode(node.orderBy),
+            partitionBy: this.transformNode(node.partitionBy),
+        });
+    }
+    transformPartitionBy(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'PartitionByNode',
+            items: this.transformNodeList(node.items),
+        });
+    }
+    transformPartitionByItem(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'PartitionByItemNode',
+            partitionBy: this.transformNode(node.partitionBy),
+        });
+    }
+    transformBinaryOperation(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'BinaryOperationNode',
+            leftOperand: this.transformNode(node.leftOperand),
+            operator: this.transformNode(node.operator),
+            rightOperand: this.transformNode(node.rightOperand),
+        });
+    }
+    transformUnaryOperation(node) {
+        return (0, require_all_props_js_1.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;

package/dist/cjs/operation-node/operation-node-visitor.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';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -83,7 +88,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitTable(node: TableNode): void;
     protected abstract visitFrom(node: FromNode): void;
     protected abstract visitReference(node: ReferenceNode): void;
-    protected abstract visitFilter(node: FilterNode): void;
     protected abstract visitAnd(node: AndNode): void;
     protected abstract visitOr(node: OrNode): void;
     protected abstract visitValueList(node: ValueListNode): void;
@@ -129,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;
@@ -148,4 +151,11 @@ export declare abstract class OperationNodeVisitor {
     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;
+    protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
+    protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
 }

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

@@ -19,7 +19,6 @@ class OperationNodeVisitor {
         TableNode: this.visitTable.bind(this),
         FromNode: this.visitFrom.bind(this),
         SelectAllNode: this.visitSelectAll.bind(this),
-        FilterNode: this.visitFilter.bind(this),
         AndNode: this.visitAnd.bind(this),
         OrNode: this.visitOr.bind(this),
         ValueNode: this.visitValue.bind(this),
@@ -68,7 +67,6 @@ 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),
@@ -80,6 +78,13 @@ class OperationNodeVisitor {
         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),
+        BinaryOperationNode: this.visitBinaryOperation.bind(this),
+        UnaryOperationNode: this.visitUnaryOperation.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/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' | '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' | 'BinaryOperationNode' | 'UnaryOperationNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,7 +1,9 @@
-import { ArrayItemType } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists", "&&", "||", "@@", "@@@", "!!", "<->"];
-export declare type Operator = ArrayItemType<typeof OPERATORS>;
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
+export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
+export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
+export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];
+export declare type Operator = ComparisonOperator | UnaryFilterOperator;
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';
     readonly operator: Operator;

package/dist/cjs/operation-node/operator-node.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorNode = exports.OPERATORS = void 0;
+exports.OperatorNode = exports.UNARY_FILTER_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-exports.OPERATORS = [
+exports.COMPARISON_OPERATORS = [
     '=',
     '==',
     '!=',
@@ -22,7 +22,6 @@ exports.OPERATORS = [
     '@>',
     '<@',
     '?',
-    '?',
     '?&',
     '!<',
     '!>',
@@ -31,8 +30,6 @@ exports.OPERATORS = [
     '~',
     '~*',
     '!~*',
-    'exists',
-    'not exists',
     '&&',
     '||',
     '@@',
@@ -40,6 +37,7 @@ exports.OPERATORS = [
     '!!',
     '<->',
 ];
+exports.UNARY_FILTER_OPERATORS = ['exists', 'not exists'];
 /**
  * @internal
  */

package/dist/cjs/operation-node/or-node.d.ts

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

package/dist/cjs/operation-node/order-by-item-node.d.ts

@@ -1,15 +1,13 @@
 import { OperationNode } from './operation-node.js';
-import { ReferenceExpressionNode } from './operation-node-utils.js';
-import { RawNode } from './raw-node.js';
 export interface OrderByItemNode extends OperationNode {
     readonly kind: 'OrderByItemNode';
-    readonly orderBy: ReferenceExpressionNode;
-    readonly direction?: RawNode;
+    readonly orderBy: OperationNode;
+    readonly direction?: OperationNode;
 }
 /**
  * @internal
  */
 export declare const OrderByItemNode: Readonly<{
     is(node: OperationNode): node is OrderByItemNode;
-    create(orderBy: ReferenceExpressionNode, direction?: RawNode): OrderByItemNode;
+    create(orderBy: OperationNode, direction?: OperationNode): OrderByItemNode;
 }>;

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