kysely 0.21.6 → 0.23.0

package/dist/esm/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/esm/operation-node/operation-node-visitor.js

@@ -17,7 +17,6 @@ export 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),
@@ -66,7 +65,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),
@@ -78,6 +76,13 @@ export 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/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | '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/esm/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/esm/operation-node/operator-node.js

@@ -1,6 +1,6 @@
 /// <reference types="./operator-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-export const OPERATORS = [
+export const COMPARISON_OPERATORS = [
     '=',
     '==',
     '!=',
@@ -20,7 +20,6 @@ export const OPERATORS = [
     '@>',
     '<@',
     '?',
-    '?',
     '?&',
     '!<',
     '!>',
@@ -29,8 +28,6 @@ export const OPERATORS = [
     '~',
     '~*',
     '!~*',
-    'exists',
-    'not exists',
     '&&',
     '||',
     '@@',
@@ -38,6 +35,7 @@ export const OPERATORS = [
     '!!',
     '<->',
 ];
+export const UNARY_FILTER_OPERATORS = ['exists', 'not exists'];
 /**
  * @internal
  */

package/dist/esm/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/esm/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/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/parens-node.d.ts

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

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+export interface PartitionByItemNode extends OperationNode {
+    readonly kind: 'PartitionByItemNode';
+    readonly partitionBy: SimpleReferenceExpressionNode;
+}
+/**
+ * @internal
+ */
+export declare const PartitionByItemNode: Readonly<{
+    is(node: OperationNode): node is PartitionByItemNode;
+    create(partitionBy: SimpleReferenceExpressionNode): 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/query-node.d.ts

@@ -5,7 +5,6 @@ import { DeleteQueryNode } from './delete-query-node.js';
 import { JoinNode } from './join-node.js';
 import { SelectionNode } from './selection-node.js';
 import { OperationNode } from './operation-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 export declare type QueryNode = SelectQueryNode | DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type MutatingQueryNode = DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | UpdateQueryNode;
@@ -14,8 +13,8 @@ export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | Up
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
-    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, operation: OperationNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, operation: OperationNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
     cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

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

@@ -16,20 +16,20 @@ export const QueryNode = freeze({
             UpdateQueryNode.is(node) ||
             SelectQueryNode.is(node));
     },
-    cloneWithWhere(node, filter) {
+    cloneWithWhere(node, operation) {
         return freeze({
             ...node,
             where: node.where
-                ? WhereNode.cloneWithFilter(node.where, 'And', filter)
-                : WhereNode.create(filter),
+                ? WhereNode.cloneWithOperation(node.where, 'And', operation)
+                : WhereNode.create(operation),
         });
     },
-    cloneWithOrWhere(node, filter) {
+    cloneWithOrWhere(node, operation) {
         return freeze({
             ...node,
             where: node.where
-                ? WhereNode.cloneWithFilter(node.where, 'Or', filter)
-                : WhereNode.create(filter),
+                ? WhereNode.cloneWithOperation(node.where, 'Or', operation)
+                : WhereNode.create(operation),
         });
     },
     cloneWithJoin(node, join) {

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

@@ -1,10 +1,9 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
 export interface SelectModifierNode extends OperationNode {
     readonly kind: 'SelectModifierNode';
     readonly modifier?: SelectModifier;
-    readonly rawModifier?: RawNode;
+    readonly rawModifier?: OperationNode;
 }
 /**
  * @internal
@@ -12,5 +11,5 @@ export interface SelectModifierNode extends OperationNode {
 export declare const SelectModifierNode: Readonly<{
     is(node: OperationNode): node is SelectModifierNode;
     create(modifier: SelectModifier): SelectModifierNode;
-    createWithRaw(modifier: RawNode): SelectModifierNode;
+    createWithExpression(modifier: OperationNode): SelectModifierNode;
 }>;

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

@@ -13,7 +13,7 @@ export const SelectModifierNode = freeze({
             modifier,
         });
     },
-    createWithRaw(modifier) {
+    createWithExpression(modifier) {
         return freeze({
             kind: 'SelectModifierNode',
             rawModifier: modifier,

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

@@ -6,20 +6,19 @@ import { JoinNode } from './join-node.js';
 import { LimitNode } from './limit-node.js';
 import { OffsetNode } from './offset-node.js';
 import { OperationNode } from './operation-node.js';
-import { FilterExpressionNode, TableExpressionNode } from './operation-node-utils.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 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;
     readonly selections?: ReadonlyArray<SelectionNode>;
-    readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
+    readonly distinctOn?: ReadonlyArray<OperationNode>;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
@@ -30,25 +29,25 @@ 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
  */
 export declare const SelectQueryNode: Readonly<{
     is(node: OperationNode): node is SelectQueryNode;
-    create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode): SelectQueryNode;
+    create(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
-    cloneWithDistinctOnSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
+    cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItem(selectNode: SelectQueryNode, item: OrderByItemNode): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
+    cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
 }>;

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

@@ -26,12 +26,12 @@ export const SelectQueryNode = freeze({
                 : freeze(selections),
         });
     },
-    cloneWithDistinctOnSelections(select, selections) {
+    cloneWithDistinctOn(select, expressions) {
         return freeze({
             ...select,
-            distinctOnSelections: select.distinctOnSelections
-                ? freeze([...select.distinctOnSelections, ...selections])
-                : freeze(selections),
+            distinctOn: select.distinctOn
+                ? freeze([...select.distinctOn, ...expressions])
+                : freeze(expressions),
         });
     },
     cloneWithFrontModifier(select, modifier) {
@@ -78,28 +78,28 @@ export const SelectQueryNode = freeze({
             offset,
         });
     },
-    cloneWithHaving(selectNode, filter) {
+    cloneWithHaving(selectNode, operation) {
         return freeze({
             ...selectNode,
             having: selectNode.having
-                ? HavingNode.cloneWithFilter(selectNode.having, 'And', filter)
-                : HavingNode.create(filter),
+                ? HavingNode.cloneWithOperation(selectNode.having, 'And', operation)
+                : HavingNode.create(operation),
         });
     },
-    cloneWithOrHaving(selectNode, filter) {
+    cloneWithOrHaving(selectNode, operation) {
         return freeze({
             ...selectNode,
             having: selectNode.having
-                ? HavingNode.cloneWithFilter(selectNode.having, 'Or', filter)
-                : HavingNode.create(filter),
+                ? HavingNode.cloneWithOperation(selectNode.having, 'Or', operation)
+                : HavingNode.create(operation),
         });
     },
-    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/selection-node.d.ts

@@ -1,10 +1,9 @@
 import { AliasNode } from './alias-node.js';
-import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
-import { ReferenceNode } from './reference-node.js';
 import { SelectAllNode } from './select-all-node.js';
+import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { TableNode } from './table-node.js';
-declare type SelectionNodeChild = ColumnNode | ReferenceNode | AliasNode | SelectAllNode;
+declare type SelectionNodeChild = SimpleReferenceExpressionNode | AliasNode | SelectAllNode;
 export interface SelectionNode extends OperationNode {
     readonly kind: 'SelectionNode';
     readonly selection: SelectionNodeChild;

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

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+export declare type SetOperator = 'union' | 'intersect' | 'except';
+export interface SetOperationNode extends OperationNode {
+    kind: 'SetOperationNode';
+    operator: SetOperator;
+    expression: OperationNode;
+    all: boolean;
+}
+/**
+ * @internal
+ */
+export declare const SetOperationNode: Readonly<{
+    is(node: OperationNode): node is SetOperationNode;
+    create(operator: SetOperator, expression: OperationNode, 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/simple-reference-expression-node.d.ts

@@ -0,0 +1,3 @@
+import { ColumnNode } from './column-node.js';
+import { ReferenceNode } from './reference-node.js';
+export declare type SimpleReferenceExpressionNode = ColumnNode | ReferenceNode;

package/dist/esm/operation-node/simple-reference-expression-node.js

@@ -0,0 +1,2 @@
+/// <reference types="./simple-reference-expression-node.d.ts" />
+export {};

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

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

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

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

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

@@ -1,7 +1,6 @@
 import { ColumnUpdateNode } from './column-update-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 import { PrimitiveValueListNode } from './primitive-value-list-node.js';
 import { ReturningNode } from './returning-node.js';
 import { ValueListNode } from './value-list-node.js';
@@ -12,7 +11,7 @@ import { ExplainNode } from './explain-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
-    readonly table: TableExpressionNode;
+    readonly table: OperationNode;
     readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
@@ -26,8 +25,8 @@ export interface UpdateQueryNode extends OperationNode {
  */
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
-    create(table: TableExpressionNode, withNode?: WithNode): UpdateQueryNode;
-    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
+    create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
     cloneWithExplain(updateQuery: UpdateQueryNode, explain: ExplainNode): UpdateQueryNode;
 }>;