kysely 0.27.5 → 0.28.0

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

@@ -97,8 +97,10 @@ export class OperationNodeTransformer {
         ModifyColumnNode: this.transformModifyColumn.bind(this),
         AddConstraintNode: this.transformAddConstraint.bind(this),
         DropConstraintNode: this.transformDropConstraint.bind(this),
+        RenameConstraintNode: this.transformRenameConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
+        RefreshMaterializedViewNode: this.transformRefreshMaterializedView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
         GeneratedNode: this.transformGenerated.bind(this),
         DefaultValueNode: this.transformDefaultValue.bind(this),
@@ -132,754 +134,792 @@ export class OperationNodeTransformer {
         FetchNode: this.transformFetch.bind(this),
         TopNode: this.transformTop.bind(this),
         OutputNode: this.transformOutput.bind(this),
+        OrActionNode: this.transformOrAction.bind(this),
+        CollateNode: this.transformCollate.bind(this),
     });
-    transformNode(node) {
+    transformNode(node, queryId) {
         if (!node) {
             return node;
         }
         this.nodeStack.push(node);
-        const out = this.transformNodeImpl(node);
+        const out = this.transformNodeImpl(node, queryId);
         this.nodeStack.pop();
         return freeze(out);
     }
-    transformNodeImpl(node) {
-        return this.#transformers[node.kind](node);
+    transformNodeImpl(node, queryId) {
+        return this.#transformers[node.kind](node, queryId);
     }
-    transformNodeList(list) {
+    transformNodeList(list, queryId) {
         if (!list) {
             return list;
         }
-        return freeze(list.map((node) => this.transformNode(node)));
+        return freeze(list.map((node) => this.transformNode(node, queryId)));
     }
-    transformSelectQuery(node) {
+    transformSelectQuery(node, queryId) {
         return requireAllProps({
             kind: 'SelectQueryNode',
-            from: this.transformNode(node.from),
-            selections: this.transformNodeList(node.selections),
-            distinctOn: this.transformNodeList(node.distinctOn),
-            joins: this.transformNodeList(node.joins),
-            groupBy: this.transformNode(node.groupBy),
-            orderBy: this.transformNode(node.orderBy),
-            where: this.transformNode(node.where),
-            frontModifiers: this.transformNodeList(node.frontModifiers),
-            endModifiers: this.transformNodeList(node.endModifiers),
-            limit: this.transformNode(node.limit),
-            offset: this.transformNode(node.offset),
-            with: this.transformNode(node.with),
-            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) {
+            from: this.transformNode(node.from, queryId),
+            selections: this.transformNodeList(node.selections, queryId),
+            distinctOn: this.transformNodeList(node.distinctOn, queryId),
+            joins: this.transformNodeList(node.joins, queryId),
+            groupBy: this.transformNode(node.groupBy, queryId),
+            orderBy: this.transformNode(node.orderBy, queryId),
+            where: this.transformNode(node.where, queryId),
+            frontModifiers: this.transformNodeList(node.frontModifiers, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
+            limit: this.transformNode(node.limit, queryId),
+            offset: this.transformNode(node.offset, queryId),
+            with: this.transformNode(node.with, queryId),
+            having: this.transformNode(node.having, queryId),
+            explain: this.transformNode(node.explain, queryId),
+            setOperations: this.transformNodeList(node.setOperations, queryId),
+            fetch: this.transformNode(node.fetch, queryId),
+            top: this.transformNode(node.top, queryId),
+        });
+    }
+    transformSelection(node, queryId) {
         return requireAllProps({
             kind: 'SelectionNode',
-            selection: this.transformNode(node.selection),
+            selection: this.transformNode(node.selection, queryId),
         });
     }
-    transformColumn(node) {
+    transformColumn(node, queryId) {
         return requireAllProps({
             kind: 'ColumnNode',
-            column: this.transformNode(node.column),
+            column: this.transformNode(node.column, queryId),
         });
     }
-    transformAlias(node) {
+    transformAlias(node, queryId) {
         return requireAllProps({
             kind: 'AliasNode',
-            node: this.transformNode(node.node),
-            alias: this.transformNode(node.alias),
+            node: this.transformNode(node.node, queryId),
+            alias: this.transformNode(node.alias, queryId),
         });
     }
-    transformTable(node) {
+    transformTable(node, queryId) {
         return requireAllProps({
             kind: 'TableNode',
-            table: this.transformNode(node.table),
+            table: this.transformNode(node.table, queryId),
         });
     }
-    transformFrom(node) {
+    transformFrom(node, queryId) {
         return requireAllProps({
             kind: 'FromNode',
-            froms: this.transformNodeList(node.froms),
+            froms: this.transformNodeList(node.froms, queryId),
         });
     }
-    transformReference(node) {
+    transformReference(node, queryId) {
         return requireAllProps({
             kind: 'ReferenceNode',
-            column: this.transformNode(node.column),
-            table: this.transformNode(node.table),
+            column: this.transformNode(node.column, queryId),
+            table: this.transformNode(node.table, queryId),
         });
     }
-    transformAnd(node) {
+    transformAnd(node, queryId) {
         return requireAllProps({
             kind: 'AndNode',
-            left: this.transformNode(node.left),
-            right: this.transformNode(node.right),
+            left: this.transformNode(node.left, queryId),
+            right: this.transformNode(node.right, queryId),
         });
     }
-    transformOr(node) {
+    transformOr(node, queryId) {
         return requireAllProps({
             kind: 'OrNode',
-            left: this.transformNode(node.left),
-            right: this.transformNode(node.right),
+            left: this.transformNode(node.left, queryId),
+            right: this.transformNode(node.right, queryId),
         });
     }
-    transformValueList(node) {
+    transformValueList(node, queryId) {
         return requireAllProps({
             kind: 'ValueListNode',
-            values: this.transformNodeList(node.values),
+            values: this.transformNodeList(node.values, queryId),
         });
     }
-    transformParens(node) {
+    transformParens(node, queryId) {
         return requireAllProps({
             kind: 'ParensNode',
-            node: this.transformNode(node.node),
+            node: this.transformNode(node.node, queryId),
         });
     }
-    transformJoin(node) {
+    transformJoin(node, queryId) {
         return requireAllProps({
             kind: 'JoinNode',
             joinType: node.joinType,
-            table: this.transformNode(node.table),
-            on: this.transformNode(node.on),
+            table: this.transformNode(node.table, queryId),
+            on: this.transformNode(node.on, queryId),
         });
     }
-    transformRaw(node) {
+    transformRaw(node, queryId) {
         return requireAllProps({
             kind: 'RawNode',
             sqlFragments: freeze([...node.sqlFragments]),
-            parameters: this.transformNodeList(node.parameters),
+            parameters: this.transformNodeList(node.parameters, queryId),
         });
     }
-    transformWhere(node) {
+    transformWhere(node, queryId) {
         return requireAllProps({
             kind: 'WhereNode',
-            where: this.transformNode(node.where),
+            where: this.transformNode(node.where, queryId),
         });
     }
-    transformInsertQuery(node) {
+    transformInsertQuery(node, queryId) {
         return requireAllProps({
             kind: 'InsertQueryNode',
-            into: this.transformNode(node.into),
-            columns: this.transformNodeList(node.columns),
-            values: this.transformNode(node.values),
-            returning: this.transformNode(node.returning),
-            onConflict: this.transformNode(node.onConflict),
-            onDuplicateKey: this.transformNode(node.onDuplicateKey),
-            endModifiers: this.transformNodeList(node.endModifiers),
-            with: this.transformNode(node.with),
+            into: this.transformNode(node.into, queryId),
+            columns: this.transformNodeList(node.columns, queryId),
+            values: this.transformNode(node.values, queryId),
+            returning: this.transformNode(node.returning, queryId),
+            onConflict: this.transformNode(node.onConflict, queryId),
+            onDuplicateKey: this.transformNode(node.onDuplicateKey, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
+            with: this.transformNode(node.with, queryId),
             ignore: node.ignore,
+            orAction: this.transformNode(node.orAction, queryId),
             replace: node.replace,
-            explain: this.transformNode(node.explain),
+            explain: this.transformNode(node.explain, queryId),
             defaultValues: node.defaultValues,
-            top: this.transformNode(node.top),
-            output: this.transformNode(node.output),
+            top: this.transformNode(node.top, queryId),
+            output: this.transformNode(node.output, queryId),
         });
     }
-    transformValues(node) {
+    transformValues(node, queryId) {
         return requireAllProps({
             kind: 'ValuesNode',
-            values: this.transformNodeList(node.values),
+            values: this.transformNodeList(node.values, queryId),
         });
     }
-    transformDeleteQuery(node) {
+    transformDeleteQuery(node, queryId) {
         return requireAllProps({
             kind: 'DeleteQueryNode',
-            from: this.transformNode(node.from),
-            using: this.transformNode(node.using),
-            joins: this.transformNodeList(node.joins),
-            where: this.transformNode(node.where),
-            returning: this.transformNode(node.returning),
-            endModifiers: this.transformNodeList(node.endModifiers),
-            with: this.transformNode(node.with),
-            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) {
+            from: this.transformNode(node.from, queryId),
+            using: this.transformNode(node.using, queryId),
+            joins: this.transformNodeList(node.joins, queryId),
+            where: this.transformNode(node.where, queryId),
+            returning: this.transformNode(node.returning, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
+            with: this.transformNode(node.with, queryId),
+            orderBy: this.transformNode(node.orderBy, queryId),
+            limit: this.transformNode(node.limit, queryId),
+            explain: this.transformNode(node.explain, queryId),
+            top: this.transformNode(node.top, queryId),
+            output: this.transformNode(node.output, queryId),
+        });
+    }
+    transformReturning(node, queryId) {
         return requireAllProps({
             kind: 'ReturningNode',
-            selections: this.transformNodeList(node.selections),
+            selections: this.transformNodeList(node.selections, queryId),
         });
     }
-    transformCreateTable(node) {
+    transformCreateTable(node, queryId) {
         return requireAllProps({
             kind: 'CreateTableNode',
-            table: this.transformNode(node.table),
-            columns: this.transformNodeList(node.columns),
-            constraints: this.transformNodeList(node.constraints),
+            table: this.transformNode(node.table, queryId),
+            columns: this.transformNodeList(node.columns, queryId),
+            constraints: this.transformNodeList(node.constraints, queryId),
             temporary: node.temporary,
             ifNotExists: node.ifNotExists,
             onCommit: node.onCommit,
-            frontModifiers: this.transformNodeList(node.frontModifiers),
-            endModifiers: this.transformNodeList(node.endModifiers),
-            selectQuery: this.transformNode(node.selectQuery),
+            frontModifiers: this.transformNodeList(node.frontModifiers, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
+            selectQuery: this.transformNode(node.selectQuery, queryId),
         });
     }
-    transformColumnDefinition(node) {
+    transformColumnDefinition(node, queryId) {
         return requireAllProps({
             kind: 'ColumnDefinitionNode',
-            column: this.transformNode(node.column),
-            dataType: this.transformNode(node.dataType),
-            references: this.transformNode(node.references),
+            column: this.transformNode(node.column, queryId),
+            dataType: this.transformNode(node.dataType, queryId),
+            references: this.transformNode(node.references, queryId),
             primaryKey: node.primaryKey,
             autoIncrement: node.autoIncrement,
             unique: node.unique,
             notNull: node.notNull,
             unsigned: node.unsigned,
-            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),
+            defaultTo: this.transformNode(node.defaultTo, queryId),
+            check: this.transformNode(node.check, queryId),
+            generated: this.transformNode(node.generated, queryId),
+            frontModifiers: this.transformNodeList(node.frontModifiers, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
             nullsNotDistinct: node.nullsNotDistinct,
             identity: node.identity,
             ifNotExists: node.ifNotExists,
         });
     }
-    transformAddColumn(node) {
+    transformAddColumn(node, queryId) {
         return requireAllProps({
             kind: 'AddColumnNode',
-            column: this.transformNode(node.column),
+            column: this.transformNode(node.column, queryId),
         });
     }
-    transformDropTable(node) {
+    transformDropTable(node, queryId) {
         return requireAllProps({
             kind: 'DropTableNode',
-            table: this.transformNode(node.table),
+            table: this.transformNode(node.table, queryId),
             ifExists: node.ifExists,
             cascade: node.cascade,
         });
     }
-    transformOrderBy(node) {
+    transformOrderBy(node, queryId) {
         return requireAllProps({
             kind: 'OrderByNode',
-            items: this.transformNodeList(node.items),
+            items: this.transformNodeList(node.items, queryId),
         });
     }
-    transformOrderByItem(node) {
+    transformOrderByItem(node, queryId) {
         return requireAllProps({
             kind: 'OrderByItemNode',
-            orderBy: this.transformNode(node.orderBy),
-            direction: this.transformNode(node.direction),
+            orderBy: this.transformNode(node.orderBy, queryId),
+            direction: this.transformNode(node.direction, queryId),
+            collation: this.transformNode(node.collation, queryId),
+            nulls: node.nulls,
         });
     }
-    transformGroupBy(node) {
+    transformGroupBy(node, queryId) {
         return requireAllProps({
             kind: 'GroupByNode',
-            items: this.transformNodeList(node.items),
+            items: this.transformNodeList(node.items, queryId),
         });
     }
-    transformGroupByItem(node) {
+    transformGroupByItem(node, queryId) {
         return requireAllProps({
             kind: 'GroupByItemNode',
-            groupBy: this.transformNode(node.groupBy),
+            groupBy: this.transformNode(node.groupBy, queryId),
         });
     }
-    transformUpdateQuery(node) {
+    transformUpdateQuery(node, queryId) {
         return requireAllProps({
             kind: 'UpdateQueryNode',
-            table: this.transformNode(node.table),
-            from: this.transformNode(node.from),
-            joins: this.transformNodeList(node.joins),
-            where: this.transformNode(node.where),
-            updates: this.transformNodeList(node.updates),
-            returning: this.transformNode(node.returning),
-            endModifiers: this.transformNodeList(node.endModifiers),
-            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) {
+            table: this.transformNode(node.table, queryId),
+            from: this.transformNode(node.from, queryId),
+            joins: this.transformNodeList(node.joins, queryId),
+            where: this.transformNode(node.where, queryId),
+            updates: this.transformNodeList(node.updates, queryId),
+            returning: this.transformNode(node.returning, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
+            with: this.transformNode(node.with, queryId),
+            explain: this.transformNode(node.explain, queryId),
+            limit: this.transformNode(node.limit, queryId),
+            top: this.transformNode(node.top, queryId),
+            output: this.transformNode(node.output, queryId),
+            orderBy: this.transformNode(node.orderBy, queryId),
+        });
+    }
+    transformColumnUpdate(node, queryId) {
         return requireAllProps({
             kind: 'ColumnUpdateNode',
-            column: this.transformNode(node.column),
-            value: this.transformNode(node.value),
+            column: this.transformNode(node.column, queryId),
+            value: this.transformNode(node.value, queryId),
         });
     }
-    transformLimit(node) {
+    transformLimit(node, queryId) {
         return requireAllProps({
             kind: 'LimitNode',
-            limit: this.transformNode(node.limit),
+            limit: this.transformNode(node.limit, queryId),
         });
     }
-    transformOffset(node) {
+    transformOffset(node, queryId) {
         return requireAllProps({
             kind: 'OffsetNode',
-            offset: this.transformNode(node.offset),
+            offset: this.transformNode(node.offset, queryId),
         });
     }
-    transformOnConflict(node) {
+    transformOnConflict(node, queryId) {
         return requireAllProps({
             kind: 'OnConflictNode',
-            columns: this.transformNodeList(node.columns),
-            constraint: this.transformNode(node.constraint),
-            indexExpression: this.transformNode(node.indexExpression),
-            indexWhere: this.transformNode(node.indexWhere),
-            updates: this.transformNodeList(node.updates),
-            updateWhere: this.transformNode(node.updateWhere),
+            columns: this.transformNodeList(node.columns, queryId),
+            constraint: this.transformNode(node.constraint, queryId),
+            indexExpression: this.transformNode(node.indexExpression, queryId),
+            indexWhere: this.transformNode(node.indexWhere, queryId),
+            updates: this.transformNodeList(node.updates, queryId),
+            updateWhere: this.transformNode(node.updateWhere, queryId),
             doNothing: node.doNothing,
         });
     }
-    transformOnDuplicateKey(node) {
+    transformOnDuplicateKey(node, queryId) {
         return requireAllProps({
             kind: 'OnDuplicateKeyNode',
-            updates: this.transformNodeList(node.updates),
+            updates: this.transformNodeList(node.updates, queryId),
         });
     }
-    transformCreateIndex(node) {
+    transformCreateIndex(node, queryId) {
         return requireAllProps({
             kind: 'CreateIndexNode',
-            name: this.transformNode(node.name),
-            table: this.transformNode(node.table),
-            columns: this.transformNodeList(node.columns),
+            name: this.transformNode(node.name, queryId),
+            table: this.transformNode(node.table, queryId),
+            columns: this.transformNodeList(node.columns, queryId),
             unique: node.unique,
-            using: this.transformNode(node.using),
+            using: this.transformNode(node.using, queryId),
             ifNotExists: node.ifNotExists,
-            where: this.transformNode(node.where),
+            where: this.transformNode(node.where, queryId),
             nullsNotDistinct: node.nullsNotDistinct,
         });
     }
-    transformList(node) {
+    transformList(node, queryId) {
         return requireAllProps({
             kind: 'ListNode',
-            items: this.transformNodeList(node.items),
+            items: this.transformNodeList(node.items, queryId),
         });
     }
-    transformDropIndex(node) {
+    transformDropIndex(node, queryId) {
         return requireAllProps({
             kind: 'DropIndexNode',
-            name: this.transformNode(node.name),
-            table: this.transformNode(node.table),
+            name: this.transformNode(node.name, queryId),
+            table: this.transformNode(node.table, queryId),
             ifExists: node.ifExists,
             cascade: node.cascade,
         });
     }
-    transformPrimaryKeyConstraint(node) {
+    transformPrimaryKeyConstraint(node, queryId) {
         return requireAllProps({
             kind: 'PrimaryKeyConstraintNode',
-            columns: this.transformNodeList(node.columns),
-            name: this.transformNode(node.name),
+            columns: this.transformNodeList(node.columns, queryId),
+            name: this.transformNode(node.name, queryId),
+            deferrable: node.deferrable,
+            initiallyDeferred: node.initiallyDeferred,
         });
     }
-    transformUniqueConstraint(node) {
+    transformUniqueConstraint(node, queryId) {
         return requireAllProps({
             kind: 'UniqueConstraintNode',
-            columns: this.transformNodeList(node.columns),
-            name: this.transformNode(node.name),
+            columns: this.transformNodeList(node.columns, queryId),
+            name: this.transformNode(node.name, queryId),
             nullsNotDistinct: node.nullsNotDistinct,
+            deferrable: node.deferrable,
+            initiallyDeferred: node.initiallyDeferred,
         });
     }
-    transformForeignKeyConstraint(node) {
+    transformForeignKeyConstraint(node, queryId) {
         return requireAllProps({
             kind: 'ForeignKeyConstraintNode',
-            columns: this.transformNodeList(node.columns),
-            references: this.transformNode(node.references),
-            name: this.transformNode(node.name),
+            columns: this.transformNodeList(node.columns, queryId),
+            references: this.transformNode(node.references, queryId),
+            name: this.transformNode(node.name, queryId),
             onDelete: node.onDelete,
             onUpdate: node.onUpdate,
+            deferrable: node.deferrable,
+            initiallyDeferred: node.initiallyDeferred,
         });
     }
-    transformSetOperation(node) {
+    transformSetOperation(node, queryId) {
         return requireAllProps({
             kind: 'SetOperationNode',
             operator: node.operator,
-            expression: this.transformNode(node.expression),
+            expression: this.transformNode(node.expression, queryId),
             all: node.all,
         });
     }
-    transformReferences(node) {
+    transformReferences(node, queryId) {
         return requireAllProps({
             kind: 'ReferencesNode',
-            table: this.transformNode(node.table),
-            columns: this.transformNodeList(node.columns),
+            table: this.transformNode(node.table, queryId),
+            columns: this.transformNodeList(node.columns, queryId),
             onDelete: node.onDelete,
             onUpdate: node.onUpdate,
         });
     }
-    transformCheckConstraint(node) {
+    transformCheckConstraint(node, queryId) {
         return requireAllProps({
             kind: 'CheckConstraintNode',
-            expression: this.transformNode(node.expression),
-            name: this.transformNode(node.name),
+            expression: this.transformNode(node.expression, queryId),
+            name: this.transformNode(node.name, queryId),
         });
     }
-    transformWith(node) {
+    transformWith(node, queryId) {
         return requireAllProps({
             kind: 'WithNode',
-            expressions: this.transformNodeList(node.expressions),
+            expressions: this.transformNodeList(node.expressions, queryId),
             recursive: node.recursive,
         });
     }
-    transformCommonTableExpression(node) {
+    transformCommonTableExpression(node, queryId) {
         return requireAllProps({
             kind: 'CommonTableExpressionNode',
-            name: this.transformNode(node.name),
+            name: this.transformNode(node.name, queryId),
             materialized: node.materialized,
-            expression: this.transformNode(node.expression),
+            expression: this.transformNode(node.expression, queryId),
         });
     }
-    transformCommonTableExpressionName(node) {
+    transformCommonTableExpressionName(node, queryId) {
         return requireAllProps({
             kind: 'CommonTableExpressionNameNode',
-            table: this.transformNode(node.table),
-            columns: this.transformNodeList(node.columns),
+            table: this.transformNode(node.table, queryId),
+            columns: this.transformNodeList(node.columns, queryId),
         });
     }
-    transformHaving(node) {
+    transformHaving(node, queryId) {
         return requireAllProps({
             kind: 'HavingNode',
-            having: this.transformNode(node.having),
+            having: this.transformNode(node.having, queryId),
         });
     }
-    transformCreateSchema(node) {
+    transformCreateSchema(node, queryId) {
         return requireAllProps({
             kind: 'CreateSchemaNode',
-            schema: this.transformNode(node.schema),
+            schema: this.transformNode(node.schema, queryId),
             ifNotExists: node.ifNotExists,
         });
     }
-    transformDropSchema(node) {
+    transformDropSchema(node, queryId) {
         return requireAllProps({
             kind: 'DropSchemaNode',
-            schema: this.transformNode(node.schema),
+            schema: this.transformNode(node.schema, queryId),
             ifExists: node.ifExists,
             cascade: node.cascade,
         });
     }
-    transformAlterTable(node) {
+    transformAlterTable(node, queryId) {
         return requireAllProps({
             kind: 'AlterTableNode',
-            table: this.transformNode(node.table),
-            renameTo: this.transformNode(node.renameTo),
-            setSchema: this.transformNode(node.setSchema),
-            columnAlterations: this.transformNodeList(node.columnAlterations),
-            addConstraint: this.transformNode(node.addConstraint),
-            dropConstraint: this.transformNode(node.dropConstraint),
-            addIndex: this.transformNode(node.addIndex),
-            dropIndex: this.transformNode(node.dropIndex),
+            table: this.transformNode(node.table, queryId),
+            renameTo: this.transformNode(node.renameTo, queryId),
+            setSchema: this.transformNode(node.setSchema, queryId),
+            columnAlterations: this.transformNodeList(node.columnAlterations, queryId),
+            addConstraint: this.transformNode(node.addConstraint, queryId),
+            dropConstraint: this.transformNode(node.dropConstraint, queryId),
+            renameConstraint: this.transformNode(node.renameConstraint, queryId),
+            addIndex: this.transformNode(node.addIndex, queryId),
+            dropIndex: this.transformNode(node.dropIndex, queryId),
         });
     }
-    transformDropColumn(node) {
+    transformDropColumn(node, queryId) {
         return requireAllProps({
             kind: 'DropColumnNode',
-            column: this.transformNode(node.column),
+            column: this.transformNode(node.column, queryId),
         });
     }
-    transformRenameColumn(node) {
+    transformRenameColumn(node, queryId) {
         return requireAllProps({
             kind: 'RenameColumnNode',
-            column: this.transformNode(node.column),
-            renameTo: this.transformNode(node.renameTo),
+            column: this.transformNode(node.column, queryId),
+            renameTo: this.transformNode(node.renameTo, queryId),
         });
     }
-    transformAlterColumn(node) {
+    transformAlterColumn(node, queryId) {
         return requireAllProps({
             kind: 'AlterColumnNode',
-            column: this.transformNode(node.column),
-            dataType: this.transformNode(node.dataType),
-            dataTypeExpression: this.transformNode(node.dataTypeExpression),
-            setDefault: this.transformNode(node.setDefault),
+            column: this.transformNode(node.column, queryId),
+            dataType: this.transformNode(node.dataType, queryId),
+            dataTypeExpression: this.transformNode(node.dataTypeExpression, queryId),
+            setDefault: this.transformNode(node.setDefault, queryId),
             dropDefault: node.dropDefault,
             setNotNull: node.setNotNull,
             dropNotNull: node.dropNotNull,
         });
     }
-    transformModifyColumn(node) {
+    transformModifyColumn(node, queryId) {
         return requireAllProps({
             kind: 'ModifyColumnNode',
-            column: this.transformNode(node.column),
+            column: this.transformNode(node.column, queryId),
         });
     }
-    transformAddConstraint(node) {
+    transformAddConstraint(node, queryId) {
         return requireAllProps({
             kind: 'AddConstraintNode',
-            constraint: this.transformNode(node.constraint),
+            constraint: this.transformNode(node.constraint, queryId),
         });
     }
-    transformDropConstraint(node) {
+    transformDropConstraint(node, queryId) {
         return requireAllProps({
             kind: 'DropConstraintNode',
-            constraintName: this.transformNode(node.constraintName),
+            constraintName: this.transformNode(node.constraintName, queryId),
             ifExists: node.ifExists,
             modifier: node.modifier,
         });
     }
-    transformCreateView(node) {
+    transformRenameConstraint(node, queryId) {
+        return requireAllProps({
+            kind: 'RenameConstraintNode',
+            oldName: this.transformNode(node.oldName, queryId),
+            newName: this.transformNode(node.newName, queryId),
+        });
+    }
+    transformCreateView(node, queryId) {
         return requireAllProps({
             kind: 'CreateViewNode',
-            name: this.transformNode(node.name),
+            name: this.transformNode(node.name, queryId),
             temporary: node.temporary,
             orReplace: node.orReplace,
             ifNotExists: node.ifNotExists,
             materialized: node.materialized,
-            columns: this.transformNodeList(node.columns),
-            as: this.transformNode(node.as),
+            columns: this.transformNodeList(node.columns, queryId),
+            as: this.transformNode(node.as, queryId),
         });
     }
-    transformDropView(node) {
+    transformRefreshMaterializedView(node, queryId) {
+        return requireAllProps({
+            kind: 'RefreshMaterializedViewNode',
+            name: this.transformNode(node.name, queryId),
+            concurrently: node.concurrently,
+            withNoData: node.withNoData,
+        });
+    }
+    transformDropView(node, queryId) {
         return requireAllProps({
             kind: 'DropViewNode',
-            name: this.transformNode(node.name),
+            name: this.transformNode(node.name, queryId),
             ifExists: node.ifExists,
             materialized: node.materialized,
             cascade: node.cascade,
         });
     }
-    transformGenerated(node) {
+    transformGenerated(node, queryId) {
         return requireAllProps({
             kind: 'GeneratedNode',
             byDefault: node.byDefault,
             always: node.always,
             identity: node.identity,
             stored: node.stored,
-            expression: this.transformNode(node.expression),
+            expression: this.transformNode(node.expression, queryId),
         });
     }
-    transformDefaultValue(node) {
+    transformDefaultValue(node, queryId) {
         return requireAllProps({
             kind: 'DefaultValueNode',
-            defaultValue: this.transformNode(node.defaultValue),
+            defaultValue: this.transformNode(node.defaultValue, queryId),
         });
     }
-    transformOn(node) {
+    transformOn(node, queryId) {
         return requireAllProps({
             kind: 'OnNode',
-            on: this.transformNode(node.on),
+            on: this.transformNode(node.on, queryId),
         });
     }
-    transformSelectModifier(node) {
+    transformSelectModifier(node, queryId) {
         return requireAllProps({
             kind: 'SelectModifierNode',
             modifier: node.modifier,
-            rawModifier: this.transformNode(node.rawModifier),
-            of: this.transformNodeList(node.of),
+            rawModifier: this.transformNode(node.rawModifier, queryId),
+            of: this.transformNodeList(node.of, queryId),
         });
     }
-    transformCreateType(node) {
+    transformCreateType(node, queryId) {
         return requireAllProps({
             kind: 'CreateTypeNode',
-            name: this.transformNode(node.name),
-            enum: this.transformNode(node.enum),
+            name: this.transformNode(node.name, queryId),
+            enum: this.transformNode(node.enum, queryId),
         });
     }
-    transformDropType(node) {
+    transformDropType(node, queryId) {
         return requireAllProps({
             kind: 'DropTypeNode',
-            name: this.transformNode(node.name),
+            name: this.transformNode(node.name, queryId),
             ifExists: node.ifExists,
         });
     }
-    transformExplain(node) {
+    transformExplain(node, queryId) {
         return requireAllProps({
             kind: 'ExplainNode',
             format: node.format,
-            options: this.transformNode(node.options),
+            options: this.transformNode(node.options, queryId),
         });
     }
-    transformSchemableIdentifier(node) {
+    transformSchemableIdentifier(node, queryId) {
         return requireAllProps({
             kind: 'SchemableIdentifierNode',
-            schema: this.transformNode(node.schema),
-            identifier: this.transformNode(node.identifier),
+            schema: this.transformNode(node.schema, queryId),
+            identifier: this.transformNode(node.identifier, queryId),
         });
     }
-    transformAggregateFunction(node) {
+    transformAggregateFunction(node, queryId) {
         return requireAllProps({
             kind: 'AggregateFunctionNode',
-            aggregated: this.transformNodeList(node.aggregated),
-            distinct: node.distinct,
-            orderBy: this.transformNode(node.orderBy),
-            filter: this.transformNode(node.filter),
             func: node.func,
-            over: this.transformNode(node.over),
+            aggregated: this.transformNodeList(node.aggregated, queryId),
+            distinct: node.distinct,
+            orderBy: this.transformNode(node.orderBy, queryId),
+            withinGroup: this.transformNode(node.withinGroup, queryId),
+            filter: this.transformNode(node.filter, queryId),
+            over: this.transformNode(node.over, queryId),
         });
     }
-    transformOver(node) {
+    transformOver(node, queryId) {
         return requireAllProps({
             kind: 'OverNode',
-            orderBy: this.transformNode(node.orderBy),
-            partitionBy: this.transformNode(node.partitionBy),
+            orderBy: this.transformNode(node.orderBy, queryId),
+            partitionBy: this.transformNode(node.partitionBy, queryId),
         });
     }
-    transformPartitionBy(node) {
+    transformPartitionBy(node, queryId) {
         return requireAllProps({
             kind: 'PartitionByNode',
-            items: this.transformNodeList(node.items),
+            items: this.transformNodeList(node.items, queryId),
         });
     }
-    transformPartitionByItem(node) {
+    transformPartitionByItem(node, queryId) {
         return requireAllProps({
             kind: 'PartitionByItemNode',
-            partitionBy: this.transformNode(node.partitionBy),
+            partitionBy: this.transformNode(node.partitionBy, queryId),
         });
     }
-    transformBinaryOperation(node) {
+    transformBinaryOperation(node, queryId) {
         return requireAllProps({
             kind: 'BinaryOperationNode',
-            leftOperand: this.transformNode(node.leftOperand),
-            operator: this.transformNode(node.operator),
-            rightOperand: this.transformNode(node.rightOperand),
+            leftOperand: this.transformNode(node.leftOperand, queryId),
+            operator: this.transformNode(node.operator, queryId),
+            rightOperand: this.transformNode(node.rightOperand, queryId),
         });
     }
-    transformUnaryOperation(node) {
+    transformUnaryOperation(node, queryId) {
         return requireAllProps({
             kind: 'UnaryOperationNode',
-            operator: this.transformNode(node.operator),
-            operand: this.transformNode(node.operand),
+            operator: this.transformNode(node.operator, queryId),
+            operand: this.transformNode(node.operand, queryId),
         });
     }
-    transformUsing(node) {
+    transformUsing(node, queryId) {
         return requireAllProps({
             kind: 'UsingNode',
-            tables: this.transformNodeList(node.tables),
+            tables: this.transformNodeList(node.tables, queryId),
         });
     }
-    transformFunction(node) {
+    transformFunction(node, queryId) {
         return requireAllProps({
             kind: 'FunctionNode',
             func: node.func,
-            arguments: this.transformNodeList(node.arguments),
+            arguments: this.transformNodeList(node.arguments, queryId),
         });
     }
-    transformCase(node) {
+    transformCase(node, queryId) {
         return requireAllProps({
             kind: 'CaseNode',
-            value: this.transformNode(node.value),
-            when: this.transformNodeList(node.when),
-            else: this.transformNode(node.else),
+            value: this.transformNode(node.value, queryId),
+            when: this.transformNodeList(node.when, queryId),
+            else: this.transformNode(node.else, queryId),
             isStatement: node.isStatement,
         });
     }
-    transformWhen(node) {
+    transformWhen(node, queryId) {
         return requireAllProps({
             kind: 'WhenNode',
-            condition: this.transformNode(node.condition),
-            result: this.transformNode(node.result),
+            condition: this.transformNode(node.condition, queryId),
+            result: this.transformNode(node.result, queryId),
         });
     }
-    transformJSONReference(node) {
+    transformJSONReference(node, queryId) {
         return requireAllProps({
             kind: 'JSONReferenceNode',
-            reference: this.transformNode(node.reference),
-            traversal: this.transformNode(node.traversal),
+            reference: this.transformNode(node.reference, queryId),
+            traversal: this.transformNode(node.traversal, queryId),
         });
     }
-    transformJSONPath(node) {
+    transformJSONPath(node, queryId) {
         return requireAllProps({
             kind: 'JSONPathNode',
-            inOperator: this.transformNode(node.inOperator),
-            pathLegs: this.transformNodeList(node.pathLegs),
+            inOperator: this.transformNode(node.inOperator, queryId),
+            pathLegs: this.transformNodeList(node.pathLegs, queryId),
         });
     }
-    transformJSONPathLeg(node) {
+    transformJSONPathLeg(node, _queryId) {
         return requireAllProps({
             kind: 'JSONPathLegNode',
             type: node.type,
             value: node.value,
         });
     }
-    transformJSONOperatorChain(node) {
+    transformJSONOperatorChain(node, queryId) {
         return requireAllProps({
             kind: 'JSONOperatorChainNode',
-            operator: this.transformNode(node.operator),
-            values: this.transformNodeList(node.values),
+            operator: this.transformNode(node.operator, queryId),
+            values: this.transformNodeList(node.values, queryId),
         });
     }
-    transformTuple(node) {
+    transformTuple(node, queryId) {
         return requireAllProps({
             kind: 'TupleNode',
-            values: this.transformNodeList(node.values),
+            values: this.transformNodeList(node.values, queryId),
         });
     }
-    transformMergeQuery(node) {
+    transformMergeQuery(node, queryId) {
         return 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),
-            endModifiers: this.transformNodeList(node.endModifiers),
-            output: this.transformNode(node.output),
+            into: this.transformNode(node.into, queryId),
+            using: this.transformNode(node.using, queryId),
+            whens: this.transformNodeList(node.whens, queryId),
+            with: this.transformNode(node.with, queryId),
+            top: this.transformNode(node.top, queryId),
+            endModifiers: this.transformNodeList(node.endModifiers, queryId),
+            output: this.transformNode(node.output, queryId),
+            returning: this.transformNode(node.returning, queryId),
         });
     }
-    transformMatched(node) {
+    transformMatched(node, _queryId) {
         return requireAllProps({
             kind: 'MatchedNode',
             not: node.not,
             bySource: node.bySource,
         });
     }
-    transformAddIndex(node) {
+    transformAddIndex(node, queryId) {
         return requireAllProps({
             kind: 'AddIndexNode',
-            name: this.transformNode(node.name),
-            columns: this.transformNodeList(node.columns),
+            name: this.transformNode(node.name, queryId),
+            columns: this.transformNodeList(node.columns, queryId),
             unique: node.unique,
-            using: this.transformNode(node.using),
+            using: this.transformNode(node.using, queryId),
             ifNotExists: node.ifNotExists,
         });
     }
-    transformCast(node) {
+    transformCast(node, queryId) {
         return requireAllProps({
             kind: 'CastNode',
-            expression: this.transformNode(node.expression),
-            dataType: this.transformNode(node.dataType),
+            expression: this.transformNode(node.expression, queryId),
+            dataType: this.transformNode(node.dataType, queryId),
         });
     }
-    transformFetch(node) {
+    transformFetch(node, queryId) {
         return requireAllProps({
             kind: 'FetchNode',
-            rowCount: this.transformNode(node.rowCount),
+            rowCount: this.transformNode(node.rowCount, queryId),
             modifier: node.modifier,
         });
     }
-    transformTop(node) {
+    transformTop(node, _queryId) {
         return requireAllProps({
             kind: 'TopNode',
             expression: node.expression,
             modifiers: node.modifiers,
         });
     }
-    transformOutput(node) {
+    transformOutput(node, queryId) {
         return requireAllProps({
             kind: 'OutputNode',
-            selections: this.transformNodeList(node.selections),
+            selections: this.transformNodeList(node.selections, queryId),
         });
     }
-    transformDataType(node) {
+    transformDataType(node, _queryId) {
+        // An Object.freezed leaf node. No need to clone.
+        return node;
+    }
+    transformSelectAll(node, _queryId) {
+        // An Object.freezed leaf node. No need to clone.
+        return node;
+    }
+    transformIdentifier(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformSelectAll(node) {
+    transformValue(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformIdentifier(node) {
+    transformPrimitiveValueList(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformValue(node) {
+    transformOperator(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformPrimitiveValueList(node) {
+    transformDefaultInsertValue(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformOperator(node) {
+    transformOrAction(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformDefaultInsertValue(node) {
+    transformCollate(node, _queryId) {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }