com.google.zetasql.resolvedast.RewritingVisitor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of zetasql-client Show documentation
Analyzer Framework for SQL
There is a newer version: 2024.11.1
/*
 * Copyright 2019 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

// RewritingVisitor.java GENERATED FROM RewritingVisitor.java.template
package com.google.zetasql.resolvedast;

import com.google.common.collect.ImmutableList;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAbortBatchStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAddColumnAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAddConstraintAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAddSubEntityAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAddToRestricteeListAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAggregateFunctionCall;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAggregateHavingModifier;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAggregateScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAggregateScanBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAggregationThresholdAggregateScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterAllRowAccessPoliciesStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterApproxViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnDropDefaultAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnDropGeneratedAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnDropNotNullAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnOptionsAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnSetDataTypeAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterColumnSetDefaultAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterConnectionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterDatabaseStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterEntityStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterExternalSchemaStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterMaterializedViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterModelStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterObjectStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterPrivilegeRestrictionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterRowAccessPolicyStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterSchemaStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterSubEntityAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterTableSetOptionsStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterTableStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAlterViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAnalyticFunctionCall;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAnalyticFunctionGroup;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAnalyticScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAnalyzeStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAnonymizedAggregateScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedArgument;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedArgumentDef;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedArgumentList;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedArgumentRef;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedArrayScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAssertRowsModified;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAssertScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAssertStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAssignmentStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAuxLoadDataPartitionFilter;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedAuxLoadDataStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedBarrierScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedBeginStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCallStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCast;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCatalogColumnRef;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCheckConstraint;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCloneDataStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedColumnAnnotations;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedColumnDefaultValue;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedColumnDefinition;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedColumnHolder;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedColumnRef;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCommitStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedComputedColumn;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedComputedColumnBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedComputedColumnImpl;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedConnection;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedConstant;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedConstraint;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateApproxViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateConnectionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateConstantStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateDatabaseStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateEntityStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateExternalSchemaStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateExternalTableStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateFunctionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateIndexStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateMaterializedViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateModelAliasedQuery;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateModelStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreatePrivilegeRestrictionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateProcedureStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateRowAccessPolicyStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateSchemaStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateSchemaStmtBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateSnapshotTableStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateStatement;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateTableAsSelectStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateTableFunctionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateTableStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateTableStmtBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateViewBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCreateViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedCube;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDMLDefault;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDMLValue;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDeferredComputedColumn;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDefineTableStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDeleteStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDescribeStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDescriptor;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDifferentialPrivacyAggregateScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropColumnAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropConstraintAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropFunctionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropIndexStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropMaterializedViewStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropPrimaryKeyAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropPrivilegeRestrictionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropRowAccessPolicyStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropSnapshotTableStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropSubEntityAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedDropTableFunctionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExecuteAsRoleScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExecuteImmediateArgument;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExecuteImmediateStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExplainStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExportDataStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExportMetadataStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExportModelStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExpr;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExpressionColumn;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExtendedCast;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedExtendedCastElement;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFilterField;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFilterFieldArg;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFilterScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFilterUsingAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFlatten;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFlattenedArg;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedForeignKey;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFunctionArgument;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFunctionCall;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFunctionCallBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedFunctionSignatureHolder;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGeneratedColumnInfo;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGetJsonField;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGetProtoField;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGetProtoOneof;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGetStructField;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGrantOrRevokeStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGrantStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGrantToAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGroupRowsScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGroupingCall;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGroupingSet;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGroupingSetBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedGroupingSetMultiColumn;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedIdentityColumnInfo;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedImportStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedIndexItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedInlineLambda;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedInsertRow;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedInsertStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedJoinScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedLimitOffsetScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedLiteral;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedMakeProto;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedMakeProtoField;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedMakeStruct;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedMergeStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedMergeWhen;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedModel;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedModuleStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedNonScalarFunctionCallBase;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedObjectUnit;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedOption;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedOrderByItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedOrderByScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedOutputColumn;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedParameter;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedPivotColumn;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedPivotScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedPrimaryKey;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedPrivilege;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedProjectScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedQueryStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRecursionDepthModifier;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRecursiveRefScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRecursiveScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRelationArgumentScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRemoveFromRestricteeListAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRenameColumnAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRenameStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRenameToAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedReplaceField;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedReplaceFieldItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRestrictToAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedReturningClause;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRevokeFromAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRevokeStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRollbackStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRollup;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedRunBatchStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSampleScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSequence;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSetAsAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSetCollateClause;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSetOperationItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSetOperationScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSetOptionsAction;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSetTransactionStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedShowStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSingleRowScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedStartBatchStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedStatement;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedStaticDescribeScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSubqueryExpr;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedSystemVariable;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedTVFScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedTableAndColumnInfo;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedTableScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedTruncateStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUndropStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUnnestItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUnpivotArg;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUnpivotScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUpdateArrayItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUpdateItem;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedUpdateStmt;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWindowFrame;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWindowFrameExpr;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWindowOrdering;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWindowPartitioning;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWithEntry;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWithExpr;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWithPartitionColumns;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWithRefScan;
import com.google.zetasql.resolvedast.ResolvedNodes.ResolvedWithScan;
import java.util.function.Function;
import javax.annotation.Nullable;

/**
 * Base class for visitors that modify trees of {@link ResolvedNode}s.
 *
 * This is analogous to ResolvedASTDeepCopyVisitor in C++. However,
 * because the trees are immutable in Java, subtrees without modifications
 * can be re-used.
 */
public abstract class RewritingVisitor {

  protected ResolvedLiteral visit(ResolvedLiteral node) {
    return node;
  }

  protected ResolvedParameter visit(ResolvedParameter node) {
    return node;
  }

  protected ResolvedExpressionColumn visit(ResolvedExpressionColumn node) {
    return node;
  }

  protected ResolvedCatalogColumnRef visit(ResolvedCatalogColumnRef node) {
    return node;
  }

  protected ResolvedColumnRef visit(ResolvedColumnRef node) {
    return node;
  }

  protected ResolvedGroupingSetMultiColumn visit(ResolvedGroupingSetMultiColumn node) {
    ImmutableList newColumnList =
        descend(n -> n.accept(this), node.getColumnList());
    if (node.getColumnList() != newColumnList) {
      ResolvedNodes.ResolvedGroupingSetMultiColumn.Builder builder = node.toBuilder();
      builder.setColumnList(newColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedConstant visit(ResolvedConstant node) {
    return node;
  }

  protected ResolvedSystemVariable visit(ResolvedSystemVariable node) {
    return node;
  }

  protected ResolvedInlineLambda visit(ResolvedInlineLambda node) {
    ResolvedExpr newBody =
        node.getBody() != null
            ? node.getBody().accept(this)
            : null;
    ImmutableList newParameterList =
        descend(n -> n.accept(this), node.getParameterList());
    if (node.getBody() != newBody
        || node.getParameterList() != newParameterList) {
      ResolvedNodes.ResolvedInlineLambda.Builder builder = node.toBuilder();
      builder.setBody(newBody);
      builder.setParameterList(newParameterList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSequence visit(ResolvedSequence node) {
    return node;
  }

  protected ResolvedFilterFieldArg visit(ResolvedFilterFieldArg node) {
    return node;
  }

  protected ResolvedFilterField visit(ResolvedFilterField node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ImmutableList newFilterFieldArgList =
        descend(n -> n.accept(this), node.getFilterFieldArgList());
    if (node.getExpr() != newExpr
        || node.getFilterFieldArgList() != newFilterFieldArgList) {
      ResolvedNodes.ResolvedFilterField.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setFilterFieldArgList(newFilterFieldArgList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedFunctionCall visit(ResolvedFunctionCall node) {
    ImmutableList newArgumentList =
        descend(n -> n.accept(this), node.getArgumentList());
    ImmutableList newGenericArgumentList =
        descend(n -> n.accept(this), node.getGenericArgumentList());
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getArgumentList() != newArgumentList
        || node.getGenericArgumentList() != newGenericArgumentList
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedFunctionCall.Builder builder = node.toBuilder();
      builder.setArgumentList(newArgumentList);
      builder.setGenericArgumentList(newGenericArgumentList);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAggregateFunctionCall visit(ResolvedAggregateFunctionCall node) {
    ResolvedScan newWithGroupRowsSubquery =
        node.getWithGroupRowsSubquery() != null
            ? node.getWithGroupRowsSubquery().accept(this)
            : null;
    ResolvedAggregateHavingModifier newHavingModifier =
        node.getHavingModifier() != null
            ? node.getHavingModifier().accept(this)
            : null;
    ResolvedExpr newLimit =
        node.getLimit() != null
            ? node.getLimit().accept(this)
            : null;
    ImmutableList newArgumentList =
        descend(n -> n.accept(this), node.getArgumentList());
    ImmutableList newGenericArgumentList =
        descend(n -> n.accept(this), node.getGenericArgumentList());
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newWithGroupRowsParameterList =
        descend(n -> n.accept(this), node.getWithGroupRowsParameterList());
    ImmutableList newOrderByItemList =
        descend(n -> n.accept(this), node.getOrderByItemList());
    ImmutableList newGroupByList =
        descend(n -> n.accept(this), node.getGroupByList());
    ImmutableList newGroupByAggregateList =
        descend(n -> n.accept(this), node.getGroupByAggregateList());
    if (node.getWithGroupRowsSubquery() != newWithGroupRowsSubquery
        || node.getHavingModifier() != newHavingModifier
        || node.getLimit() != newLimit
        || node.getArgumentList() != newArgumentList
        || node.getGenericArgumentList() != newGenericArgumentList
        || node.getHintList() != newHintList
        || node.getWithGroupRowsParameterList() != newWithGroupRowsParameterList
        || node.getOrderByItemList() != newOrderByItemList
        || node.getGroupByList() != newGroupByList
        || node.getGroupByAggregateList() != newGroupByAggregateList) {
      ResolvedNodes.ResolvedAggregateFunctionCall.Builder builder = node.toBuilder();
      builder.setWithGroupRowsSubquery(newWithGroupRowsSubquery);
      builder.setHavingModifier(newHavingModifier);
      builder.setLimit(newLimit);
      builder.setArgumentList(newArgumentList);
      builder.setGenericArgumentList(newGenericArgumentList);
      builder.setHintList(newHintList);
      builder.setWithGroupRowsParameterList(newWithGroupRowsParameterList);
      builder.setOrderByItemList(newOrderByItemList);
      builder.setGroupByList(newGroupByList);
      builder.setGroupByAggregateList(newGroupByAggregateList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAnalyticFunctionCall visit(ResolvedAnalyticFunctionCall node) {
    ResolvedScan newWithGroupRowsSubquery =
        node.getWithGroupRowsSubquery() != null
            ? node.getWithGroupRowsSubquery().accept(this)
            : null;
    ResolvedWindowFrame newWindowFrame =
        node.getWindowFrame() != null
            ? node.getWindowFrame().accept(this)
            : null;
    ImmutableList newArgumentList =
        descend(n -> n.accept(this), node.getArgumentList());
    ImmutableList newGenericArgumentList =
        descend(n -> n.accept(this), node.getGenericArgumentList());
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newWithGroupRowsParameterList =
        descend(n -> n.accept(this), node.getWithGroupRowsParameterList());
    if (node.getWithGroupRowsSubquery() != newWithGroupRowsSubquery
        || node.getWindowFrame() != newWindowFrame
        || node.getArgumentList() != newArgumentList
        || node.getGenericArgumentList() != newGenericArgumentList
        || node.getHintList() != newHintList
        || node.getWithGroupRowsParameterList() != newWithGroupRowsParameterList) {
      ResolvedNodes.ResolvedAnalyticFunctionCall.Builder builder = node.toBuilder();
      builder.setWithGroupRowsSubquery(newWithGroupRowsSubquery);
      builder.setWindowFrame(newWindowFrame);
      builder.setArgumentList(newArgumentList);
      builder.setGenericArgumentList(newGenericArgumentList);
      builder.setHintList(newHintList);
      builder.setWithGroupRowsParameterList(newWithGroupRowsParameterList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExtendedCastElement visit(ResolvedExtendedCastElement node) {
    return node;
  }

  protected ResolvedExtendedCast visit(ResolvedExtendedCast node) {
    ImmutableList newElementList =
        descend(n -> n.accept(this), node.getElementList());
    if (node.getElementList() != newElementList) {
      ResolvedNodes.ResolvedExtendedCast.Builder builder = node.toBuilder();
      builder.setElementList(newElementList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCast visit(ResolvedCast node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ResolvedExtendedCast newExtendedCast =
        node.getExtendedCast() != null
            ? node.getExtendedCast().accept(this)
            : null;
    ResolvedExpr newFormat =
        node.getFormat() != null
            ? node.getFormat().accept(this)
            : null;
    ResolvedExpr newTimeZone =
        node.getTimeZone() != null
            ? node.getTimeZone().accept(this)
            : null;
    if (node.getExpr() != newExpr
        || node.getExtendedCast() != newExtendedCast
        || node.getFormat() != newFormat
        || node.getTimeZone() != newTimeZone) {
      ResolvedNodes.ResolvedCast.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setExtendedCast(newExtendedCast);
      builder.setFormat(newFormat);
      builder.setTimeZone(newTimeZone);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedMakeStruct visit(ResolvedMakeStruct node) {
    ImmutableList newFieldList =
        descend(n -> n.accept(this), node.getFieldList());
    if (node.getFieldList() != newFieldList) {
      ResolvedNodes.ResolvedMakeStruct.Builder builder = node.toBuilder();
      builder.setFieldList(newFieldList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedMakeProto visit(ResolvedMakeProto node) {
    ImmutableList newFieldList =
        descend(n -> n.accept(this), node.getFieldList());
    if (node.getFieldList() != newFieldList) {
      ResolvedNodes.ResolvedMakeProto.Builder builder = node.toBuilder();
      builder.setFieldList(newFieldList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedMakeProtoField visit(ResolvedMakeProtoField node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedMakeProtoField.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGetStructField visit(ResolvedGetStructField node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedGetStructField.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGetProtoField visit(ResolvedGetProtoField node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedGetProtoField.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGetJsonField visit(ResolvedGetJsonField node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedGetJsonField.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedFlatten visit(ResolvedFlatten node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ImmutableList newGetFieldList =
        descend(n -> n.accept(this), node.getGetFieldList());
    if (node.getExpr() != newExpr
        || node.getGetFieldList() != newGetFieldList) {
      ResolvedNodes.ResolvedFlatten.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setGetFieldList(newGetFieldList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedFlattenedArg visit(ResolvedFlattenedArg node) {
    return node;
  }

  protected ResolvedReplaceFieldItem visit(ResolvedReplaceFieldItem node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedReplaceFieldItem.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedReplaceField visit(ResolvedReplaceField node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ImmutableList newReplaceFieldItemList =
        descend(n -> n.accept(this), node.getReplaceFieldItemList());
    if (node.getExpr() != newExpr
        || node.getReplaceFieldItemList() != newReplaceFieldItemList) {
      ResolvedNodes.ResolvedReplaceField.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setReplaceFieldItemList(newReplaceFieldItemList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGetProtoOneof visit(ResolvedGetProtoOneof node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedGetProtoOneof.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSubqueryExpr visit(ResolvedSubqueryExpr node) {
    ResolvedExpr newInExpr =
        node.getInExpr() != null
            ? node.getInExpr().accept(this)
            : null;
    ResolvedScan newSubquery =
        node.getSubquery() != null
            ? node.getSubquery().accept(this)
            : null;
    ImmutableList newParameterList =
        descend(n -> n.accept(this), node.getParameterList());
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInExpr() != newInExpr
        || node.getSubquery() != newSubquery
        || node.getParameterList() != newParameterList
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedSubqueryExpr.Builder builder = node.toBuilder();
      builder.setInExpr(newInExpr);
      builder.setSubquery(newSubquery);
      builder.setParameterList(newParameterList);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWithExpr visit(ResolvedWithExpr node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ImmutableList newAssignmentList =
        descend(n -> n.accept(this), node.getAssignmentList());
    if (node.getExpr() != newExpr
        || node.getAssignmentList() != newAssignmentList) {
      ResolvedNodes.ResolvedWithExpr.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setAssignmentList(newAssignmentList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExecuteAsRoleScan visit(ResolvedExecuteAsRoleScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedExecuteAsRoleScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedModel visit(ResolvedModel node) {
    return node;
  }

  protected ResolvedConnection visit(ResolvedConnection node) {
    return node;
  }

  protected ResolvedDescriptor visit(ResolvedDescriptor node) {
    return node;
  }

  protected ResolvedSingleRowScan visit(ResolvedSingleRowScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedSingleRowScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedTableScan visit(ResolvedTableScan node) {
    ResolvedExpr newForSystemTimeExpr =
        node.getForSystemTimeExpr() != null
            ? node.getForSystemTimeExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getForSystemTimeExpr() != newForSystemTimeExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedTableScan.Builder builder = node.toBuilder();
      builder.setForSystemTimeExpr(newForSystemTimeExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedJoinScan visit(ResolvedJoinScan node) {
    ResolvedScan newLeftScan =
        node.getLeftScan() != null
            ? node.getLeftScan().accept(this)
            : null;
    ResolvedScan newRightScan =
        node.getRightScan() != null
            ? node.getRightScan().accept(this)
            : null;
    ResolvedExpr newJoinExpr =
        node.getJoinExpr() != null
            ? node.getJoinExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getLeftScan() != newLeftScan
        || node.getRightScan() != newRightScan
        || node.getJoinExpr() != newJoinExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedJoinScan.Builder builder = node.toBuilder();
      builder.setLeftScan(newLeftScan);
      builder.setRightScan(newRightScan);
      builder.setJoinExpr(newJoinExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedArrayScan visit(ResolvedArrayScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedColumnHolder newArrayOffsetColumn =
        node.getArrayOffsetColumn() != null
            ? node.getArrayOffsetColumn().accept(this)
            : null;
    ResolvedExpr newJoinExpr =
        node.getJoinExpr() != null
            ? node.getJoinExpr().accept(this)
            : null;
    ResolvedExpr newArrayZipMode =
        node.getArrayZipMode() != null
            ? node.getArrayZipMode().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newArrayExprList =
        descend(n -> n.accept(this), node.getArrayExprList());
    if (node.getInputScan() != newInputScan
        || node.getArrayOffsetColumn() != newArrayOffsetColumn
        || node.getJoinExpr() != newJoinExpr
        || node.getArrayZipMode() != newArrayZipMode
        || node.getHintList() != newHintList
        || node.getArrayExprList() != newArrayExprList) {
      ResolvedNodes.ResolvedArrayScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setArrayOffsetColumn(newArrayOffsetColumn);
      builder.setJoinExpr(newJoinExpr);
      builder.setArrayZipMode(newArrayZipMode);
      builder.setHintList(newHintList);
      builder.setArrayExprList(newArrayExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedColumnHolder visit(ResolvedColumnHolder node) {
    return node;
  }

  protected ResolvedFilterScan visit(ResolvedFilterScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newFilterExpr =
        node.getFilterExpr() != null
            ? node.getFilterExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInputScan() != newInputScan
        || node.getFilterExpr() != newFilterExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedFilterScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setFilterExpr(newFilterExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGroupingCall visit(ResolvedGroupingCall node) {
    ResolvedColumnRef newGroupByColumn =
        node.getGroupByColumn() != null
            ? node.getGroupByColumn().accept(this)
            : null;
    if (node.getGroupByColumn() != newGroupByColumn) {
      ResolvedNodes.ResolvedGroupingCall.Builder builder = node.toBuilder();
      builder.setGroupByColumn(newGroupByColumn);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGroupingSet visit(ResolvedGroupingSet node) {
    ImmutableList newGroupByColumnList =
        descend(n -> n.accept(this), node.getGroupByColumnList());
    if (node.getGroupByColumnList() != newGroupByColumnList) {
      ResolvedNodes.ResolvedGroupingSet.Builder builder = node.toBuilder();
      builder.setGroupByColumnList(newGroupByColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRollup visit(ResolvedRollup node) {
    ImmutableList newRollupColumnList =
        descend(n -> n.accept(this), node.getRollupColumnList());
    if (node.getRollupColumnList() != newRollupColumnList) {
      ResolvedNodes.ResolvedRollup.Builder builder = node.toBuilder();
      builder.setRollupColumnList(newRollupColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCube visit(ResolvedCube node) {
    ImmutableList newCubeColumnList =
        descend(n -> n.accept(this), node.getCubeColumnList());
    if (node.getCubeColumnList() != newCubeColumnList) {
      ResolvedNodes.ResolvedCube.Builder builder = node.toBuilder();
      builder.setCubeColumnList(newCubeColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAggregateScan visit(ResolvedAggregateScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newGroupByList =
        descend(n -> n.accept(this), node.getGroupByList());
    ImmutableList newAggregateList =
        descend(n -> n.accept(this), node.getAggregateList());
    ImmutableList newGroupingSetList =
        descend(n -> n.accept(this), node.getGroupingSetList());
    ImmutableList newRollupColumnList =
        descend(n -> n.accept(this), node.getRollupColumnList());
    ImmutableList newGroupingCallList =
        descend(n -> n.accept(this), node.getGroupingCallList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList
        || node.getGroupByList() != newGroupByList
        || node.getAggregateList() != newAggregateList
        || node.getGroupingSetList() != newGroupingSetList
        || node.getRollupColumnList() != newRollupColumnList
        || node.getGroupingCallList() != newGroupingCallList) {
      ResolvedNodes.ResolvedAggregateScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      builder.setGroupByList(newGroupByList);
      builder.setAggregateList(newAggregateList);
      builder.setGroupingSetList(newGroupingSetList);
      builder.setRollupColumnList(newRollupColumnList);
      builder.setGroupingCallList(newGroupingCallList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAnonymizedAggregateScan visit(ResolvedAnonymizedAggregateScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newKThresholdExpr =
        node.getKThresholdExpr() != null
            ? node.getKThresholdExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newGroupByList =
        descend(n -> n.accept(this), node.getGroupByList());
    ImmutableList newAggregateList =
        descend(n -> n.accept(this), node.getAggregateList());
    ImmutableList newGroupingSetList =
        descend(n -> n.accept(this), node.getGroupingSetList());
    ImmutableList newRollupColumnList =
        descend(n -> n.accept(this), node.getRollupColumnList());
    ImmutableList newGroupingCallList =
        descend(n -> n.accept(this), node.getGroupingCallList());
    ImmutableList newAnonymizationOptionList =
        descend(n -> n.accept(this), node.getAnonymizationOptionList());
    if (node.getInputScan() != newInputScan
        || node.getKThresholdExpr() != newKThresholdExpr
        || node.getHintList() != newHintList
        || node.getGroupByList() != newGroupByList
        || node.getAggregateList() != newAggregateList
        || node.getGroupingSetList() != newGroupingSetList
        || node.getRollupColumnList() != newRollupColumnList
        || node.getGroupingCallList() != newGroupingCallList
        || node.getAnonymizationOptionList() != newAnonymizationOptionList) {
      ResolvedNodes.ResolvedAnonymizedAggregateScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setKThresholdExpr(newKThresholdExpr);
      builder.setHintList(newHintList);
      builder.setGroupByList(newGroupByList);
      builder.setAggregateList(newAggregateList);
      builder.setGroupingSetList(newGroupingSetList);
      builder.setRollupColumnList(newRollupColumnList);
      builder.setGroupingCallList(newGroupingCallList);
      builder.setAnonymizationOptionList(newAnonymizationOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDifferentialPrivacyAggregateScan visit(ResolvedDifferentialPrivacyAggregateScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newGroupSelectionThresholdExpr =
        node.getGroupSelectionThresholdExpr() != null
            ? node.getGroupSelectionThresholdExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newGroupByList =
        descend(n -> n.accept(this), node.getGroupByList());
    ImmutableList newAggregateList =
        descend(n -> n.accept(this), node.getAggregateList());
    ImmutableList newGroupingSetList =
        descend(n -> n.accept(this), node.getGroupingSetList());
    ImmutableList newRollupColumnList =
        descend(n -> n.accept(this), node.getRollupColumnList());
    ImmutableList newGroupingCallList =
        descend(n -> n.accept(this), node.getGroupingCallList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getInputScan() != newInputScan
        || node.getGroupSelectionThresholdExpr() != newGroupSelectionThresholdExpr
        || node.getHintList() != newHintList
        || node.getGroupByList() != newGroupByList
        || node.getAggregateList() != newAggregateList
        || node.getGroupingSetList() != newGroupingSetList
        || node.getRollupColumnList() != newRollupColumnList
        || node.getGroupingCallList() != newGroupingCallList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedDifferentialPrivacyAggregateScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setGroupSelectionThresholdExpr(newGroupSelectionThresholdExpr);
      builder.setHintList(newHintList);
      builder.setGroupByList(newGroupByList);
      builder.setAggregateList(newAggregateList);
      builder.setGroupingSetList(newGroupingSetList);
      builder.setRollupColumnList(newRollupColumnList);
      builder.setGroupingCallList(newGroupingCallList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAggregationThresholdAggregateScan visit(ResolvedAggregationThresholdAggregateScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newGroupByList =
        descend(n -> n.accept(this), node.getGroupByList());
    ImmutableList newAggregateList =
        descend(n -> n.accept(this), node.getAggregateList());
    ImmutableList newGroupingSetList =
        descend(n -> n.accept(this), node.getGroupingSetList());
    ImmutableList newRollupColumnList =
        descend(n -> n.accept(this), node.getRollupColumnList());
    ImmutableList newGroupingCallList =
        descend(n -> n.accept(this), node.getGroupingCallList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList
        || node.getGroupByList() != newGroupByList
        || node.getAggregateList() != newAggregateList
        || node.getGroupingSetList() != newGroupingSetList
        || node.getRollupColumnList() != newRollupColumnList
        || node.getGroupingCallList() != newGroupingCallList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedAggregationThresholdAggregateScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      builder.setGroupByList(newGroupByList);
      builder.setAggregateList(newAggregateList);
      builder.setGroupingSetList(newGroupingSetList);
      builder.setRollupColumnList(newRollupColumnList);
      builder.setGroupingCallList(newGroupingCallList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSetOperationItem visit(ResolvedSetOperationItem node) {
    ResolvedScan newScan =
        node.getScan() != null
            ? node.getScan().accept(this)
            : null;
    if (node.getScan() != newScan) {
      ResolvedNodes.ResolvedSetOperationItem.Builder builder = node.toBuilder();
      builder.setScan(newScan);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSetOperationScan visit(ResolvedSetOperationScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newInputItemList =
        descend(n -> n.accept(this), node.getInputItemList());
    if (node.getHintList() != newHintList
        || node.getInputItemList() != newInputItemList) {
      ResolvedNodes.ResolvedSetOperationScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setInputItemList(newInputItemList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedOrderByScan visit(ResolvedOrderByScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOrderByItemList =
        descend(n -> n.accept(this), node.getOrderByItemList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList
        || node.getOrderByItemList() != newOrderByItemList) {
      ResolvedNodes.ResolvedOrderByScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      builder.setOrderByItemList(newOrderByItemList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedLimitOffsetScan visit(ResolvedLimitOffsetScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newLimit =
        node.getLimit() != null
            ? node.getLimit().accept(this)
            : null;
    ResolvedExpr newOffset =
        node.getOffset() != null
            ? node.getOffset().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInputScan() != newInputScan
        || node.getLimit() != newLimit
        || node.getOffset() != newOffset
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedLimitOffsetScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setLimit(newLimit);
      builder.setOffset(newOffset);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWithRefScan visit(ResolvedWithRefScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedWithRefScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAnalyticScan visit(ResolvedAnalyticScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newFunctionGroupList =
        descend(n -> n.accept(this), node.getFunctionGroupList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList
        || node.getFunctionGroupList() != newFunctionGroupList) {
      ResolvedNodes.ResolvedAnalyticScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      builder.setFunctionGroupList(newFunctionGroupList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSampleScan visit(ResolvedSampleScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newSize =
        node.getSize() != null
            ? node.getSize().accept(this)
            : null;
    ResolvedExpr newRepeatableArgument =
        node.getRepeatableArgument() != null
            ? node.getRepeatableArgument().accept(this)
            : null;
    ResolvedColumnHolder newWeightColumn =
        node.getWeightColumn() != null
            ? node.getWeightColumn().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    if (node.getInputScan() != newInputScan
        || node.getSize() != newSize
        || node.getRepeatableArgument() != newRepeatableArgument
        || node.getWeightColumn() != newWeightColumn
        || node.getHintList() != newHintList
        || node.getPartitionByList() != newPartitionByList) {
      ResolvedNodes.ResolvedSampleScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setSize(newSize);
      builder.setRepeatableArgument(newRepeatableArgument);
      builder.setWeightColumn(newWeightColumn);
      builder.setHintList(newHintList);
      builder.setPartitionByList(newPartitionByList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedComputedColumn visit(ResolvedComputedColumn node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedComputedColumn.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDeferredComputedColumn visit(ResolvedDeferredComputedColumn node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    if (node.getExpr() != newExpr) {
      ResolvedNodes.ResolvedDeferredComputedColumn.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedOrderByItem visit(ResolvedOrderByItem node) {
    ResolvedColumnRef newColumnRef =
        node.getColumnRef() != null
            ? node.getColumnRef().accept(this)
            : null;
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    if (node.getColumnRef() != newColumnRef
        || node.getCollationName() != newCollationName) {
      ResolvedNodes.ResolvedOrderByItem.Builder builder = node.toBuilder();
      builder.setColumnRef(newColumnRef);
      builder.setCollationName(newCollationName);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedColumnAnnotations visit(ResolvedColumnAnnotations node) {
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newChildList =
        descend(n -> n.accept(this), node.getChildList());
    if (node.getCollationName() != newCollationName
        || node.getOptionList() != newOptionList
        || node.getChildList() != newChildList) {
      ResolvedNodes.ResolvedColumnAnnotations.Builder builder = node.toBuilder();
      builder.setCollationName(newCollationName);
      builder.setOptionList(newOptionList);
      builder.setChildList(newChildList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGeneratedColumnInfo visit(ResolvedGeneratedColumnInfo node) {
    ResolvedExpr newExpression =
        node.getExpression() != null
            ? node.getExpression().accept(this)
            : null;
    ResolvedIdentityColumnInfo newIdentityColumnInfo =
        node.getIdentityColumnInfo() != null
            ? node.getIdentityColumnInfo().accept(this)
            : null;
    if (node.getExpression() != newExpression
        || node.getIdentityColumnInfo() != newIdentityColumnInfo) {
      ResolvedNodes.ResolvedGeneratedColumnInfo.Builder builder = node.toBuilder();
      builder.setExpression(newExpression);
      builder.setIdentityColumnInfo(newIdentityColumnInfo);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedColumnDefaultValue visit(ResolvedColumnDefaultValue node) {
    ResolvedExpr newExpression =
        node.getExpression() != null
            ? node.getExpression().accept(this)
            : null;
    if (node.getExpression() != newExpression) {
      ResolvedNodes.ResolvedColumnDefaultValue.Builder builder = node.toBuilder();
      builder.setExpression(newExpression);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedColumnDefinition visit(ResolvedColumnDefinition node) {
    ResolvedColumnAnnotations newAnnotations =
        node.getAnnotations() != null
            ? node.getAnnotations().accept(this)
            : null;
    ResolvedGeneratedColumnInfo newGeneratedColumnInfo =
        node.getGeneratedColumnInfo() != null
            ? node.getGeneratedColumnInfo().accept(this)
            : null;
    ResolvedColumnDefaultValue newDefaultValue =
        node.getDefaultValue() != null
            ? node.getDefaultValue().accept(this)
            : null;
    if (node.getAnnotations() != newAnnotations
        || node.getGeneratedColumnInfo() != newGeneratedColumnInfo
        || node.getDefaultValue() != newDefaultValue) {
      ResolvedNodes.ResolvedColumnDefinition.Builder builder = node.toBuilder();
      builder.setAnnotations(newAnnotations);
      builder.setGeneratedColumnInfo(newGeneratedColumnInfo);
      builder.setDefaultValue(newDefaultValue);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedPrimaryKey visit(ResolvedPrimaryKey node) {
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedPrimaryKey.Builder builder = node.toBuilder();
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedForeignKey visit(ResolvedForeignKey node) {
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedForeignKey.Builder builder = node.toBuilder();
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCheckConstraint visit(ResolvedCheckConstraint node) {
    ResolvedExpr newExpression =
        node.getExpression() != null
            ? node.getExpression().accept(this)
            : null;
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getExpression() != newExpression
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCheckConstraint.Builder builder = node.toBuilder();
      builder.setExpression(newExpression);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedOutputColumn visit(ResolvedOutputColumn node) {
    return node;
  }

  protected ResolvedProjectScan visit(ResolvedProjectScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newExprList =
        descend(n -> n.accept(this), node.getExprList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList
        || node.getExprList() != newExprList) {
      ResolvedNodes.ResolvedProjectScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      builder.setExprList(newExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedTVFScan visit(ResolvedTVFScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newArgumentList =
        descend(n -> n.accept(this), node.getArgumentList());
    if (node.getHintList() != newHintList
        || node.getArgumentList() != newArgumentList) {
      ResolvedNodes.ResolvedTVFScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setArgumentList(newArgumentList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGroupRowsScan visit(ResolvedGroupRowsScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newInputColumnList =
        descend(n -> n.accept(this), node.getInputColumnList());
    if (node.getHintList() != newHintList
        || node.getInputColumnList() != newInputColumnList) {
      ResolvedNodes.ResolvedGroupRowsScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setInputColumnList(newInputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedFunctionArgument visit(ResolvedFunctionArgument node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ResolvedScan newScan =
        node.getScan() != null
            ? node.getScan().accept(this)
            : null;
    ResolvedModel newModel =
        node.getModel() != null
            ? node.getModel().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ResolvedDescriptor newDescriptorArg =
        node.getDescriptorArg() != null
            ? node.getDescriptorArg().accept(this)
            : null;
    ResolvedInlineLambda newInlineLambda =
        node.getInlineLambda() != null
            ? node.getInlineLambda().accept(this)
            : null;
    ResolvedSequence newSequence =
        node.getSequence() != null
            ? node.getSequence().accept(this)
            : null;
    if (node.getExpr() != newExpr
        || node.getScan() != newScan
        || node.getModel() != newModel
        || node.getConnection() != newConnection
        || node.getDescriptorArg() != newDescriptorArg
        || node.getInlineLambda() != newInlineLambda
        || node.getSequence() != newSequence) {
      ResolvedNodes.ResolvedFunctionArgument.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setScan(newScan);
      builder.setModel(newModel);
      builder.setConnection(newConnection);
      builder.setDescriptorArg(newDescriptorArg);
      builder.setInlineLambda(newInlineLambda);
      builder.setSequence(newSequence);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExplainStmt visit(ResolvedExplainStmt node) {
    ResolvedStatement newStatement =
        node.getStatement() != null
            ? node.getStatement().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getStatement() != newStatement
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedExplainStmt.Builder builder = node.toBuilder();
      builder.setStatement(newStatement);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedQueryStmt visit(ResolvedQueryStmt node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    if (node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getOutputColumnList() != newOutputColumnList) {
      ResolvedNodes.ResolvedQueryStmt.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setOutputColumnList(newOutputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateDatabaseStmt visit(ResolvedCreateDatabaseStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateDatabaseStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedIndexItem visit(ResolvedIndexItem node) {
    ResolvedColumnRef newColumnRef =
        node.getColumnRef() != null
            ? node.getColumnRef().accept(this)
            : null;
    if (node.getColumnRef() != newColumnRef) {
      ResolvedNodes.ResolvedIndexItem.Builder builder = node.toBuilder();
      builder.setColumnRef(newColumnRef);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUnnestItem visit(ResolvedUnnestItem node) {
    ResolvedExpr newArrayExpr =
        node.getArrayExpr() != null
            ? node.getArrayExpr().accept(this)
            : null;
    ResolvedColumnHolder newArrayOffsetColumn =
        node.getArrayOffsetColumn() != null
            ? node.getArrayOffsetColumn().accept(this)
            : null;
    if (node.getArrayExpr() != newArrayExpr
        || node.getArrayOffsetColumn() != newArrayOffsetColumn) {
      ResolvedNodes.ResolvedUnnestItem.Builder builder = node.toBuilder();
      builder.setArrayExpr(newArrayExpr);
      builder.setArrayOffsetColumn(newArrayOffsetColumn);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateIndexStmt visit(ResolvedCreateIndexStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newIndexItemList =
        descend(n -> n.accept(this), node.getIndexItemList());
    ImmutableList newStoringExpressionList =
        descend(n -> n.accept(this), node.getStoringExpressionList());
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newComputedColumnsList =
        descend(n -> n.accept(this), node.getComputedColumnsList());
    ImmutableList newUnnestExpressionsList =
        descend(n -> n.accept(this), node.getUnnestExpressionsList());
    if (node.getTableScan() != newTableScan
        || node.getHintList() != newHintList
        || node.getIndexItemList() != newIndexItemList
        || node.getStoringExpressionList() != newStoringExpressionList
        || node.getPartitionByList() != newPartitionByList
        || node.getOptionList() != newOptionList
        || node.getComputedColumnsList() != newComputedColumnsList
        || node.getUnnestExpressionsList() != newUnnestExpressionsList) {
      ResolvedNodes.ResolvedCreateIndexStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setHintList(newHintList);
      builder.setIndexItemList(newIndexItemList);
      builder.setStoringExpressionList(newStoringExpressionList);
      builder.setPartitionByList(newPartitionByList);
      builder.setOptionList(newOptionList);
      builder.setComputedColumnsList(newComputedColumnsList);
      builder.setUnnestExpressionsList(newUnnestExpressionsList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateSchemaStmt visit(ResolvedCreateSchemaStmt node) {
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getCollationName() != newCollationName
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateSchemaStmt.Builder builder = node.toBuilder();
      builder.setCollationName(newCollationName);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateExternalSchemaStmt visit(ResolvedCreateExternalSchemaStmt node) {
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateExternalSchemaStmt.Builder builder = node.toBuilder();
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateTableStmt visit(ResolvedCreateTableStmt node) {
    ResolvedPrimaryKey newPrimaryKey =
        node.getPrimaryKey() != null
            ? node.getPrimaryKey().accept(this)
            : null;
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ResolvedScan newCloneFrom =
        node.getCloneFrom() != null
            ? node.getCloneFrom().accept(this)
            : null;
    ResolvedScan newCopyFrom =
        node.getCopyFrom() != null
            ? node.getCopyFrom().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    ImmutableList newForeignKeyList =
        descend(n -> n.accept(this), node.getForeignKeyList());
    ImmutableList newCheckConstraintList =
        descend(n -> n.accept(this), node.getCheckConstraintList());
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    ImmutableList newClusterByList =
        descend(n -> n.accept(this), node.getClusterByList());
    if (node.getPrimaryKey() != newPrimaryKey
        || node.getCollationName() != newCollationName
        || node.getConnection() != newConnection
        || node.getCloneFrom() != newCloneFrom
        || node.getCopyFrom() != newCopyFrom
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getColumnDefinitionList() != newColumnDefinitionList
        || node.getForeignKeyList() != newForeignKeyList
        || node.getCheckConstraintList() != newCheckConstraintList
        || node.getPartitionByList() != newPartitionByList
        || node.getClusterByList() != newClusterByList) {
      ResolvedNodes.ResolvedCreateTableStmt.Builder builder = node.toBuilder();
      builder.setPrimaryKey(newPrimaryKey);
      builder.setCollationName(newCollationName);
      builder.setConnection(newConnection);
      builder.setCloneFrom(newCloneFrom);
      builder.setCopyFrom(newCopyFrom);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      builder.setForeignKeyList(newForeignKeyList);
      builder.setCheckConstraintList(newCheckConstraintList);
      builder.setPartitionByList(newPartitionByList);
      builder.setClusterByList(newClusterByList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateTableAsSelectStmt visit(ResolvedCreateTableAsSelectStmt node) {
    ResolvedPrimaryKey newPrimaryKey =
        node.getPrimaryKey() != null
            ? node.getPrimaryKey().accept(this)
            : null;
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    ImmutableList newForeignKeyList =
        descend(n -> n.accept(this), node.getForeignKeyList());
    ImmutableList newCheckConstraintList =
        descend(n -> n.accept(this), node.getCheckConstraintList());
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    ImmutableList newClusterByList =
        descend(n -> n.accept(this), node.getClusterByList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    if (node.getPrimaryKey() != newPrimaryKey
        || node.getCollationName() != newCollationName
        || node.getConnection() != newConnection
        || node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getColumnDefinitionList() != newColumnDefinitionList
        || node.getForeignKeyList() != newForeignKeyList
        || node.getCheckConstraintList() != newCheckConstraintList
        || node.getPartitionByList() != newPartitionByList
        || node.getClusterByList() != newClusterByList
        || node.getOutputColumnList() != newOutputColumnList) {
      ResolvedNodes.ResolvedCreateTableAsSelectStmt.Builder builder = node.toBuilder();
      builder.setPrimaryKey(newPrimaryKey);
      builder.setCollationName(newCollationName);
      builder.setConnection(newConnection);
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      builder.setForeignKeyList(newForeignKeyList);
      builder.setCheckConstraintList(newCheckConstraintList);
      builder.setPartitionByList(newPartitionByList);
      builder.setClusterByList(newClusterByList);
      builder.setOutputColumnList(newOutputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateModelAliasedQuery visit(ResolvedCreateModelAliasedQuery node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    if (node.getQuery() != newQuery
        || node.getOutputColumnList() != newOutputColumnList) {
      ResolvedNodes.ResolvedCreateModelAliasedQuery.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setOutputColumnList(newOutputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateModelStmt visit(ResolvedCreateModelStmt node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    ImmutableList newAliasedQueryList =
        descend(n -> n.accept(this), node.getAliasedQueryList());
    ImmutableList newTransformInputColumnList =
        descend(n -> n.accept(this), node.getTransformInputColumnList());
    ImmutableList newTransformList =
        descend(n -> n.accept(this), node.getTransformList());
    ImmutableList newTransformOutputColumnList =
        descend(n -> n.accept(this), node.getTransformOutputColumnList());
    ImmutableList newTransformAnalyticFunctionGroupList =
        descend(n -> n.accept(this), node.getTransformAnalyticFunctionGroupList());
    ImmutableList newInputColumnDefinitionList =
        descend(n -> n.accept(this), node.getInputColumnDefinitionList());
    ImmutableList newOutputColumnDefinitionList =
        descend(n -> n.accept(this), node.getOutputColumnDefinitionList());
    if (node.getQuery() != newQuery
        || node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getOutputColumnList() != newOutputColumnList
        || node.getAliasedQueryList() != newAliasedQueryList
        || node.getTransformInputColumnList() != newTransformInputColumnList
        || node.getTransformList() != newTransformList
        || node.getTransformOutputColumnList() != newTransformOutputColumnList
        || node.getTransformAnalyticFunctionGroupList() != newTransformAnalyticFunctionGroupList
        || node.getInputColumnDefinitionList() != newInputColumnDefinitionList
        || node.getOutputColumnDefinitionList() != newOutputColumnDefinitionList) {
      ResolvedNodes.ResolvedCreateModelStmt.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setOutputColumnList(newOutputColumnList);
      builder.setAliasedQueryList(newAliasedQueryList);
      builder.setTransformInputColumnList(newTransformInputColumnList);
      builder.setTransformList(newTransformList);
      builder.setTransformOutputColumnList(newTransformOutputColumnList);
      builder.setTransformAnalyticFunctionGroupList(newTransformAnalyticFunctionGroupList);
      builder.setInputColumnDefinitionList(newInputColumnDefinitionList);
      builder.setOutputColumnDefinitionList(newOutputColumnDefinitionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateViewStmt visit(ResolvedCreateViewStmt node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    if (node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getOutputColumnList() != newOutputColumnList
        || node.getColumnDefinitionList() != newColumnDefinitionList) {
      ResolvedNodes.ResolvedCreateViewStmt.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setOutputColumnList(newOutputColumnList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWithPartitionColumns visit(ResolvedWithPartitionColumns node) {
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    if (node.getColumnDefinitionList() != newColumnDefinitionList) {
      ResolvedNodes.ResolvedWithPartitionColumns.Builder builder = node.toBuilder();
      builder.setColumnDefinitionList(newColumnDefinitionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateSnapshotTableStmt visit(ResolvedCreateSnapshotTableStmt node) {
    ResolvedScan newCloneFrom =
        node.getCloneFrom() != null
            ? node.getCloneFrom().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getCloneFrom() != newCloneFrom
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateSnapshotTableStmt.Builder builder = node.toBuilder();
      builder.setCloneFrom(newCloneFrom);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateExternalTableStmt visit(ResolvedCreateExternalTableStmt node) {
    ResolvedPrimaryKey newPrimaryKey =
        node.getPrimaryKey() != null
            ? node.getPrimaryKey().accept(this)
            : null;
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ResolvedWithPartitionColumns newWithPartitionColumns =
        node.getWithPartitionColumns() != null
            ? node.getWithPartitionColumns().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    ImmutableList newForeignKeyList =
        descend(n -> n.accept(this), node.getForeignKeyList());
    ImmutableList newCheckConstraintList =
        descend(n -> n.accept(this), node.getCheckConstraintList());
    if (node.getPrimaryKey() != newPrimaryKey
        || node.getCollationName() != newCollationName
        || node.getConnection() != newConnection
        || node.getWithPartitionColumns() != newWithPartitionColumns
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getColumnDefinitionList() != newColumnDefinitionList
        || node.getForeignKeyList() != newForeignKeyList
        || node.getCheckConstraintList() != newCheckConstraintList) {
      ResolvedNodes.ResolvedCreateExternalTableStmt.Builder builder = node.toBuilder();
      builder.setPrimaryKey(newPrimaryKey);
      builder.setCollationName(newCollationName);
      builder.setConnection(newConnection);
      builder.setWithPartitionColumns(newWithPartitionColumns);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      builder.setForeignKeyList(newForeignKeyList);
      builder.setCheckConstraintList(newCheckConstraintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExportModelStmt visit(ResolvedExportModelStmt node) {
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedExportModelStmt.Builder builder = node.toBuilder();
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExportDataStmt visit(ResolvedExportDataStmt node) {
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    if (node.getConnection() != newConnection
        || node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getOutputColumnList() != newOutputColumnList) {
      ResolvedNodes.ResolvedExportDataStmt.Builder builder = node.toBuilder();
      builder.setConnection(newConnection);
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setOutputColumnList(newOutputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExportMetadataStmt visit(ResolvedExportMetadataStmt node) {
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedExportMetadataStmt.Builder builder = node.toBuilder();
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDefineTableStmt visit(ResolvedDefineTableStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedDefineTableStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDescribeStmt visit(ResolvedDescribeStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDescribeStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedShowStmt visit(ResolvedShowStmt node) {
    ResolvedLiteral newLikeExpr =
        node.getLikeExpr() != null
            ? node.getLikeExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getLikeExpr() != newLikeExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedShowStmt.Builder builder = node.toBuilder();
      builder.setLikeExpr(newLikeExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedBeginStmt visit(ResolvedBeginStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedBeginStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSetTransactionStmt visit(ResolvedSetTransactionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedSetTransactionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCommitStmt visit(ResolvedCommitStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedCommitStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRollbackStmt visit(ResolvedRollbackStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedRollbackStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedStartBatchStmt visit(ResolvedStartBatchStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedStartBatchStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRunBatchStmt visit(ResolvedRunBatchStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedRunBatchStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAbortBatchStmt visit(ResolvedAbortBatchStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedAbortBatchStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropStmt visit(ResolvedDropStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropMaterializedViewStmt visit(ResolvedDropMaterializedViewStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropMaterializedViewStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropSnapshotTableStmt visit(ResolvedDropSnapshotTableStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropSnapshotTableStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRecursiveRefScan visit(ResolvedRecursiveRefScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedRecursiveRefScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRecursionDepthModifier visit(ResolvedRecursionDepthModifier node) {
    ResolvedExpr newLowerBound =
        node.getLowerBound() != null
            ? node.getLowerBound().accept(this)
            : null;
    ResolvedExpr newUpperBound =
        node.getUpperBound() != null
            ? node.getUpperBound().accept(this)
            : null;
    ResolvedColumnHolder newRecursionDepthColumn =
        node.getRecursionDepthColumn() != null
            ? node.getRecursionDepthColumn().accept(this)
            : null;
    if (node.getLowerBound() != newLowerBound
        || node.getUpperBound() != newUpperBound
        || node.getRecursionDepthColumn() != newRecursionDepthColumn) {
      ResolvedNodes.ResolvedRecursionDepthModifier.Builder builder = node.toBuilder();
      builder.setLowerBound(newLowerBound);
      builder.setUpperBound(newUpperBound);
      builder.setRecursionDepthColumn(newRecursionDepthColumn);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRecursiveScan visit(ResolvedRecursiveScan node) {
    ResolvedSetOperationItem newNonRecursiveTerm =
        node.getNonRecursiveTerm() != null
            ? node.getNonRecursiveTerm().accept(this)
            : null;
    ResolvedSetOperationItem newRecursiveTerm =
        node.getRecursiveTerm() != null
            ? node.getRecursiveTerm().accept(this)
            : null;
    ResolvedRecursionDepthModifier newRecursionDepthModifier =
        node.getRecursionDepthModifier() != null
            ? node.getRecursionDepthModifier().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getNonRecursiveTerm() != newNonRecursiveTerm
        || node.getRecursiveTerm() != newRecursiveTerm
        || node.getRecursionDepthModifier() != newRecursionDepthModifier
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedRecursiveScan.Builder builder = node.toBuilder();
      builder.setNonRecursiveTerm(newNonRecursiveTerm);
      builder.setRecursiveTerm(newRecursiveTerm);
      builder.setRecursionDepthModifier(newRecursionDepthModifier);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWithScan visit(ResolvedWithScan node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newWithEntryList =
        descend(n -> n.accept(this), node.getWithEntryList());
    if (node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getWithEntryList() != newWithEntryList) {
      ResolvedNodes.ResolvedWithScan.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setWithEntryList(newWithEntryList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWithEntry visit(ResolvedWithEntry node) {
    ResolvedScan newWithSubquery =
        node.getWithSubquery() != null
            ? node.getWithSubquery().accept(this)
            : null;
    if (node.getWithSubquery() != newWithSubquery) {
      ResolvedNodes.ResolvedWithEntry.Builder builder = node.toBuilder();
      builder.setWithSubquery(newWithSubquery);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedOption visit(ResolvedOption node) {
    ResolvedExpr newValue =
        node.getValue() != null
            ? node.getValue().accept(this)
            : null;
    if (node.getValue() != newValue) {
      ResolvedNodes.ResolvedOption.Builder builder = node.toBuilder();
      builder.setValue(newValue);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWindowPartitioning visit(ResolvedWindowPartitioning node) {
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getPartitionByList() != newPartitionByList
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedWindowPartitioning.Builder builder = node.toBuilder();
      builder.setPartitionByList(newPartitionByList);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWindowOrdering visit(ResolvedWindowOrdering node) {
    ImmutableList newOrderByItemList =
        descend(n -> n.accept(this), node.getOrderByItemList());
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getOrderByItemList() != newOrderByItemList
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedWindowOrdering.Builder builder = node.toBuilder();
      builder.setOrderByItemList(newOrderByItemList);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWindowFrame visit(ResolvedWindowFrame node) {
    ResolvedWindowFrameExpr newStartExpr =
        node.getStartExpr() != null
            ? node.getStartExpr().accept(this)
            : null;
    ResolvedWindowFrameExpr newEndExpr =
        node.getEndExpr() != null
            ? node.getEndExpr().accept(this)
            : null;
    if (node.getStartExpr() != newStartExpr
        || node.getEndExpr() != newEndExpr) {
      ResolvedNodes.ResolvedWindowFrame.Builder builder = node.toBuilder();
      builder.setStartExpr(newStartExpr);
      builder.setEndExpr(newEndExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAnalyticFunctionGroup visit(ResolvedAnalyticFunctionGroup node) {
    ResolvedWindowPartitioning newPartitionBy =
        node.getPartitionBy() != null
            ? node.getPartitionBy().accept(this)
            : null;
    ResolvedWindowOrdering newOrderBy =
        node.getOrderBy() != null
            ? node.getOrderBy().accept(this)
            : null;
    ImmutableList newAnalyticFunctionList =
        descend(n -> n.accept(this), node.getAnalyticFunctionList());
    if (node.getPartitionBy() != newPartitionBy
        || node.getOrderBy() != newOrderBy
        || node.getAnalyticFunctionList() != newAnalyticFunctionList) {
      ResolvedNodes.ResolvedAnalyticFunctionGroup.Builder builder = node.toBuilder();
      builder.setPartitionBy(newPartitionBy);
      builder.setOrderBy(newOrderBy);
      builder.setAnalyticFunctionList(newAnalyticFunctionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedWindowFrameExpr visit(ResolvedWindowFrameExpr node) {
    ResolvedExpr newExpression =
        node.getExpression() != null
            ? node.getExpression().accept(this)
            : null;
    if (node.getExpression() != newExpression) {
      ResolvedNodes.ResolvedWindowFrameExpr.Builder builder = node.toBuilder();
      builder.setExpression(newExpression);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDMLValue visit(ResolvedDMLValue node) {
    ResolvedExpr newValue =
        node.getValue() != null
            ? node.getValue().accept(this)
            : null;
    if (node.getValue() != newValue) {
      ResolvedNodes.ResolvedDMLValue.Builder builder = node.toBuilder();
      builder.setValue(newValue);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDMLDefault visit(ResolvedDMLDefault node) {
    return node;
  }

  protected ResolvedAssertStmt visit(ResolvedAssertStmt node) {
    ResolvedExpr newExpression =
        node.getExpression() != null
            ? node.getExpression().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getExpression() != newExpression
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedAssertStmt.Builder builder = node.toBuilder();
      builder.setExpression(newExpression);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAssertRowsModified visit(ResolvedAssertRowsModified node) {
    ResolvedExpr newRows =
        node.getRows() != null
            ? node.getRows().accept(this)
            : null;
    if (node.getRows() != newRows) {
      ResolvedNodes.ResolvedAssertRowsModified.Builder builder = node.toBuilder();
      builder.setRows(newRows);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedInsertRow visit(ResolvedInsertRow node) {
    ImmutableList newValueList =
        descend(n -> n.accept(this), node.getValueList());
    if (node.getValueList() != newValueList) {
      ResolvedNodes.ResolvedInsertRow.Builder builder = node.toBuilder();
      builder.setValueList(newValueList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedInsertStmt visit(ResolvedInsertStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ResolvedAssertRowsModified newAssertRowsModified =
        node.getAssertRowsModified() != null
            ? node.getAssertRowsModified().accept(this)
            : null;
    ResolvedReturningClause newReturning =
        node.getReturning() != null
            ? node.getReturning().accept(this)
            : null;
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newQueryParameterList =
        descend(n -> n.accept(this), node.getQueryParameterList());
    ImmutableList newRowList =
        descend(n -> n.accept(this), node.getRowList());
    ImmutableList newGeneratedColumnExprList =
        descend(n -> n.accept(this), node.getGeneratedColumnExprList());
    if (node.getTableScan() != newTableScan
        || node.getAssertRowsModified() != newAssertRowsModified
        || node.getReturning() != newReturning
        || node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getQueryParameterList() != newQueryParameterList
        || node.getRowList() != newRowList
        || node.getGeneratedColumnExprList() != newGeneratedColumnExprList) {
      ResolvedNodes.ResolvedInsertStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setAssertRowsModified(newAssertRowsModified);
      builder.setReturning(newReturning);
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setQueryParameterList(newQueryParameterList);
      builder.setRowList(newRowList);
      builder.setGeneratedColumnExprList(newGeneratedColumnExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDeleteStmt visit(ResolvedDeleteStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ResolvedAssertRowsModified newAssertRowsModified =
        node.getAssertRowsModified() != null
            ? node.getAssertRowsModified().accept(this)
            : null;
    ResolvedReturningClause newReturning =
        node.getReturning() != null
            ? node.getReturning().accept(this)
            : null;
    ResolvedColumnHolder newArrayOffsetColumn =
        node.getArrayOffsetColumn() != null
            ? node.getArrayOffsetColumn().accept(this)
            : null;
    ResolvedExpr newWhereExpr =
        node.getWhereExpr() != null
            ? node.getWhereExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getTableScan() != newTableScan
        || node.getAssertRowsModified() != newAssertRowsModified
        || node.getReturning() != newReturning
        || node.getArrayOffsetColumn() != newArrayOffsetColumn
        || node.getWhereExpr() != newWhereExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDeleteStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setAssertRowsModified(newAssertRowsModified);
      builder.setReturning(newReturning);
      builder.setArrayOffsetColumn(newArrayOffsetColumn);
      builder.setWhereExpr(newWhereExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUpdateItem visit(ResolvedUpdateItem node) {
    ResolvedExpr newTarget =
        node.getTarget() != null
            ? node.getTarget().accept(this)
            : null;
    ResolvedDMLValue newSetValue =
        node.getSetValue() != null
            ? node.getSetValue().accept(this)
            : null;
    ResolvedColumnHolder newElementColumn =
        node.getElementColumn() != null
            ? node.getElementColumn().accept(this)
            : null;
    ImmutableList newArrayUpdateList =
        descend(n -> n.accept(this), node.getArrayUpdateList());
    ImmutableList newDeleteList =
        descend(n -> n.accept(this), node.getDeleteList());
    ImmutableList newUpdateList =
        descend(n -> n.accept(this), node.getUpdateList());
    ImmutableList newInsertList =
        descend(n -> n.accept(this), node.getInsertList());
    if (node.getTarget() != newTarget
        || node.getSetValue() != newSetValue
        || node.getElementColumn() != newElementColumn
        || node.getArrayUpdateList() != newArrayUpdateList
        || node.getDeleteList() != newDeleteList
        || node.getUpdateList() != newUpdateList
        || node.getInsertList() != newInsertList) {
      ResolvedNodes.ResolvedUpdateItem.Builder builder = node.toBuilder();
      builder.setTarget(newTarget);
      builder.setSetValue(newSetValue);
      builder.setElementColumn(newElementColumn);
      builder.setArrayUpdateList(newArrayUpdateList);
      builder.setDeleteList(newDeleteList);
      builder.setUpdateList(newUpdateList);
      builder.setInsertList(newInsertList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUpdateArrayItem visit(ResolvedUpdateArrayItem node) {
    ResolvedExpr newOffset =
        node.getOffset() != null
            ? node.getOffset().accept(this)
            : null;
    ResolvedUpdateItem newUpdateItem =
        node.getUpdateItem() != null
            ? node.getUpdateItem().accept(this)
            : null;
    if (node.getOffset() != newOffset
        || node.getUpdateItem() != newUpdateItem) {
      ResolvedNodes.ResolvedUpdateArrayItem.Builder builder = node.toBuilder();
      builder.setOffset(newOffset);
      builder.setUpdateItem(newUpdateItem);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUpdateStmt visit(ResolvedUpdateStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ResolvedAssertRowsModified newAssertRowsModified =
        node.getAssertRowsModified() != null
            ? node.getAssertRowsModified().accept(this)
            : null;
    ResolvedReturningClause newReturning =
        node.getReturning() != null
            ? node.getReturning().accept(this)
            : null;
    ResolvedColumnHolder newArrayOffsetColumn =
        node.getArrayOffsetColumn() != null
            ? node.getArrayOffsetColumn().accept(this)
            : null;
    ResolvedExpr newWhereExpr =
        node.getWhereExpr() != null
            ? node.getWhereExpr().accept(this)
            : null;
    ResolvedScan newFromScan =
        node.getFromScan() != null
            ? node.getFromScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newUpdateItemList =
        descend(n -> n.accept(this), node.getUpdateItemList());
    ImmutableList newGeneratedColumnExprList =
        descend(n -> n.accept(this), node.getGeneratedColumnExprList());
    if (node.getTableScan() != newTableScan
        || node.getAssertRowsModified() != newAssertRowsModified
        || node.getReturning() != newReturning
        || node.getArrayOffsetColumn() != newArrayOffsetColumn
        || node.getWhereExpr() != newWhereExpr
        || node.getFromScan() != newFromScan
        || node.getHintList() != newHintList
        || node.getUpdateItemList() != newUpdateItemList
        || node.getGeneratedColumnExprList() != newGeneratedColumnExprList) {
      ResolvedNodes.ResolvedUpdateStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setAssertRowsModified(newAssertRowsModified);
      builder.setReturning(newReturning);
      builder.setArrayOffsetColumn(newArrayOffsetColumn);
      builder.setWhereExpr(newWhereExpr);
      builder.setFromScan(newFromScan);
      builder.setHintList(newHintList);
      builder.setUpdateItemList(newUpdateItemList);
      builder.setGeneratedColumnExprList(newGeneratedColumnExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedMergeWhen visit(ResolvedMergeWhen node) {
    ResolvedExpr newMatchExpr =
        node.getMatchExpr() != null
            ? node.getMatchExpr().accept(this)
            : null;
    ResolvedInsertRow newInsertRow =
        node.getInsertRow() != null
            ? node.getInsertRow().accept(this)
            : null;
    ImmutableList newUpdateItemList =
        descend(n -> n.accept(this), node.getUpdateItemList());
    if (node.getMatchExpr() != newMatchExpr
        || node.getInsertRow() != newInsertRow
        || node.getUpdateItemList() != newUpdateItemList) {
      ResolvedNodes.ResolvedMergeWhen.Builder builder = node.toBuilder();
      builder.setMatchExpr(newMatchExpr);
      builder.setInsertRow(newInsertRow);
      builder.setUpdateItemList(newUpdateItemList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedMergeStmt visit(ResolvedMergeStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ResolvedScan newFromScan =
        node.getFromScan() != null
            ? node.getFromScan().accept(this)
            : null;
    ResolvedExpr newMergeExpr =
        node.getMergeExpr() != null
            ? node.getMergeExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newWhenClauseList =
        descend(n -> n.accept(this), node.getWhenClauseList());
    if (node.getTableScan() != newTableScan
        || node.getFromScan() != newFromScan
        || node.getMergeExpr() != newMergeExpr
        || node.getHintList() != newHintList
        || node.getWhenClauseList() != newWhenClauseList) {
      ResolvedNodes.ResolvedMergeStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setFromScan(newFromScan);
      builder.setMergeExpr(newMergeExpr);
      builder.setHintList(newHintList);
      builder.setWhenClauseList(newWhenClauseList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedTruncateStmt visit(ResolvedTruncateStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ResolvedExpr newWhereExpr =
        node.getWhereExpr() != null
            ? node.getWhereExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getTableScan() != newTableScan
        || node.getWhereExpr() != newWhereExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedTruncateStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setWhereExpr(newWhereExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedObjectUnit visit(ResolvedObjectUnit node) {
    return node;
  }

  protected ResolvedPrivilege visit(ResolvedPrivilege node) {
    ImmutableList newUnitList =
        descend(n -> n.accept(this), node.getUnitList());
    if (node.getUnitList() != newUnitList) {
      ResolvedNodes.ResolvedPrivilege.Builder builder = node.toBuilder();
      builder.setUnitList(newUnitList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGrantStmt visit(ResolvedGrantStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newPrivilegeList =
        descend(n -> n.accept(this), node.getPrivilegeList());
    ImmutableList newGranteeExprList =
        descend(n -> n.accept(this), node.getGranteeExprList());
    if (node.getHintList() != newHintList
        || node.getPrivilegeList() != newPrivilegeList
        || node.getGranteeExprList() != newGranteeExprList) {
      ResolvedNodes.ResolvedGrantStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setPrivilegeList(newPrivilegeList);
      builder.setGranteeExprList(newGranteeExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRevokeStmt visit(ResolvedRevokeStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newPrivilegeList =
        descend(n -> n.accept(this), node.getPrivilegeList());
    ImmutableList newGranteeExprList =
        descend(n -> n.accept(this), node.getGranteeExprList());
    if (node.getHintList() != newHintList
        || node.getPrivilegeList() != newPrivilegeList
        || node.getGranteeExprList() != newGranteeExprList) {
      ResolvedNodes.ResolvedRevokeStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setPrivilegeList(newPrivilegeList);
      builder.setGranteeExprList(newGranteeExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterDatabaseStmt visit(ResolvedAlterDatabaseStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterDatabaseStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterMaterializedViewStmt visit(ResolvedAlterMaterializedViewStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterMaterializedViewStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterApproxViewStmt visit(ResolvedAlterApproxViewStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterApproxViewStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterSchemaStmt visit(ResolvedAlterSchemaStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterSchemaStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterExternalSchemaStmt visit(ResolvedAlterExternalSchemaStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterExternalSchemaStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterModelStmt visit(ResolvedAlterModelStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterModelStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterTableStmt visit(ResolvedAlterTableStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterTableStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterViewStmt visit(ResolvedAlterViewStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterViewStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedSetOptionsAction visit(ResolvedSetOptionsAction node) {
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedSetOptionsAction.Builder builder = node.toBuilder();
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterSubEntityAction visit(ResolvedAlterSubEntityAction node) {
    ResolvedAlterAction newAlterAction =
        node.getAlterAction() != null
            ? node.getAlterAction().accept(this)
            : null;
    if (node.getAlterAction() != newAlterAction) {
      ResolvedNodes.ResolvedAlterSubEntityAction.Builder builder = node.toBuilder();
      builder.setAlterAction(newAlterAction);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAddSubEntityAction visit(ResolvedAddSubEntityAction node) {
    ImmutableList newOptionsList =
        descend(n -> n.accept(this), node.getOptionsList());
    if (node.getOptionsList() != newOptionsList) {
      ResolvedNodes.ResolvedAddSubEntityAction.Builder builder = node.toBuilder();
      builder.setOptionsList(newOptionsList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropSubEntityAction visit(ResolvedDropSubEntityAction node) {
    return node;
  }

  protected ResolvedAddColumnAction visit(ResolvedAddColumnAction node) {
    ResolvedColumnDefinition newColumnDefinition =
        node.getColumnDefinition() != null
            ? node.getColumnDefinition().accept(this)
            : null;
    if (node.getColumnDefinition() != newColumnDefinition) {
      ResolvedNodes.ResolvedAddColumnAction.Builder builder = node.toBuilder();
      builder.setColumnDefinition(newColumnDefinition);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAddConstraintAction visit(ResolvedAddConstraintAction node) {
    ResolvedConstraint newConstraint =
        node.getConstraint() != null
            ? node.getConstraint().accept(this)
            : null;
    if (node.getConstraint() != newConstraint) {
      ResolvedNodes.ResolvedAddConstraintAction.Builder builder = node.toBuilder();
      builder.setConstraint(newConstraint);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropConstraintAction visit(ResolvedDropConstraintAction node) {
    return node;
  }

  protected ResolvedDropPrimaryKeyAction visit(ResolvedDropPrimaryKeyAction node) {
    return node;
  }

  protected ResolvedAlterColumnOptionsAction visit(ResolvedAlterColumnOptionsAction node) {
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedAlterColumnOptionsAction.Builder builder = node.toBuilder();
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterColumnDropNotNullAction visit(ResolvedAlterColumnDropNotNullAction node) {
    return node;
  }

  protected ResolvedAlterColumnDropGeneratedAction visit(ResolvedAlterColumnDropGeneratedAction node) {
    return node;
  }

  protected ResolvedAlterColumnSetDataTypeAction visit(ResolvedAlterColumnSetDataTypeAction node) {
    ResolvedColumnAnnotations newUpdatedAnnotations =
        node.getUpdatedAnnotations() != null
            ? node.getUpdatedAnnotations().accept(this)
            : null;
    if (node.getUpdatedAnnotations() != newUpdatedAnnotations) {
      ResolvedNodes.ResolvedAlterColumnSetDataTypeAction.Builder builder = node.toBuilder();
      builder.setUpdatedAnnotations(newUpdatedAnnotations);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterColumnSetDefaultAction visit(ResolvedAlterColumnSetDefaultAction node) {
    ResolvedColumnDefaultValue newDefaultValue =
        node.getDefaultValue() != null
            ? node.getDefaultValue().accept(this)
            : null;
    if (node.getDefaultValue() != newDefaultValue) {
      ResolvedNodes.ResolvedAlterColumnSetDefaultAction.Builder builder = node.toBuilder();
      builder.setDefaultValue(newDefaultValue);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterColumnDropDefaultAction visit(ResolvedAlterColumnDropDefaultAction node) {
    return node;
  }

  protected ResolvedDropColumnAction visit(ResolvedDropColumnAction node) {
    return node;
  }

  protected ResolvedRenameColumnAction visit(ResolvedRenameColumnAction node) {
    return node;
  }

  protected ResolvedSetAsAction visit(ResolvedSetAsAction node) {
    return node;
  }

  protected ResolvedSetCollateClause visit(ResolvedSetCollateClause node) {
    ResolvedExpr newCollationName =
        node.getCollationName() != null
            ? node.getCollationName().accept(this)
            : null;
    if (node.getCollationName() != newCollationName) {
      ResolvedNodes.ResolvedSetCollateClause.Builder builder = node.toBuilder();
      builder.setCollationName(newCollationName);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterTableSetOptionsStmt visit(ResolvedAlterTableSetOptionsStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedAlterTableSetOptionsStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRenameStmt visit(ResolvedRenameStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedRenameStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreatePrivilegeRestrictionStmt visit(ResolvedCreatePrivilegeRestrictionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newColumnPrivilegeList =
        descend(n -> n.accept(this), node.getColumnPrivilegeList());
    ImmutableList newRestricteeList =
        descend(n -> n.accept(this), node.getRestricteeList());
    if (node.getHintList() != newHintList
        || node.getColumnPrivilegeList() != newColumnPrivilegeList
        || node.getRestricteeList() != newRestricteeList) {
      ResolvedNodes.ResolvedCreatePrivilegeRestrictionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setColumnPrivilegeList(newColumnPrivilegeList);
      builder.setRestricteeList(newRestricteeList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateRowAccessPolicyStmt visit(ResolvedCreateRowAccessPolicyStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ResolvedExpr newPredicate =
        node.getPredicate() != null
            ? node.getPredicate().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newGranteeExprList =
        descend(n -> n.accept(this), node.getGranteeExprList());
    if (node.getTableScan() != newTableScan
        || node.getPredicate() != newPredicate
        || node.getHintList() != newHintList
        || node.getGranteeExprList() != newGranteeExprList) {
      ResolvedNodes.ResolvedCreateRowAccessPolicyStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setPredicate(newPredicate);
      builder.setHintList(newHintList);
      builder.setGranteeExprList(newGranteeExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropPrivilegeRestrictionStmt visit(ResolvedDropPrivilegeRestrictionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newColumnPrivilegeList =
        descend(n -> n.accept(this), node.getColumnPrivilegeList());
    if (node.getHintList() != newHintList
        || node.getColumnPrivilegeList() != newColumnPrivilegeList) {
      ResolvedNodes.ResolvedDropPrivilegeRestrictionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setColumnPrivilegeList(newColumnPrivilegeList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropRowAccessPolicyStmt visit(ResolvedDropRowAccessPolicyStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropRowAccessPolicyStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropIndexStmt visit(ResolvedDropIndexStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropIndexStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedGrantToAction visit(ResolvedGrantToAction node) {
    ImmutableList newGranteeExprList =
        descend(n -> n.accept(this), node.getGranteeExprList());
    if (node.getGranteeExprList() != newGranteeExprList) {
      ResolvedNodes.ResolvedGrantToAction.Builder builder = node.toBuilder();
      builder.setGranteeExprList(newGranteeExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRestrictToAction visit(ResolvedRestrictToAction node) {
    ImmutableList newRestricteeList =
        descend(n -> n.accept(this), node.getRestricteeList());
    if (node.getRestricteeList() != newRestricteeList) {
      ResolvedNodes.ResolvedRestrictToAction.Builder builder = node.toBuilder();
      builder.setRestricteeList(newRestricteeList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAddToRestricteeListAction visit(ResolvedAddToRestricteeListAction node) {
    ImmutableList newRestricteeList =
        descend(n -> n.accept(this), node.getRestricteeList());
    if (node.getRestricteeList() != newRestricteeList) {
      ResolvedNodes.ResolvedAddToRestricteeListAction.Builder builder = node.toBuilder();
      builder.setRestricteeList(newRestricteeList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRemoveFromRestricteeListAction visit(ResolvedRemoveFromRestricteeListAction node) {
    ImmutableList newRestricteeList =
        descend(n -> n.accept(this), node.getRestricteeList());
    if (node.getRestricteeList() != newRestricteeList) {
      ResolvedNodes.ResolvedRemoveFromRestricteeListAction.Builder builder = node.toBuilder();
      builder.setRestricteeList(newRestricteeList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedFilterUsingAction visit(ResolvedFilterUsingAction node) {
    ResolvedExpr newPredicate =
        node.getPredicate() != null
            ? node.getPredicate().accept(this)
            : null;
    if (node.getPredicate() != newPredicate) {
      ResolvedNodes.ResolvedFilterUsingAction.Builder builder = node.toBuilder();
      builder.setPredicate(newPredicate);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRevokeFromAction visit(ResolvedRevokeFromAction node) {
    ImmutableList newRevokeeExprList =
        descend(n -> n.accept(this), node.getRevokeeExprList());
    if (node.getRevokeeExprList() != newRevokeeExprList) {
      ResolvedNodes.ResolvedRevokeFromAction.Builder builder = node.toBuilder();
      builder.setRevokeeExprList(newRevokeeExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRenameToAction visit(ResolvedRenameToAction node) {
    return node;
  }

  protected ResolvedAlterPrivilegeRestrictionStmt visit(ResolvedAlterPrivilegeRestrictionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    ImmutableList newColumnPrivilegeList =
        descend(n -> n.accept(this), node.getColumnPrivilegeList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList
        || node.getColumnPrivilegeList() != newColumnPrivilegeList) {
      ResolvedNodes.ResolvedAlterPrivilegeRestrictionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      builder.setColumnPrivilegeList(newColumnPrivilegeList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterRowAccessPolicyStmt visit(ResolvedAlterRowAccessPolicyStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getTableScan() != newTableScan
        || node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterRowAccessPolicyStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterAllRowAccessPoliciesStmt visit(ResolvedAlterAllRowAccessPoliciesStmt node) {
    ResolvedTableScan newTableScan =
        node.getTableScan() != null
            ? node.getTableScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getTableScan() != newTableScan
        || node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterAllRowAccessPoliciesStmt.Builder builder = node.toBuilder();
      builder.setTableScan(newTableScan);
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateConstantStmt visit(ResolvedCreateConstantStmt node) {
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getExpr() != newExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedCreateConstantStmt.Builder builder = node.toBuilder();
      builder.setExpr(newExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateFunctionStmt visit(ResolvedCreateFunctionStmt node) {
    ResolvedExpr newFunctionExpression =
        node.getFunctionExpression() != null
            ? node.getFunctionExpression().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAggregateExpressionList =
        descend(n -> n.accept(this), node.getAggregateExpressionList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getFunctionExpression() != newFunctionExpression
        || node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getAggregateExpressionList() != newAggregateExpressionList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateFunctionStmt.Builder builder = node.toBuilder();
      builder.setFunctionExpression(newFunctionExpression);
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setAggregateExpressionList(newAggregateExpressionList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedArgumentDef visit(ResolvedArgumentDef node) {
    return node;
  }

  protected ResolvedArgumentRef visit(ResolvedArgumentRef node) {
    return node;
  }

  protected ResolvedCreateTableFunctionStmt visit(ResolvedCreateTableFunctionStmt node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    if (node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getOutputColumnList() != newOutputColumnList) {
      ResolvedNodes.ResolvedCreateTableFunctionStmt.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setOutputColumnList(newOutputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedRelationArgumentScan visit(ResolvedRelationArgumentScan node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedRelationArgumentScan.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedArgumentList visit(ResolvedArgumentList node) {
    ImmutableList newArgList =
        descend(n -> n.accept(this), node.getArgList());
    if (node.getArgList() != newArgList) {
      ResolvedNodes.ResolvedArgumentList.Builder builder = node.toBuilder();
      builder.setArgList(newArgList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedFunctionSignatureHolder visit(ResolvedFunctionSignatureHolder node) {
    return node;
  }

  protected ResolvedDropFunctionStmt visit(ResolvedDropFunctionStmt node) {
    ResolvedArgumentList newArguments =
        node.getArguments() != null
            ? node.getArguments().accept(this)
            : null;
    ResolvedFunctionSignatureHolder newSignature =
        node.getSignature() != null
            ? node.getSignature().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getArguments() != newArguments
        || node.getSignature() != newSignature
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropFunctionStmt.Builder builder = node.toBuilder();
      builder.setArguments(newArguments);
      builder.setSignature(newSignature);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedDropTableFunctionStmt visit(ResolvedDropTableFunctionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedDropTableFunctionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCallStmt visit(ResolvedCallStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newArgumentList =
        descend(n -> n.accept(this), node.getArgumentList());
    if (node.getHintList() != newHintList
        || node.getArgumentList() != newArgumentList) {
      ResolvedNodes.ResolvedCallStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setArgumentList(newArgumentList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedImportStmt visit(ResolvedImportStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedImportStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedModuleStmt visit(ResolvedModuleStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedModuleStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAggregateHavingModifier visit(ResolvedAggregateHavingModifier node) {
    ResolvedExpr newHavingExpr =
        node.getHavingExpr() != null
            ? node.getHavingExpr().accept(this)
            : null;
    if (node.getHavingExpr() != newHavingExpr) {
      ResolvedNodes.ResolvedAggregateHavingModifier.Builder builder = node.toBuilder();
      builder.setHavingExpr(newHavingExpr);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateMaterializedViewStmt visit(ResolvedCreateMaterializedViewStmt node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ResolvedScan newReplicaSource =
        node.getReplicaSource() != null
            ? node.getReplicaSource().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    ImmutableList newClusterByList =
        descend(n -> n.accept(this), node.getClusterByList());
    if (node.getQuery() != newQuery
        || node.getReplicaSource() != newReplicaSource
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getOutputColumnList() != newOutputColumnList
        || node.getColumnDefinitionList() != newColumnDefinitionList
        || node.getPartitionByList() != newPartitionByList
        || node.getClusterByList() != newClusterByList) {
      ResolvedNodes.ResolvedCreateMaterializedViewStmt.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setReplicaSource(newReplicaSource);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setOutputColumnList(newOutputColumnList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      builder.setPartitionByList(newPartitionByList);
      builder.setClusterByList(newClusterByList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateApproxViewStmt visit(ResolvedCreateApproxViewStmt node) {
    ResolvedScan newQuery =
        node.getQuery() != null
            ? node.getQuery().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    if (node.getQuery() != newQuery
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getOutputColumnList() != newOutputColumnList
        || node.getColumnDefinitionList() != newColumnDefinitionList) {
      ResolvedNodes.ResolvedCreateApproxViewStmt.Builder builder = node.toBuilder();
      builder.setQuery(newQuery);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setOutputColumnList(newOutputColumnList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateProcedureStmt visit(ResolvedCreateProcedureStmt node) {
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateProcedureStmt.Builder builder = node.toBuilder();
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExecuteImmediateArgument visit(ResolvedExecuteImmediateArgument node) {
    ResolvedExpr newExpression =
        node.getExpression() != null
            ? node.getExpression().accept(this)
            : null;
    if (node.getExpression() != newExpression) {
      ResolvedNodes.ResolvedExecuteImmediateArgument.Builder builder = node.toBuilder();
      builder.setExpression(newExpression);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedExecuteImmediateStmt visit(ResolvedExecuteImmediateStmt node) {
    ResolvedExpr newSql =
        node.getSql() != null
            ? node.getSql().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newUsingArgumentList =
        descend(n -> n.accept(this), node.getUsingArgumentList());
    if (node.getSql() != newSql
        || node.getHintList() != newHintList
        || node.getUsingArgumentList() != newUsingArgumentList) {
      ResolvedNodes.ResolvedExecuteImmediateStmt.Builder builder = node.toBuilder();
      builder.setSql(newSql);
      builder.setHintList(newHintList);
      builder.setUsingArgumentList(newUsingArgumentList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAssignmentStmt visit(ResolvedAssignmentStmt node) {
    ResolvedExpr newTarget =
        node.getTarget() != null
            ? node.getTarget().accept(this)
            : null;
    ResolvedExpr newExpr =
        node.getExpr() != null
            ? node.getExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getTarget() != newTarget
        || node.getExpr() != newExpr
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedAssignmentStmt.Builder builder = node.toBuilder();
      builder.setTarget(newTarget);
      builder.setExpr(newExpr);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateEntityStmt visit(ResolvedCreateEntityStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateEntityStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterEntityStmt visit(ResolvedAlterEntityStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterEntityStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedPivotColumn visit(ResolvedPivotColumn node) {
    return node;
  }

  protected ResolvedPivotScan visit(ResolvedPivotScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newForExpr =
        node.getForExpr() != null
            ? node.getForExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newGroupByList =
        descend(n -> n.accept(this), node.getGroupByList());
    ImmutableList newPivotExprList =
        descend(n -> n.accept(this), node.getPivotExprList());
    ImmutableList newPivotValueList =
        descend(n -> n.accept(this), node.getPivotValueList());
    ImmutableList newPivotColumnList =
        descend(n -> n.accept(this), node.getPivotColumnList());
    if (node.getInputScan() != newInputScan
        || node.getForExpr() != newForExpr
        || node.getHintList() != newHintList
        || node.getGroupByList() != newGroupByList
        || node.getPivotExprList() != newPivotExprList
        || node.getPivotValueList() != newPivotValueList
        || node.getPivotColumnList() != newPivotColumnList) {
      ResolvedNodes.ResolvedPivotScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setForExpr(newForExpr);
      builder.setHintList(newHintList);
      builder.setGroupByList(newGroupByList);
      builder.setPivotExprList(newPivotExprList);
      builder.setPivotValueList(newPivotValueList);
      builder.setPivotColumnList(newPivotColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedReturningClause visit(ResolvedReturningClause node) {
    ResolvedColumnHolder newActionColumn =
        node.getActionColumn() != null
            ? node.getActionColumn().accept(this)
            : null;
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    ImmutableList newExprList =
        descend(n -> n.accept(this), node.getExprList());
    if (node.getActionColumn() != newActionColumn
        || node.getOutputColumnList() != newOutputColumnList
        || node.getExprList() != newExprList) {
      ResolvedNodes.ResolvedReturningClause.Builder builder = node.toBuilder();
      builder.setActionColumn(newActionColumn);
      builder.setOutputColumnList(newOutputColumnList);
      builder.setExprList(newExprList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUnpivotArg visit(ResolvedUnpivotArg node) {
    ImmutableList newColumnList =
        descend(n -> n.accept(this), node.getColumnList());
    if (node.getColumnList() != newColumnList) {
      ResolvedNodes.ResolvedUnpivotArg.Builder builder = node.toBuilder();
      builder.setColumnList(newColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUnpivotScan visit(ResolvedUnpivotScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newLabelList =
        descend(n -> n.accept(this), node.getLabelList());
    ImmutableList newUnpivotArgList =
        descend(n -> n.accept(this), node.getUnpivotArgList());
    ImmutableList newProjectedInputColumnList =
        descend(n -> n.accept(this), node.getProjectedInputColumnList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList
        || node.getLabelList() != newLabelList
        || node.getUnpivotArgList() != newUnpivotArgList
        || node.getProjectedInputColumnList() != newProjectedInputColumnList) {
      ResolvedNodes.ResolvedUnpivotScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      builder.setLabelList(newLabelList);
      builder.setUnpivotArgList(newUnpivotArgList);
      builder.setProjectedInputColumnList(newProjectedInputColumnList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCloneDataStmt visit(ResolvedCloneDataStmt node) {
    ResolvedTableScan newTargetTable =
        node.getTargetTable() != null
            ? node.getTargetTable().accept(this)
            : null;
    ResolvedScan newCloneFrom =
        node.getCloneFrom() != null
            ? node.getCloneFrom().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getTargetTable() != newTargetTable
        || node.getCloneFrom() != newCloneFrom
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedCloneDataStmt.Builder builder = node.toBuilder();
      builder.setTargetTable(newTargetTable);
      builder.setCloneFrom(newCloneFrom);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedTableAndColumnInfo visit(ResolvedTableAndColumnInfo node) {
    return node;
  }

  protected ResolvedAnalyzeStmt visit(ResolvedAnalyzeStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newTableAndColumnIndexList =
        descend(n -> n.accept(this), node.getTableAndColumnIndexList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList
        || node.getTableAndColumnIndexList() != newTableAndColumnIndexList) {
      ResolvedNodes.ResolvedAnalyzeStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      builder.setTableAndColumnIndexList(newTableAndColumnIndexList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAuxLoadDataPartitionFilter visit(ResolvedAuxLoadDataPartitionFilter node) {
    ResolvedExpr newFilter =
        node.getFilter() != null
            ? node.getFilter().accept(this)
            : null;
    if (node.getFilter() != newFilter) {
      ResolvedNodes.ResolvedAuxLoadDataPartitionFilter.Builder builder = node.toBuilder();
      builder.setFilter(newFilter);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAuxLoadDataStmt visit(ResolvedAuxLoadDataStmt node) {
    ResolvedAuxLoadDataPartitionFilter newPartitionFilter =
        node.getPartitionFilter() != null
            ? node.getPartitionFilter().accept(this)
            : null;
    ResolvedPrimaryKey newPrimaryKey =
        node.getPrimaryKey() != null
            ? node.getPrimaryKey().accept(this)
            : null;
    ResolvedWithPartitionColumns newWithPartitionColumns =
        node.getWithPartitionColumns() != null
            ? node.getWithPartitionColumns().accept(this)
            : null;
    ResolvedConnection newConnection =
        node.getConnection() != null
            ? node.getConnection().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOutputColumnList =
        descend(n -> n.accept(this), node.getOutputColumnList());
    ImmutableList newColumnDefinitionList =
        descend(n -> n.accept(this), node.getColumnDefinitionList());
    ImmutableList newForeignKeyList =
        descend(n -> n.accept(this), node.getForeignKeyList());
    ImmutableList newCheckConstraintList =
        descend(n -> n.accept(this), node.getCheckConstraintList());
    ImmutableList newPartitionByList =
        descend(n -> n.accept(this), node.getPartitionByList());
    ImmutableList newClusterByList =
        descend(n -> n.accept(this), node.getClusterByList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    ImmutableList newFromFilesOptionList =
        descend(n -> n.accept(this), node.getFromFilesOptionList());
    if (node.getPartitionFilter() != newPartitionFilter
        || node.getPrimaryKey() != newPrimaryKey
        || node.getWithPartitionColumns() != newWithPartitionColumns
        || node.getConnection() != newConnection
        || node.getHintList() != newHintList
        || node.getOutputColumnList() != newOutputColumnList
        || node.getColumnDefinitionList() != newColumnDefinitionList
        || node.getForeignKeyList() != newForeignKeyList
        || node.getCheckConstraintList() != newCheckConstraintList
        || node.getPartitionByList() != newPartitionByList
        || node.getClusterByList() != newClusterByList
        || node.getOptionList() != newOptionList
        || node.getFromFilesOptionList() != newFromFilesOptionList) {
      ResolvedNodes.ResolvedAuxLoadDataStmt.Builder builder = node.toBuilder();
      builder.setPartitionFilter(newPartitionFilter);
      builder.setPrimaryKey(newPrimaryKey);
      builder.setWithPartitionColumns(newWithPartitionColumns);
      builder.setConnection(newConnection);
      builder.setHintList(newHintList);
      builder.setOutputColumnList(newOutputColumnList);
      builder.setColumnDefinitionList(newColumnDefinitionList);
      builder.setForeignKeyList(newForeignKeyList);
      builder.setCheckConstraintList(newCheckConstraintList);
      builder.setPartitionByList(newPartitionByList);
      builder.setClusterByList(newClusterByList);
      builder.setOptionList(newOptionList);
      builder.setFromFilesOptionList(newFromFilesOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedUndropStmt visit(ResolvedUndropStmt node) {
    ResolvedExpr newForSystemTimeExpr =
        node.getForSystemTimeExpr() != null
            ? node.getForSystemTimeExpr().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getForSystemTimeExpr() != newForSystemTimeExpr
        || node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedUndropStmt.Builder builder = node.toBuilder();
      builder.setForSystemTimeExpr(newForSystemTimeExpr);
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedIdentityColumnInfo visit(ResolvedIdentityColumnInfo node) {
    return node;
  }

  protected ResolvedStaticDescribeScan visit(ResolvedStaticDescribeScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedStaticDescribeScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAssertScan visit(ResolvedAssertScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ResolvedExpr newCondition =
        node.getCondition() != null
            ? node.getCondition().accept(this)
            : null;
    ResolvedExpr newMessage =
        node.getMessage() != null
            ? node.getMessage().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInputScan() != newInputScan
        || node.getCondition() != newCondition
        || node.getMessage() != newMessage
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedAssertScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setCondition(newCondition);
      builder.setMessage(newMessage);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedBarrierScan visit(ResolvedBarrierScan node) {
    ResolvedScan newInputScan =
        node.getInputScan() != null
            ? node.getInputScan().accept(this)
            : null;
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    if (node.getInputScan() != newInputScan
        || node.getHintList() != newHintList) {
      ResolvedNodes.ResolvedBarrierScan.Builder builder = node.toBuilder();
      builder.setInputScan(newInputScan);
      builder.setHintList(newHintList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedCreateConnectionStmt visit(ResolvedCreateConnectionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newOptionList =
        descend(n -> n.accept(this), node.getOptionList());
    if (node.getHintList() != newHintList
        || node.getOptionList() != newOptionList) {
      ResolvedNodes.ResolvedCreateConnectionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setOptionList(newOptionList);
      return builder.build();
    } else {
      return node;
    }
  }

  protected ResolvedAlterConnectionStmt visit(ResolvedAlterConnectionStmt node) {
    ImmutableList newHintList =
        descend(n -> n.accept(this), node.getHintList());
    ImmutableList newAlterActionList =
        descend(n -> n.accept(this), node.getAlterActionList());
    if (node.getHintList() != newHintList
        || node.getAlterActionList() != newAlterActionList) {
      ResolvedNodes.ResolvedAlterConnectionStmt.Builder builder = node.toBuilder();
      builder.setHintList(newHintList);
      builder.setAlterActionList(newAlterActionList);
      return builder.build();
    } else {
      return node;
    }
  }

  /**
   * Visits each element of the given list and returns an updated copy of the
   * list if any element is changed, or the given list instance otherwise.
   */
  private  ImmutableList descend(
      Function acceptFunc, @Nullable ImmutableList list) {
    if (list != null) {
      int index = 0;
      T rewrittenElement = null;
      for (index = 0; index < list.size(); index++) {
        rewrittenElement = acceptFunc.apply(list.get(index));
        if (rewrittenElement != list.get(index)) {
          // This element of the list needs to change, so we have to copy.
          break;
        }
      }
      if (index == list.size()) {
        // No element of the list changed, so return the original list.
        return list;
      } else {
        ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize(list.size());
        // Copy the unmodified prefix of the list.
        list.subList(0, index).forEach(builder::add);
        // Add the first modified element.
        builder.add(rewrittenElement);
        // Call the visitor with each remaining element.
        while (++index < list.size()) {
          builder.add(acceptFunc.apply(list.get(index)));
        }
        return builder.build();
      }
    } else {
      return null;
    }
  }
}