Trait Fold

Source

pub trait Fold<T: AstInfo, T2: AstInfo> {
Show 326 methods    // Required methods
    fn fold_cluster_name(&mut self, node: T::ClusterName) -> T2::ClusterName;
    fn fold_column_reference(
        &mut self,
        node: T::ColumnReference,
    ) -> T2::ColumnReference;
    fn fold_cte_id(&mut self, node: T::CteId) -> T2::CteId;
    fn fold_data_type(&mut self, node: T::DataType) -> T2::DataType;
    fn fold_database_name(&mut self, node: T::DatabaseName) -> T2::DatabaseName;
    fn fold_item_name(&mut self, node: T::ItemName) -> T2::ItemName;
    fn fold_nested_statement(
        &mut self,
        node: T::NestedStatement,
    ) -> T2::NestedStatement;
    fn fold_network_policy_name(
        &mut self,
        node: T::NetworkPolicyName,
    ) -> T2::NetworkPolicyName;
    fn fold_object_name(&mut self, node: T::ObjectName) -> T2::ObjectName;
    fn fold_role_name(&mut self, node: T::RoleName) -> T2::RoleName;
    fn fold_schema_name(&mut self, node: T::SchemaName) -> T2::SchemaName;

    // Provided methods
    fn fold_abbreviated_grant_or_revoke_statement(
        &mut self,
        node: AbbreviatedGrantOrRevokeStatement<T>,
    ) -> AbbreviatedGrantOrRevokeStatement<T2> { ... }
    fn fold_abbreviated_grant_statement(
        &mut self,
        node: AbbreviatedGrantStatement<T>,
    ) -> AbbreviatedGrantStatement<T2> { ... }
    fn fold_abbreviated_revoke_statement(
        &mut self,
        node: AbbreviatedRevokeStatement<T>,
    ) -> AbbreviatedRevokeStatement<T2> { ... }
    fn fold_alter_cluster_action(
        &mut self,
        node: AlterClusterAction<T>,
    ) -> AlterClusterAction<T2> { ... }
    fn fold_alter_cluster_statement(
        &mut self,
        node: AlterClusterStatement<T>,
    ) -> AlterClusterStatement<T2> { ... }
    fn fold_alter_connection_action(
        &mut self,
        node: AlterConnectionAction<T>,
    ) -> AlterConnectionAction<T2> { ... }
    fn fold_alter_connection_option(
        &mut self,
        node: AlterConnectionOption<T>,
    ) -> AlterConnectionOption<T2> { ... }
    fn fold_alter_connection_option_name(
        &mut self,
        node: AlterConnectionOptionName,
    ) -> AlterConnectionOptionName { ... }
    fn fold_alter_connection_statement(
        &mut self,
        node: AlterConnectionStatement<T>,
    ) -> AlterConnectionStatement<T2> { ... }
    fn fold_alter_default_privileges_statement(
        &mut self,
        node: AlterDefaultPrivilegesStatement<T>,
    ) -> AlterDefaultPrivilegesStatement<T2> { ... }
    fn fold_alter_index_action(
        &mut self,
        node: AlterIndexAction<T>,
    ) -> AlterIndexAction<T2> { ... }
    fn fold_alter_index_statement(
        &mut self,
        node: AlterIndexStatement<T>,
    ) -> AlterIndexStatement<T2> { ... }
    fn fold_alter_materialized_view_apply_replacement_statement(
        &mut self,
        node: AlterMaterializedViewApplyReplacementStatement,
    ) -> AlterMaterializedViewApplyReplacementStatement { ... }
    fn fold_alter_network_policy_statement(
        &mut self,
        node: AlterNetworkPolicyStatement<T>,
    ) -> AlterNetworkPolicyStatement<T2> { ... }
    fn fold_alter_object_rename_statement(
        &mut self,
        node: AlterObjectRenameStatement,
    ) -> AlterObjectRenameStatement { ... }
    fn fold_alter_object_swap_statement(
        &mut self,
        node: AlterObjectSwapStatement,
    ) -> AlterObjectSwapStatement { ... }
    fn fold_alter_owner_statement(
        &mut self,
        node: AlterOwnerStatement<T>,
    ) -> AlterOwnerStatement<T2> { ... }
    fn fold_alter_retain_history_statement(
        &mut self,
        node: AlterRetainHistoryStatement<T>,
    ) -> AlterRetainHistoryStatement<T2> { ... }
    fn fold_alter_role_option(
        &mut self,
        node: AlterRoleOption,
    ) -> AlterRoleOption { ... }
    fn fold_alter_role_statement(
        &mut self,
        node: AlterRoleStatement<T>,
    ) -> AlterRoleStatement<T2> { ... }
    fn fold_alter_secret_statement(
        &mut self,
        node: AlterSecretStatement<T>,
    ) -> AlterSecretStatement<T2> { ... }
    fn fold_alter_set_cluster_statement(
        &mut self,
        node: AlterSetClusterStatement<T>,
    ) -> AlterSetClusterStatement<T2> { ... }
    fn fold_alter_sink_action(
        &mut self,
        node: AlterSinkAction<T>,
    ) -> AlterSinkAction<T2> { ... }
    fn fold_alter_sink_statement(
        &mut self,
        node: AlterSinkStatement<T>,
    ) -> AlterSinkStatement<T2> { ... }
    fn fold_alter_source_action(
        &mut self,
        node: AlterSourceAction<T>,
    ) -> AlterSourceAction<T2> { ... }
    fn fold_alter_source_add_subsource_option(
        &mut self,
        node: AlterSourceAddSubsourceOption<T>,
    ) -> AlterSourceAddSubsourceOption<T2> { ... }
    fn fold_alter_source_add_subsource_option_name(
        &mut self,
        node: AlterSourceAddSubsourceOptionName,
    ) -> AlterSourceAddSubsourceOptionName { ... }
    fn fold_alter_source_statement(
        &mut self,
        node: AlterSourceStatement<T>,
    ) -> AlterSourceStatement<T2> { ... }
    fn fold_alter_system_reset_all_statement(
        &mut self,
        node: AlterSystemResetAllStatement,
    ) -> AlterSystemResetAllStatement { ... }
    fn fold_alter_system_reset_statement(
        &mut self,
        node: AlterSystemResetStatement,
    ) -> AlterSystemResetStatement { ... }
    fn fold_alter_system_set_statement(
        &mut self,
        node: AlterSystemSetStatement,
    ) -> AlterSystemSetStatement { ... }
    fn fold_alter_table_add_column_statement(
        &mut self,
        node: AlterTableAddColumnStatement<T>,
    ) -> AlterTableAddColumnStatement<T2> { ... }
    fn fold_as_of(&mut self, node: AsOf<T>) -> AsOf<T2> { ... }
    fn fold_assignment(&mut self, node: Assignment<T>) -> Assignment<T2> { ... }
    fn fold_avro_doc_on(&mut self, node: AvroDocOn<T>) -> AvroDocOn<T2> { ... }
    fn fold_avro_schema(&mut self, node: AvroSchema<T>) -> AvroSchema<T2> { ... }
    fn fold_avro_schema_option(
        &mut self,
        node: AvroSchemaOption<T>,
    ) -> AvroSchemaOption<T2> { ... }
    fn fold_avro_schema_option_name(
        &mut self,
        node: AvroSchemaOptionName,
    ) -> AvroSchemaOptionName { ... }
    fn fold_catalog_name(&mut self, node: CatalogName) -> CatalogName { ... }
    fn fold_close_statement(&mut self, node: CloseStatement) -> CloseStatement { ... }
    fn fold_cluster_alter_option(
        &mut self,
        node: ClusterAlterOption<T>,
    ) -> ClusterAlterOption<T2> { ... }
    fn fold_cluster_alter_option_name(
        &mut self,
        node: ClusterAlterOptionName,
    ) -> ClusterAlterOptionName { ... }
    fn fold_cluster_alter_option_value(
        &mut self,
        node: ClusterAlterOptionValue<T>,
    ) -> ClusterAlterOptionValue<T2> { ... }
    fn fold_cluster_alter_until_ready_option(
        &mut self,
        node: ClusterAlterUntilReadyOption<T>,
    ) -> ClusterAlterUntilReadyOption<T2> { ... }
    fn fold_cluster_alter_until_ready_option_name(
        &mut self,
        node: ClusterAlterUntilReadyOptionName,
    ) -> ClusterAlterUntilReadyOptionName { ... }
    fn fold_cluster_feature(
        &mut self,
        node: ClusterFeature<T>,
    ) -> ClusterFeature<T2> { ... }
    fn fold_cluster_feature_name(
        &mut self,
        node: ClusterFeatureName,
    ) -> ClusterFeatureName { ... }
    fn fold_cluster_option(
        &mut self,
        node: ClusterOption<T>,
    ) -> ClusterOption<T2> { ... }
    fn fold_cluster_option_name(
        &mut self,
        node: ClusterOptionName,
    ) -> ClusterOptionName { ... }
    fn fold_cluster_schedule_option_value(
        &mut self,
        node: ClusterScheduleOptionValue,
    ) -> ClusterScheduleOptionValue { ... }
    fn fold_column_def(&mut self, node: ColumnDef<T>) -> ColumnDef<T2> { ... }
    fn fold_column_name(&mut self, node: ColumnName<T>) -> ColumnName<T2> { ... }
    fn fold_column_option(&mut self, node: ColumnOption<T>) -> ColumnOption<T2> { ... }
    fn fold_column_option_def(
        &mut self,
        node: ColumnOptionDef<T>,
    ) -> ColumnOptionDef<T2> { ... }
    fn fold_column_versioned(
        &mut self,
        node: ColumnVersioned,
    ) -> ColumnVersioned { ... }
    fn fold_comment_object_type(
        &mut self,
        node: CommentObjectType<T>,
    ) -> CommentObjectType<T2> { ... }
    fn fold_comment_statement(
        &mut self,
        node: CommentStatement<T>,
    ) -> CommentStatement<T2> { ... }
    fn fold_commit_statement(
        &mut self,
        node: CommitStatement,
    ) -> CommitStatement { ... }
    fn fold_connection_default_aws_privatelink(
        &mut self,
        node: ConnectionDefaultAwsPrivatelink<T>,
    ) -> ConnectionDefaultAwsPrivatelink<T2> { ... }
    fn fold_connection_option(
        &mut self,
        node: ConnectionOption<T>,
    ) -> ConnectionOption<T2> { ... }
    fn fold_connection_option_name(
        &mut self,
        node: ConnectionOptionName,
    ) -> ConnectionOptionName { ... }
    fn fold_connection_rule_pattern(
        &mut self,
        node: ConnectionRulePattern,
    ) -> ConnectionRulePattern { ... }
    fn fold_copy_direction(&mut self, node: CopyDirection) -> CopyDirection { ... }
    fn fold_copy_option(&mut self, node: CopyOption<T>) -> CopyOption<T2> { ... }
    fn fold_copy_option_name(&mut self, node: CopyOptionName) -> CopyOptionName { ... }
    fn fold_copy_relation(&mut self, node: CopyRelation<T>) -> CopyRelation<T2> { ... }
    fn fold_copy_statement(
        &mut self,
        node: CopyStatement<T>,
    ) -> CopyStatement<T2> { ... }
    fn fold_copy_target(&mut self, node: CopyTarget<T>) -> CopyTarget<T2> { ... }
    fn fold_create_cluster_replica_statement(
        &mut self,
        node: CreateClusterReplicaStatement<T>,
    ) -> CreateClusterReplicaStatement<T2> { ... }
    fn fold_create_cluster_statement(
        &mut self,
        node: CreateClusterStatement<T>,
    ) -> CreateClusterStatement<T2> { ... }
    fn fold_create_connection_option(
        &mut self,
        node: CreateConnectionOption<T>,
    ) -> CreateConnectionOption<T2> { ... }
    fn fold_create_connection_option_name(
        &mut self,
        node: CreateConnectionOptionName,
    ) -> CreateConnectionOptionName { ... }
    fn fold_create_connection_statement(
        &mut self,
        node: CreateConnectionStatement<T>,
    ) -> CreateConnectionStatement<T2> { ... }
    fn fold_create_connection_type(
        &mut self,
        node: CreateConnectionType,
    ) -> CreateConnectionType { ... }
    fn fold_create_database_statement(
        &mut self,
        node: CreateDatabaseStatement,
    ) -> CreateDatabaseStatement { ... }
    fn fold_create_index_statement(
        &mut self,
        node: CreateIndexStatement<T>,
    ) -> CreateIndexStatement<T2> { ... }
    fn fold_create_materialized_view_statement(
        &mut self,
        node: CreateMaterializedViewStatement<T>,
    ) -> CreateMaterializedViewStatement<T2> { ... }
    fn fold_create_network_policy_statement(
        &mut self,
        node: CreateNetworkPolicyStatement<T>,
    ) -> CreateNetworkPolicyStatement<T2> { ... }
    fn fold_create_role_statement(
        &mut self,
        node: CreateRoleStatement,
    ) -> CreateRoleStatement { ... }
    fn fold_create_schema_statement(
        &mut self,
        node: CreateSchemaStatement,
    ) -> CreateSchemaStatement { ... }
    fn fold_create_secret_statement(
        &mut self,
        node: CreateSecretStatement<T>,
    ) -> CreateSecretStatement<T2> { ... }
    fn fold_create_sink_connection(
        &mut self,
        node: CreateSinkConnection<T>,
    ) -> CreateSinkConnection<T2> { ... }
    fn fold_create_sink_option(
        &mut self,
        node: CreateSinkOption<T>,
    ) -> CreateSinkOption<T2> { ... }
    fn fold_create_sink_option_name(
        &mut self,
        node: CreateSinkOptionName,
    ) -> CreateSinkOptionName { ... }
    fn fold_create_sink_statement(
        &mut self,
        node: CreateSinkStatement<T>,
    ) -> CreateSinkStatement<T2> { ... }
    fn fold_create_source_connection(
        &mut self,
        node: CreateSourceConnection<T>,
    ) -> CreateSourceConnection<T2> { ... }
    fn fold_create_source_option(
        &mut self,
        node: CreateSourceOption<T>,
    ) -> CreateSourceOption<T2> { ... }
    fn fold_create_source_option_name(
        &mut self,
        node: CreateSourceOptionName,
    ) -> CreateSourceOptionName { ... }
    fn fold_create_source_statement(
        &mut self,
        node: CreateSourceStatement<T>,
    ) -> CreateSourceStatement<T2> { ... }
    fn fold_create_subsource_option(
        &mut self,
        node: CreateSubsourceOption<T>,
    ) -> CreateSubsourceOption<T2> { ... }
    fn fold_create_subsource_option_name(
        &mut self,
        node: CreateSubsourceOptionName,
    ) -> CreateSubsourceOptionName { ... }
    fn fold_create_subsource_statement(
        &mut self,
        node: CreateSubsourceStatement<T>,
    ) -> CreateSubsourceStatement<T2> { ... }
    fn fold_create_table_from_source_statement(
        &mut self,
        node: CreateTableFromSourceStatement<T>,
    ) -> CreateTableFromSourceStatement<T2> { ... }
    fn fold_create_table_statement(
        &mut self,
        node: CreateTableStatement<T>,
    ) -> CreateTableStatement<T2> { ... }
    fn fold_create_type_as(&mut self, node: CreateTypeAs<T>) -> CreateTypeAs<T2> { ... }
    fn fold_create_type_list_option(
        &mut self,
        node: CreateTypeListOption<T>,
    ) -> CreateTypeListOption<T2> { ... }
    fn fold_create_type_list_option_name(
        &mut self,
        node: CreateTypeListOptionName,
    ) -> CreateTypeListOptionName { ... }
    fn fold_create_type_map_option(
        &mut self,
        node: CreateTypeMapOption<T>,
    ) -> CreateTypeMapOption<T2> { ... }
    fn fold_create_type_map_option_name(
        &mut self,
        node: CreateTypeMapOptionName,
    ) -> CreateTypeMapOptionName { ... }
    fn fold_create_type_statement(
        &mut self,
        node: CreateTypeStatement<T>,
    ) -> CreateTypeStatement<T2> { ... }
    fn fold_create_view_statement(
        &mut self,
        node: CreateViewStatement<T>,
    ) -> CreateViewStatement<T2> { ... }
    fn fold_create_webhook_source_body(
        &mut self,
        node: CreateWebhookSourceBody,
    ) -> CreateWebhookSourceBody { ... }
    fn fold_create_webhook_source_check(
        &mut self,
        node: CreateWebhookSourceCheck<T>,
    ) -> CreateWebhookSourceCheck<T2> { ... }
    fn fold_create_webhook_source_check_options(
        &mut self,
        node: CreateWebhookSourceCheckOptions<T>,
    ) -> CreateWebhookSourceCheckOptions<T2> { ... }
    fn fold_create_webhook_source_filter_header(
        &mut self,
        node: CreateWebhookSourceFilterHeader,
    ) -> CreateWebhookSourceFilterHeader { ... }
    fn fold_create_webhook_source_header(
        &mut self,
        node: CreateWebhookSourceHeader,
    ) -> CreateWebhookSourceHeader { ... }
    fn fold_create_webhook_source_include_headers(
        &mut self,
        node: CreateWebhookSourceIncludeHeaders,
    ) -> CreateWebhookSourceIncludeHeaders { ... }
    fn fold_create_webhook_source_map_header(
        &mut self,
        node: CreateWebhookSourceMapHeader,
    ) -> CreateWebhookSourceMapHeader { ... }
    fn fold_create_webhook_source_secret(
        &mut self,
        node: CreateWebhookSourceSecret<T>,
    ) -> CreateWebhookSourceSecret<T2> { ... }
    fn fold_create_webhook_source_statement(
        &mut self,
        node: CreateWebhookSourceStatement<T>,
    ) -> CreateWebhookSourceStatement<T2> { ... }
    fn fold_csr_config_option(
        &mut self,
        node: CsrConfigOption<T>,
    ) -> CsrConfigOption<T2> { ... }
    fn fold_csr_config_option_name(
        &mut self,
        node: CsrConfigOptionName<T>,
    ) -> CsrConfigOptionName<T2> { ... }
    fn fold_csr_connection(
        &mut self,
        node: CsrConnection<T>,
    ) -> CsrConnection<T2> { ... }
    fn fold_csr_connection_avro(
        &mut self,
        node: CsrConnectionAvro<T>,
    ) -> CsrConnectionAvro<T2> { ... }
    fn fold_csr_connection_protobuf(
        &mut self,
        node: CsrConnectionProtobuf<T>,
    ) -> CsrConnectionProtobuf<T2> { ... }
    fn fold_csr_seed_avro(&mut self, node: CsrSeedAvro) -> CsrSeedAvro { ... }
    fn fold_csr_seed_protobuf(
        &mut self,
        node: CsrSeedProtobuf,
    ) -> CsrSeedProtobuf { ... }
    fn fold_csr_seed_protobuf_schema(
        &mut self,
        node: CsrSeedProtobufSchema,
    ) -> CsrSeedProtobufSchema { ... }
    fn fold_csv_columns(&mut self, node: CsvColumns) -> CsvColumns { ... }
    fn fold_cte(&mut self, node: Cte<T>) -> Cte<T2> { ... }
    fn fold_cte_block(&mut self, node: CteBlock<T>) -> CteBlock<T2> { ... }
    fn fold_cte_mut_rec(&mut self, node: CteMutRec<T>) -> CteMutRec<T2> { ... }
    fn fold_cte_mut_rec_column_def(
        &mut self,
        node: CteMutRecColumnDef<T>,
    ) -> CteMutRecColumnDef<T2> { ... }
    fn fold_date_time_field(&mut self, node: DateTimeField) -> DateTimeField { ... }
    fn fold_deallocate_statement(
        &mut self,
        node: DeallocateStatement,
    ) -> DeallocateStatement { ... }
    fn fold_declare_statement(
        &mut self,
        node: DeclareStatement<T>,
    ) -> DeclareStatement<T2> { ... }
    fn fold_deferred_item_name(
        &mut self,
        node: DeferredItemName<T>,
    ) -> DeferredItemName<T2> { ... }
    fn fold_delete_statement(
        &mut self,
        node: DeleteStatement<T>,
    ) -> DeleteStatement<T2> { ... }
    fn fold_discard_statement(
        &mut self,
        node: DiscardStatement,
    ) -> DiscardStatement { ... }
    fn fold_discard_target(&mut self, node: DiscardTarget) -> DiscardTarget { ... }
    fn fold_distinct(&mut self, node: Distinct<T>) -> Distinct<T2> { ... }
    fn fold_doc_on_identifier(
        &mut self,
        node: DocOnIdentifier<T>,
    ) -> DocOnIdentifier<T2> { ... }
    fn fold_doc_on_schema(&mut self, node: DocOnSchema) -> DocOnSchema { ... }
    fn fold_drop_objects_statement(
        &mut self,
        node: DropObjectsStatement,
    ) -> DropObjectsStatement { ... }
    fn fold_drop_owned_statement(
        &mut self,
        node: DropOwnedStatement<T>,
    ) -> DropOwnedStatement<T2> { ... }
    fn fold_execute_statement(
        &mut self,
        node: ExecuteStatement<T>,
    ) -> ExecuteStatement<T2> { ... }
    fn fold_execute_unit_test_statement(
        &mut self,
        node: ExecuteUnitTestStatement<T>,
    ) -> ExecuteUnitTestStatement<T2> { ... }
    fn fold_expected_result_def(
        &mut self,
        node: ExpectedResultDef<T>,
    ) -> ExpectedResultDef<T2> { ... }
    fn fold_explain_analyze_cluster_statement(
        &mut self,
        node: ExplainAnalyzeClusterStatement,
    ) -> ExplainAnalyzeClusterStatement { ... }
    fn fold_explain_analyze_computation_properties(
        &mut self,
        node: ExplainAnalyzeComputationProperties,
    ) -> ExplainAnalyzeComputationProperties { ... }
    fn fold_explain_analyze_computation_property(
        &mut self,
        node: ExplainAnalyzeComputationProperty,
    ) -> ExplainAnalyzeComputationProperty { ... }
    fn fold_explain_analyze_object_statement(
        &mut self,
        node: ExplainAnalyzeObjectStatement<T>,
    ) -> ExplainAnalyzeObjectStatement<T2> { ... }
    fn fold_explain_analyze_property(
        &mut self,
        node: ExplainAnalyzeProperty,
    ) -> ExplainAnalyzeProperty { ... }
    fn fold_explain_format(&mut self, node: ExplainFormat) -> ExplainFormat { ... }
    fn fold_explain_plan_option(
        &mut self,
        node: ExplainPlanOption<T>,
    ) -> ExplainPlanOption<T2> { ... }
    fn fold_explain_plan_option_name(
        &mut self,
        node: ExplainPlanOptionName,
    ) -> ExplainPlanOptionName { ... }
    fn fold_explain_plan_statement(
        &mut self,
        node: ExplainPlanStatement<T>,
    ) -> ExplainPlanStatement<T2> { ... }
    fn fold_explain_pushdown_statement(
        &mut self,
        node: ExplainPushdownStatement<T>,
    ) -> ExplainPushdownStatement<T2> { ... }
    fn fold_explain_sink_schema_for(
        &mut self,
        node: ExplainSinkSchemaFor,
    ) -> ExplainSinkSchemaFor { ... }
    fn fold_explain_sink_schema_statement(
        &mut self,
        node: ExplainSinkSchemaStatement<T>,
    ) -> ExplainSinkSchemaStatement<T2> { ... }
    fn fold_explain_stage(&mut self, node: ExplainStage) -> ExplainStage { ... }
    fn fold_explain_timestamp_statement(
        &mut self,
        node: ExplainTimestampStatement<T>,
    ) -> ExplainTimestampStatement<T2> { ... }
    fn fold_explainee(&mut self, node: Explainee<T>) -> Explainee<T2> { ... }
    fn fold_expr(&mut self, node: Expr<T>) -> Expr<T2> { ... }
    fn fold_external_reference_export(
        &mut self,
        node: ExternalReferenceExport,
    ) -> ExternalReferenceExport { ... }
    fn fold_external_references(
        &mut self,
        node: ExternalReferences,
    ) -> ExternalReferences { ... }
    fn fold_fetch_direction(&mut self, node: FetchDirection) -> FetchDirection { ... }
    fn fold_fetch_option(&mut self, node: FetchOption<T>) -> FetchOption<T2> { ... }
    fn fold_fetch_option_name(
        &mut self,
        node: FetchOptionName,
    ) -> FetchOptionName { ... }
    fn fold_fetch_statement(
        &mut self,
        node: FetchStatement<T>,
    ) -> FetchStatement<T2> { ... }
    fn fold_format(&mut self, node: Format<T>) -> Format<T2> { ... }
    fn fold_format_specifier(
        &mut self,
        node: FormatSpecifier<T>,
    ) -> FormatSpecifier<T2> { ... }
    fn fold_function(&mut self, node: Function<T>) -> Function<T2> { ... }
    fn fold_function_args(&mut self, node: FunctionArgs<T>) -> FunctionArgs<T2> { ... }
    fn fold_grant_privileges_statement(
        &mut self,
        node: GrantPrivilegesStatement<T>,
    ) -> GrantPrivilegesStatement<T2> { ... }
    fn fold_grant_role_statement(
        &mut self,
        node: GrantRoleStatement<T>,
    ) -> GrantRoleStatement<T2> { ... }
    fn fold_grant_target_all_specification(
        &mut self,
        node: GrantTargetAllSpecification<T>,
    ) -> GrantTargetAllSpecification<T2> { ... }
    fn fold_grant_target_specification(
        &mut self,
        node: GrantTargetSpecification<T>,
    ) -> GrantTargetSpecification<T2> { ... }
    fn fold_grant_target_specification_inner(
        &mut self,
        node: GrantTargetSpecificationInner<T>,
    ) -> GrantTargetSpecificationInner<T2> { ... }
    fn fold_homogenizing_function(
        &mut self,
        node: HomogenizingFunction,
    ) -> HomogenizingFunction { ... }
    fn fold_iceberg_sink_config_option(
        &mut self,
        node: IcebergSinkConfigOption<T>,
    ) -> IcebergSinkConfigOption<T2> { ... }
    fn fold_iceberg_sink_config_option_name(
        &mut self,
        node: IcebergSinkConfigOptionName,
    ) -> IcebergSinkConfigOptionName { ... }
    fn fold_iceberg_sink_mode(
        &mut self,
        node: IcebergSinkMode,
    ) -> IcebergSinkMode { ... }
    fn fold_ident(&mut self, node: Ident) -> Ident { ... }
    fn fold_ident_error(&mut self, node: IdentError) -> IdentError { ... }
    fn fold_if_exists_behavior(
        &mut self,
        node: IfExistsBehavior,
    ) -> IfExistsBehavior { ... }
    fn fold_index_option(&mut self, node: IndexOption<T>) -> IndexOption<T2> { ... }
    fn fold_index_option_name(
        &mut self,
        node: IndexOptionName,
    ) -> IndexOptionName { ... }
    fn fold_insert_source(&mut self, node: InsertSource<T>) -> InsertSource<T2> { ... }
    fn fold_insert_statement(
        &mut self,
        node: InsertStatement<T>,
    ) -> InsertStatement<T2> { ... }
    fn fold_inspect_shard_statement(
        &mut self,
        node: InspectShardStatement,
    ) -> InspectShardStatement { ... }
    fn fold_interval_value(&mut self, node: IntervalValue) -> IntervalValue { ... }
    fn fold_is_expr_construct(
        &mut self,
        node: IsExprConstruct<T>,
    ) -> IsExprConstruct<T2> { ... }
    fn fold_join(&mut self, node: Join<T>) -> Join<T2> { ... }
    fn fold_join_constraint(
        &mut self,
        node: JoinConstraint<T>,
    ) -> JoinConstraint<T2> { ... }
    fn fold_join_operator(&mut self, node: JoinOperator<T>) -> JoinOperator<T2> { ... }
    fn fold_kafka_broker(&mut self, node: KafkaBroker<T>) -> KafkaBroker<T2> { ... }
    fn fold_kafka_broker_aws_privatelink(
        &mut self,
        node: KafkaBrokerAwsPrivatelink<T>,
    ) -> KafkaBrokerAwsPrivatelink<T2> { ... }
    fn fold_kafka_broker_aws_privatelink_option(
        &mut self,
        node: KafkaBrokerAwsPrivatelinkOption<T>,
    ) -> KafkaBrokerAwsPrivatelinkOption<T2> { ... }
    fn fold_kafka_broker_aws_privatelink_option_name(
        &mut self,
        node: KafkaBrokerAwsPrivatelinkOptionName,
    ) -> KafkaBrokerAwsPrivatelinkOptionName { ... }
    fn fold_kafka_broker_tunnel(
        &mut self,
        node: KafkaBrokerTunnel<T>,
    ) -> KafkaBrokerTunnel<T2> { ... }
    fn fold_kafka_matching_broker_rule(
        &mut self,
        node: KafkaMatchingBrokerRule<T>,
    ) -> KafkaMatchingBrokerRule<T2> { ... }
    fn fold_kafka_sink_config_option(
        &mut self,
        node: KafkaSinkConfigOption<T>,
    ) -> KafkaSinkConfigOption<T2> { ... }
    fn fold_kafka_sink_config_option_name(
        &mut self,
        node: KafkaSinkConfigOptionName,
    ) -> KafkaSinkConfigOptionName { ... }
    fn fold_kafka_source_config_option(
        &mut self,
        node: KafkaSourceConfigOption<T>,
    ) -> KafkaSourceConfigOption<T2> { ... }
    fn fold_kafka_source_config_option_name(
        &mut self,
        node: KafkaSourceConfigOptionName,
    ) -> KafkaSourceConfigOptionName { ... }
    fn fold_key_constraint(&mut self, node: KeyConstraint) -> KeyConstraint { ... }
    fn fold_limit(&mut self, node: Limit<T>) -> Limit<T2> { ... }
    fn fold_load_generator(&mut self, node: LoadGenerator) -> LoadGenerator { ... }
    fn fold_load_generator_option(
        &mut self,
        node: LoadGeneratorOption<T>,
    ) -> LoadGeneratorOption<T2> { ... }
    fn fold_load_generator_option_name(
        &mut self,
        node: LoadGeneratorOptionName,
    ) -> LoadGeneratorOptionName { ... }
    fn fold_map_entry(&mut self, node: MapEntry<T>) -> MapEntry<T2> { ... }
    fn fold_materialized_view_option(
        &mut self,
        node: MaterializedViewOption<T>,
    ) -> MaterializedViewOption<T2> { ... }
    fn fold_materialized_view_option_name(
        &mut self,
        node: MaterializedViewOptionName,
    ) -> MaterializedViewOptionName { ... }
    fn fold_mock_view_def(&mut self, node: MockViewDef<T>) -> MockViewDef<T2> { ... }
    fn fold_mut_rec_block(&mut self, node: MutRecBlock<T>) -> MutRecBlock<T2> { ... }
    fn fold_mut_rec_block_option(
        &mut self,
        node: MutRecBlockOption<T>,
    ) -> MutRecBlockOption<T2> { ... }
    fn fold_mut_rec_block_option_name(
        &mut self,
        node: MutRecBlockOptionName,
    ) -> MutRecBlockOptionName { ... }
    fn fold_my_sql_config_option(
        &mut self,
        node: MySqlConfigOption<T>,
    ) -> MySqlConfigOption<T2> { ... }
    fn fold_my_sql_config_option_name(
        &mut self,
        node: MySqlConfigOptionName,
    ) -> MySqlConfigOptionName { ... }
    fn fold_named_plan(&mut self, node: NamedPlan) -> NamedPlan { ... }
    fn fold_network_policy_option(
        &mut self,
        node: NetworkPolicyOption<T>,
    ) -> NetworkPolicyOption<T2> { ... }
    fn fold_network_policy_option_name(
        &mut self,
        node: NetworkPolicyOptionName,
    ) -> NetworkPolicyOptionName { ... }
    fn fold_network_policy_rule_definition(
        &mut self,
        node: NetworkPolicyRuleDefinition<T>,
    ) -> NetworkPolicyRuleDefinition<T2> { ... }
    fn fold_network_policy_rule_option(
        &mut self,
        node: NetworkPolicyRuleOption<T>,
    ) -> NetworkPolicyRuleOption<T2> { ... }
    fn fold_network_policy_rule_option_name(
        &mut self,
        node: NetworkPolicyRuleOptionName,
    ) -> NetworkPolicyRuleOptionName { ... }
    fn fold_notice_severity(&mut self, node: NoticeSeverity) -> NoticeSeverity { ... }
    fn fold_object_type(&mut self, node: ObjectType) -> ObjectType { ... }
    fn fold_op(&mut self, node: Op) -> Op { ... }
    fn fold_order_by_expr(&mut self, node: OrderByExpr<T>) -> OrderByExpr<T2> { ... }
    fn fold_pg_config_option(
        &mut self,
        node: PgConfigOption<T>,
    ) -> PgConfigOption<T2> { ... }
    fn fold_pg_config_option_name(
        &mut self,
        node: PgConfigOptionName,
    ) -> PgConfigOptionName { ... }
    fn fold_prepare_statement(
        &mut self,
        node: PrepareStatement<T>,
    ) -> PrepareStatement<T2> { ... }
    fn fold_privilege(&mut self, node: Privilege) -> Privilege { ... }
    fn fold_privilege_specification(
        &mut self,
        node: PrivilegeSpecification,
    ) -> PrivilegeSpecification { ... }
    fn fold_protobuf_schema(
        &mut self,
        node: ProtobufSchema<T>,
    ) -> ProtobufSchema<T2> { ... }
    fn fold_qualified_replica(
        &mut self,
        node: QualifiedReplica,
    ) -> QualifiedReplica { ... }
    fn fold_query(&mut self, node: Query<T>) -> Query<T2> { ... }
    fn fold_raise_statement(&mut self, node: RaiseStatement) -> RaiseStatement { ... }
    fn fold_reader_schema_selection_strategy(
        &mut self,
        node: ReaderSchemaSelectionStrategy,
    ) -> ReaderSchemaSelectionStrategy { ... }
    fn fold_reassign_owned_statement(
        &mut self,
        node: ReassignOwnedStatement<T>,
    ) -> ReassignOwnedStatement<T2> { ... }
    fn fold_refresh_at_option_value(
        &mut self,
        node: RefreshAtOptionValue<T>,
    ) -> RefreshAtOptionValue<T2> { ... }
    fn fold_refresh_every_option_value(
        &mut self,
        node: RefreshEveryOptionValue<T>,
    ) -> RefreshEveryOptionValue<T2> { ... }
    fn fold_refresh_option_value(
        &mut self,
        node: RefreshOptionValue<T>,
    ) -> RefreshOptionValue<T2> { ... }
    fn fold_replica_definition(
        &mut self,
        node: ReplicaDefinition<T>,
    ) -> ReplicaDefinition<T2> { ... }
    fn fold_replica_option(
        &mut self,
        node: ReplicaOption<T>,
    ) -> ReplicaOption<T2> { ... }
    fn fold_replica_option_name(
        &mut self,
        node: ReplicaOptionName,
    ) -> ReplicaOptionName { ... }
    fn fold_reset_variable_statement(
        &mut self,
        node: ResetVariableStatement,
    ) -> ResetVariableStatement { ... }
    fn fold_revoke_privileges_statement(
        &mut self,
        node: RevokePrivilegesStatement<T>,
    ) -> RevokePrivilegesStatement<T2> { ... }
    fn fold_revoke_role_statement(
        &mut self,
        node: RevokeRoleStatement<T>,
    ) -> RevokeRoleStatement<T2> { ... }
    fn fold_role_attribute(&mut self, node: RoleAttribute) -> RoleAttribute { ... }
    fn fold_rollback_statement(
        &mut self,
        node: RollbackStatement,
    ) -> RollbackStatement { ... }
    fn fold_schema(&mut self, node: Schema) -> Schema { ... }
    fn fold_select(&mut self, node: Select<T>) -> Select<T2> { ... }
    fn fold_select_item(&mut self, node: SelectItem<T>) -> SelectItem<T2> { ... }
    fn fold_select_option(&mut self, node: SelectOption<T>) -> SelectOption<T2> { ... }
    fn fold_select_option_name(
        &mut self,
        node: SelectOptionName,
    ) -> SelectOptionName { ... }
    fn fold_select_statement(
        &mut self,
        node: SelectStatement<T>,
    ) -> SelectStatement<T2> { ... }
    fn fold_set_expr(&mut self, node: SetExpr<T>) -> SetExpr<T2> { ... }
    fn fold_set_operator(&mut self, node: SetOperator) -> SetOperator { ... }
    fn fold_set_role_var(&mut self, node: SetRoleVar) -> SetRoleVar { ... }
    fn fold_set_transaction_statement(
        &mut self,
        node: SetTransactionStatement,
    ) -> SetTransactionStatement { ... }
    fn fold_set_variable_statement(
        &mut self,
        node: SetVariableStatement,
    ) -> SetVariableStatement { ... }
    fn fold_set_variable_to(&mut self, node: SetVariableTo) -> SetVariableTo { ... }
    fn fold_set_variable_value(
        &mut self,
        node: SetVariableValue,
    ) -> SetVariableValue { ... }
    fn fold_show_columns_statement(
        &mut self,
        node: ShowColumnsStatement<T>,
    ) -> ShowColumnsStatement<T2> { ... }
    fn fold_show_create_cluster_statement(
        &mut self,
        node: ShowCreateClusterStatement<T>,
    ) -> ShowCreateClusterStatement<T2> { ... }
    fn fold_show_create_connection_statement(
        &mut self,
        node: ShowCreateConnectionStatement<T>,
    ) -> ShowCreateConnectionStatement<T2> { ... }
    fn fold_show_create_index_statement(
        &mut self,
        node: ShowCreateIndexStatement<T>,
    ) -> ShowCreateIndexStatement<T2> { ... }
    fn fold_show_create_materialized_view_statement(
        &mut self,
        node: ShowCreateMaterializedViewStatement<T>,
    ) -> ShowCreateMaterializedViewStatement<T2> { ... }
    fn fold_show_create_sink_statement(
        &mut self,
        node: ShowCreateSinkStatement<T>,
    ) -> ShowCreateSinkStatement<T2> { ... }
    fn fold_show_create_source_statement(
        &mut self,
        node: ShowCreateSourceStatement<T>,
    ) -> ShowCreateSourceStatement<T2> { ... }
    fn fold_show_create_table_statement(
        &mut self,
        node: ShowCreateTableStatement<T>,
    ) -> ShowCreateTableStatement<T2> { ... }
    fn fold_show_create_type_statement(
        &mut self,
        node: ShowCreateTypeStatement<T>,
    ) -> ShowCreateTypeStatement<T2> { ... }
    fn fold_show_create_view_statement(
        &mut self,
        node: ShowCreateViewStatement<T>,
    ) -> ShowCreateViewStatement<T2> { ... }
    fn fold_show_object_type(
        &mut self,
        node: ShowObjectType<T>,
    ) -> ShowObjectType<T2> { ... }
    fn fold_show_objects_statement(
        &mut self,
        node: ShowObjectsStatement<T>,
    ) -> ShowObjectsStatement<T2> { ... }
    fn fold_show_statement(
        &mut self,
        node: ShowStatement<T>,
    ) -> ShowStatement<T2> { ... }
    fn fold_show_statement_filter(
        &mut self,
        node: ShowStatementFilter<T>,
    ) -> ShowStatementFilter<T2> { ... }
    fn fold_show_variable_statement(
        &mut self,
        node: ShowVariableStatement,
    ) -> ShowVariableStatement { ... }
    fn fold_sink_envelope(&mut self, node: SinkEnvelope) -> SinkEnvelope { ... }
    fn fold_sink_key(&mut self, node: SinkKey) -> SinkKey { ... }
    fn fold_source_envelope(&mut self, node: SourceEnvelope) -> SourceEnvelope { ... }
    fn fold_source_error_policy(
        &mut self,
        node: SourceErrorPolicy,
    ) -> SourceErrorPolicy { ... }
    fn fold_source_include_metadata(
        &mut self,
        node: SourceIncludeMetadata,
    ) -> SourceIncludeMetadata { ... }
    fn fold_sql_server_config_option(
        &mut self,
        node: SqlServerConfigOption<T>,
    ) -> SqlServerConfigOption<T2> { ... }
    fn fold_sql_server_config_option_name(
        &mut self,
        node: SqlServerConfigOptionName,
    ) -> SqlServerConfigOptionName { ... }
    fn fold_start_transaction_statement(
        &mut self,
        node: StartTransactionStatement,
    ) -> StartTransactionStatement { ... }
    fn fold_statement(&mut self, node: Statement<T>) -> Statement<T2> { ... }
    fn fold_subscribe_option(
        &mut self,
        node: SubscribeOption<T>,
    ) -> SubscribeOption<T2> { ... }
    fn fold_subscribe_option_name(
        &mut self,
        node: SubscribeOptionName,
    ) -> SubscribeOptionName { ... }
    fn fold_subscribe_output(
        &mut self,
        node: SubscribeOutput<T>,
    ) -> SubscribeOutput<T2> { ... }
    fn fold_subscribe_relation(
        &mut self,
        node: SubscribeRelation<T>,
    ) -> SubscribeRelation<T2> { ... }
    fn fold_subscribe_statement(
        &mut self,
        node: SubscribeStatement<T>,
    ) -> SubscribeStatement<T2> { ... }
    fn fold_subscript_position(
        &mut self,
        node: SubscriptPosition<T>,
    ) -> SubscriptPosition<T2> { ... }
    fn fold_system_object_type(
        &mut self,
        node: SystemObjectType,
    ) -> SystemObjectType { ... }
    fn fold_table_alias(&mut self, node: TableAlias) -> TableAlias { ... }
    fn fold_table_constraint(
        &mut self,
        node: TableConstraint<T>,
    ) -> TableConstraint<T2> { ... }
    fn fold_table_factor(&mut self, node: TableFactor<T>) -> TableFactor<T2> { ... }
    fn fold_table_from_source_columns(
        &mut self,
        node: TableFromSourceColumns<T>,
    ) -> TableFromSourceColumns<T2> { ... }
    fn fold_table_from_source_option(
        &mut self,
        node: TableFromSourceOption<T>,
    ) -> TableFromSourceOption<T2> { ... }
    fn fold_table_from_source_option_name(
        &mut self,
        node: TableFromSourceOptionName,
    ) -> TableFromSourceOptionName { ... }
    fn fold_table_option(&mut self, node: TableOption<T>) -> TableOption<T2> { ... }
    fn fold_table_option_name(
        &mut self,
        node: TableOptionName,
    ) -> TableOptionName { ... }
    fn fold_table_with_joins(
        &mut self,
        node: TableWithJoins<T>,
    ) -> TableWithJoins<T2> { ... }
    fn fold_target_role_specification(
        &mut self,
        node: TargetRoleSpecification<T>,
    ) -> TargetRoleSpecification<T2> { ... }
    fn fold_transaction_access_mode(
        &mut self,
        node: TransactionAccessMode,
    ) -> TransactionAccessMode { ... }
    fn fold_transaction_isolation_level(
        &mut self,
        node: TransactionIsolationLevel,
    ) -> TransactionIsolationLevel { ... }
    fn fold_transaction_mode(
        &mut self,
        node: TransactionMode,
    ) -> TransactionMode { ... }
    fn fold_unresolved_database_name(
        &mut self,
        node: UnresolvedDatabaseName,
    ) -> UnresolvedDatabaseName { ... }
    fn fold_unresolved_item_name(
        &mut self,
        node: UnresolvedItemName,
    ) -> UnresolvedItemName { ... }
    fn fold_unresolved_object_name(
        &mut self,
        node: UnresolvedObjectName,
    ) -> UnresolvedObjectName { ... }
    fn fold_unresolved_schema_name(
        &mut self,
        node: UnresolvedSchemaName,
    ) -> UnresolvedSchemaName { ... }
    fn fold_update_statement(
        &mut self,
        node: UpdateStatement<T>,
    ) -> UpdateStatement<T2> { ... }
    fn fold_validate_connection_statement(
        &mut self,
        node: ValidateConnectionStatement<T>,
    ) -> ValidateConnectionStatement<T2> { ... }
    fn fold_value(&mut self, node: Value) -> Value { ... }
    fn fold_value_error(&mut self, node: ValueError) -> ValueError { ... }
    fn fold_values(&mut self, node: Values<T>) -> Values<T2> { ... }
    fn fold_version(&mut self, node: Version) -> Version { ... }
    fn fold_view_definition(
        &mut self,
        node: ViewDefinition<T>,
    ) -> ViewDefinition<T2> { ... }
    fn fold_window_frame(&mut self, node: WindowFrame) -> WindowFrame { ... }
    fn fold_window_frame_bound(
        &mut self,
        node: WindowFrameBound,
    ) -> WindowFrameBound { ... }
    fn fold_window_frame_units(
        &mut self,
        node: WindowFrameUnits,
    ) -> WindowFrameUnits { ... }
    fn fold_window_spec(&mut self, node: WindowSpec<T>) -> WindowSpec<T2> { ... }
    fn fold_with_option_value(
        &mut self,
        node: WithOptionValue<T>,
    ) -> WithOptionValue<T2> { ... }
}