kysely 0.27.2 → 0.27.4

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

@@ -85,7 +85,13 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { MatchedNode } from './matched-node.js';
 import { AddIndexNode } from './add-index-node.js';
+import { CastNode } from './cast-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -200,7 +206,13 @@ export declare class OperationNodeTransformer {
     protected transformJSONPathLeg(node: JSONPathLegNode): JSONPathLegNode;
     protected transformJSONOperatorChain(node: JSONOperatorChainNode): JSONOperatorChainNode;
     protected transformTuple(node: TupleNode): TupleNode;
+    protected transformMergeQuery(node: MergeQueryNode): MergeQueryNode;
+    protected transformMatched(node: MatchedNode): MatchedNode;
     protected transformAddIndex(node: AddIndexNode): AddIndexNode;
+    protected transformCast(node: CastNode): CastNode;
+    protected transformFetch(node: FetchNode): FetchNode;
+    protected transformTop(node: TopNode): TopNode;
+    protected transformOutput(node: OutputNode): OutputNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -121,7 +121,13 @@ class OperationNodeTransformer {
         JSONPathLegNode: this.transformJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
         TupleNode: this.transformTuple.bind(this),
+        MergeQueryNode: this.transformMergeQuery.bind(this),
+        MatchedNode: this.transformMatched.bind(this),
         AddIndexNode: this.transformAddIndex.bind(this),
+        CastNode: this.transformCast.bind(this),
+        FetchNode: this.transformFetch.bind(this),
+        TopNode: this.transformTop.bind(this),
+        OutputNode: this.transformOutput.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -159,6 +165,8 @@ class OperationNodeTransformer {
             having: this.transformNode(node.having),
             explain: this.transformNode(node.explain),
             setOperations: this.transformNodeList(node.setOperations),
+            fetch: this.transformNode(node.fetch),
+            top: this.transformNode(node.top),
         });
     }
     transformSelection(node) {
@@ -260,6 +268,8 @@ class OperationNodeTransformer {
             replace: node.replace,
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformValues(node) {
@@ -280,6 +290,8 @@ class OperationNodeTransformer {
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
             explain: this.transformNode(node.explain),
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformReturning(node) {
@@ -319,6 +331,8 @@ class OperationNodeTransformer {
             frontModifiers: this.transformNodeList(node.frontModifiers),
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
+            identity: node.identity,
+            ifNotExists: node.ifNotExists,
         });
     }
     transformAddColumn(node) {
@@ -371,6 +385,9 @@ class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
             explain: this.transformNode(node.explain),
+            limit: this.transformNode(node.limit),
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformColumnUpdate(node) {
@@ -774,6 +791,24 @@ class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
         });
     }
+    transformMergeQuery(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'MergeQueryNode',
+            into: this.transformNode(node.into),
+            using: this.transformNode(node.using),
+            whens: this.transformNodeList(node.whens),
+            with: this.transformNode(node.with),
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
+        });
+    }
+    transformMatched(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'MatchedNode',
+            not: node.not,
+            bySource: node.bySource,
+        });
+    }
     transformAddIndex(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AddIndexNode',
@@ -784,6 +819,33 @@ class OperationNodeTransformer {
             ifNotExists: node.ifNotExists,
         });
     }
+    transformCast(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'CastNode',
+            expression: this.transformNode(node.expression),
+            dataType: this.transformNode(node.dataType),
+        });
+    }
+    transformFetch(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'FetchNode',
+            rowCount: this.transformNode(node.rowCount),
+            modifier: node.modifier,
+        });
+    }
+    transformTop(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'TopNode',
+            expression: node.expression,
+            modifiers: node.modifiers,
+        });
+    }
+    transformOutput(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'OutputNode',
+            selections: this.transformNodeList(node.selections),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -85,7 +85,13 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { MatchedNode } from './matched-node.js';
 import { AddIndexNode } from './add-index-node.js';
+import { CastNode } from './cast-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -177,5 +183,11 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
     protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
     protected abstract visitTuple(node: TupleNode): void;
+    protected abstract visitMergeQuery(node: MergeQueryNode): void;
+    protected abstract visitMatched(node: MatchedNode): void;
     protected abstract visitAddIndex(node: AddIndexNode): void;
+    protected abstract visitCast(node: CastNode): void;
+    protected abstract visitFetch(node: FetchNode): void;
+    protected abstract visitTop(node: TopNode): void;
+    protected abstract visitOutput(node: OutputNode): void;
 }

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

@@ -94,7 +94,13 @@ class OperationNodeVisitor {
         JSONPathLegNode: this.visitJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
         TupleNode: this.visitTuple.bind(this),
+        MergeQueryNode: this.visitMergeQuery.bind(this),
+        MatchedNode: this.visitMatched.bind(this),
         AddIndexNode: this.visitAddIndex.bind(this),
+        CastNode: this.visitCast.bind(this),
+        FetchNode: this.visitFetch.bind(this),
+        TopNode: this.visitTop.bind(this),
+        OutputNode: this.visitOutput.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export 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' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'AddIndexNode';
+export 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' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode' | 'OutputNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,11 +1,11 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
 export declare const JSON_OPERATORS: readonly ["->", "->>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare const UNARY_OPERATORS: readonly ["not", "-", "exists", "not exists"];
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
 export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
 export type JSONOperator = (typeof JSON_OPERATORS)[number];

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

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJSONOperator = exports.isArithmeticOperator = exports.isComparisonOperator = exports.isBinaryOperator = exports.isOperator = exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.JSON_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.JSON_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+exports.isOperator = isOperator;
+exports.isBinaryOperator = isBinaryOperator;
+exports.isComparisonOperator = isComparisonOperator;
+exports.isArithmeticOperator = isArithmeticOperator;
+exports.isJSONOperator = isJSONOperator;
 const object_utils_js_1 = require("../util/object-utils.js");
 exports.COMPARISON_OPERATORS = [
     '=',
@@ -22,9 +27,11 @@ exports.COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '^@',
     '&&',
     '?',
     '?&',
+    '?|',
     '!<',
     '!>',
     '<=>',
@@ -86,20 +93,15 @@ exports.OperatorNode = (0, object_utils_js_1.freeze)({
 function isOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.OPERATORS.includes(op);
 }
-exports.isOperator = isOperator;
 function isBinaryOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.BINARY_OPERATORS.includes(op);
 }
-exports.isBinaryOperator = isBinaryOperator;
 function isComparisonOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.COMPARISON_OPERATORS.includes(op);
 }
-exports.isComparisonOperator = isComparisonOperator;
 function isArithmeticOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.ARITHMETIC_OPERATORS.includes(op);
 }
-exports.isArithmeticOperator = isArithmeticOperator;
 function isJSONOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.JSON_OPERATORS.includes(op);
 }
-exports.isJSONOperator = isJSONOperator;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.OutputNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OutputNode';
+    },
+    create(selections) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OutputNode',
+            selections: (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+    cloneWithSelections(output, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...output,
+            selections: output.selections
+                ? (0, object_utils_js_1.freeze)([...output.selections, ...selections])
+                : (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+});

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

@@ -10,7 +10,10 @@ import { OperationNode } from './operation-node.js';
 import { ExplainNode } from './explain-node.js';
 import { ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
-export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
+import { MergeQueryNode } from './merge-query-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
+export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
 };
@@ -23,15 +26,24 @@ type HasReturning = {
 type HasExplain = {
     explain?: ExplainNode;
 };
+type HasTop = {
+    top?: TopNode;
+};
+type HasOutput = {
+    output?: OutputNode;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
-    cloneWithJoin<T_1 extends HasJoins>(node: T_1, join: JoinNode): T_1;
-    cloneWithReturning<T_2 extends HasReturning>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
-    cloneWithoutWhere<T_3 extends HasWhere>(node: T_3): T_3;
-    cloneWithExplain<T_4 extends HasExplain>(node: T_4, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_4;
+    cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): T;
+    cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): T;
+    cloneWithoutReturning<T extends HasReturning>(node: T): T;
+    cloneWithoutWhere<T extends HasWhere>(node: T): T;
+    cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): T;
+    cloneWithTop<T extends HasTop>(node: T, top: TopNode): T;
+    cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): T;
 }>;
 export {};

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

@@ -9,6 +9,8 @@ const where_node_js_1 = require("./where-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const returning_node_js_1 = require("./returning-node.js");
 const explain_node_js_1 = require("./explain-node.js");
+const merge_query_node_js_1 = require("./merge-query-node.js");
+const output_node_js_1 = require("./output-node.js");
 /**
  * @internal
  */
@@ -17,7 +19,8 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
         return (select_query_node_js_1.SelectQueryNode.is(node) ||
             insert_query_node_js_1.InsertQueryNode.is(node) ||
             update_query_node_js_1.UpdateQueryNode.is(node) ||
-            delete_query_node_js_1.DeleteQueryNode.is(node));
+            delete_query_node_js_1.DeleteQueryNode.is(node) ||
+            merge_query_node_js_1.MergeQueryNode.is(node));
     },
     cloneWithWhere(node, operation) {
         return (0, object_utils_js_1.freeze)({
@@ -41,6 +44,12 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
                 : returning_node_js_1.ReturningNode.create(selections),
         });
     },
+    cloneWithoutReturning(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            returning: undefined,
+        });
+    },
     cloneWithoutWhere(node) {
         return (0, object_utils_js_1.freeze)({
             ...node,
@@ -53,4 +62,18 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             explain: explain_node_js_1.ExplainNode.create(format, options?.toOperationNode()),
         });
     },
+    cloneWithTop(node, top) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            top,
+        });
+    },
+    cloneWithOutput(node, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            output: node.output
+                ? output_node_js_1.OutputNode.cloneWithSelections(node.output, selections)
+                : output_node_js_1.OutputNode.create(selections),
+        });
+    },
 });

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

@@ -14,6 +14,8 @@ import { WithNode } from './with-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { ExplainNode } from './explain-node.js';
 import { SetOperationNode } from './set-operation-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from?: FromNode;
@@ -31,6 +33,8 @@ export interface SelectQueryNode extends OperationNode {
     readonly having?: HavingNode;
     readonly explain?: ExplainNode;
     readonly setOperations?: ReadonlyArray<SetOperationNode>;
+    readonly fetch?: FetchNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -47,10 +51,12 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
+    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
 }>;

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

@@ -86,6 +86,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             offset,
         });
     },
+    cloneWithFetch(selectNode, fetch) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            fetch,
+        });
+    },
     cloneWithHaving(selectNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
@@ -126,4 +132,10 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             orderBy: undefined,
         });
     },
+    cloneWithoutGroupBy(select) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            groupBy: undefined,
+        });
+    },
 });

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export type TopModifier = 'percent' | 'with ties' | 'percent with ties';
+export interface TopNode extends OperationNode {
+    readonly kind: 'TopNode';
+    readonly expression: number | bigint;
+    readonly modifiers?: TopModifier;
+}
+/**
+ * @internal
+ */
+export declare const TopNode: Readonly<{
+    is(node: OperationNode): node is TopNode;
+    create(expression: number | bigint, modifiers?: TopModifier): TopNode;
+}>;

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

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

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

@@ -8,10 +8,13 @@ import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { FromNode } from './from-node.js';
 import { ExplainNode } from './explain-node.js';
+import { LimitNode } from './limit-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
-    readonly table: OperationNode;
+    readonly table?: OperationNode;
     readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
@@ -19,6 +22,9 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
     readonly explain?: ExplainNode;
+    readonly limit?: LimitNode;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal
@@ -26,6 +32,8 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
+    createWithoutTable(): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
+    cloneWithLimit(updateQuery: UpdateQueryNode, limit: LimitNode): UpdateQueryNode;
 }>;

package/dist/cjs/operation-node/update-query-node.js

@@ -17,6 +17,11 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
             ...(withNode && { with: withNode }),
         });
     },
+    createWithoutTable() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UpdateQueryNode',
+        });
+    },
     cloneWithFromItems(updateQuery, fromItems) {
         return (0, object_utils_js_1.freeze)({
             ...updateQuery,
@@ -33,4 +38,10 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
                 : updates,
         });
     },
+    cloneWithLimit(updateQuery, limit) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            limit,
+        });
+    },
 });

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

@@ -9,5 +9,5 @@ export interface WhereNode extends OperationNode {
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
     create(filter: OperationNode): WhereNode;
-    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): WhereNode;
+    cloneWithOperation(whereNode: WhereNode, operator: "And" | "Or", operation: OperationNode): WhereNode;
 }>;

package/dist/cjs/parser/binary-operation-parser.d.ts

@@ -18,4 +18,4 @@ export declare function parseValueBinaryOperationOrExpression(args: any[]): Oper
 export declare function parseValueBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseReferentialBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseFilterObject(obj: Readonly<FilterObject<any, any>>, combinator: 'and' | 'or'): OperationNode;
-export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or'): OperationNode;
+export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or', withParens?: boolean): OperationNode;

package/dist/cjs/parser/binary-operation-parser.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFilterList = exports.parseFilterObject = exports.parseReferentialBinaryOperation = exports.parseValueBinaryOperation = exports.parseValueBinaryOperationOrExpression = void 0;
+exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
+exports.parseValueBinaryOperation = parseValueBinaryOperation;
+exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
+exports.parseFilterObject = parseFilterObject;
+exports.parseFilterList = parseFilterList;
 const binary_operation_node_js_1 = require("../operation-node/binary-operation-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
@@ -20,25 +24,21 @@ function parseValueBinaryOperationOrExpression(args) {
     }
     throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
 }
-exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
 function parseValueBinaryOperation(left, operator, right) {
     if (isIsOperator(operator) && needsIsOperator(right)) {
         return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), value_node_js_1.ValueNode.createImmediate(right));
     }
     return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(right));
 }
-exports.parseValueBinaryOperation = parseValueBinaryOperation;
 function parseReferentialBinaryOperation(left, operator, right) {
     return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(right));
 }
-exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
 function parseFilterObject(obj, combinator) {
     return parseFilterList(Object.entries(obj)
         .filter(([, v]) => !(0, object_utils_js_1.isUndefined)(v))
         .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
-exports.parseFilterObject = parseFilterObject;
-function parseFilterList(list, combinator) {
+function parseFilterList(list, combinator, withParens = true) {
     const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
     if (list.length === 0) {
         return binary_operation_node_js_1.BinaryOperationNode.create(value_node_js_1.ValueNode.createImmediate(1), operator_node_js_1.OperatorNode.create('='), value_node_js_1.ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
@@ -47,12 +47,11 @@ function parseFilterList(list, combinator) {
     for (let i = 1; i < list.length; ++i) {
         node = combine(node, toOperationNode(list[i]));
     }
-    if (list.length > 1) {
+    if (list.length > 1 && withParens) {
         return parens_node_js_1.ParensNode.create(node);
     }
     return node;
 }
-exports.parseFilterList = parseFilterList;
 function isIsOperator(operator) {
     return operator === 'is' || operator === 'is not';
 }

package/dist/cjs/parser/data-type-parser.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDataTypeExpression = void 0;
+exports.parseDataTypeExpression = parseDataTypeExpression;
 const data_type_node_js_1 = require("../operation-node/data-type-node.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 function parseDataTypeExpression(dataType) {
-    return (0, operation_node_source_js_1.isOperationNodeSource)(dataType)
-        ? dataType.toOperationNode()
-        : data_type_node_js_1.DataTypeNode.create(dataType);
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(dataType)) {
+        return dataType.toOperationNode();
+    }
+    if ((0, data_type_node_js_1.isColumnDataType)(dataType)) {
+        return data_type_node_js_1.DataTypeNode.create(dataType);
+    }
+    throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
 }
-exports.parseDataTypeExpression = parseDataTypeExpression;