pub trait Fold<T, T2>{
Show 314 methods
// Required methods
fn fold_cluster_name(
&mut self,
node: <T as AstInfo>::ClusterName,
) -> <T2 as AstInfo>::ClusterName;
fn fold_column_reference(
&mut self,
node: <T as AstInfo>::ColumnReference,
) -> <T2 as AstInfo>::ColumnReference;
fn fold_cte_id(
&mut self,
node: <T as AstInfo>::CteId,
) -> <T2 as AstInfo>::CteId;
fn fold_data_type(
&mut self,
node: <T as AstInfo>::DataType,
) -> <T2 as AstInfo>::DataType;
fn fold_database_name(
&mut self,
node: <T as AstInfo>::DatabaseName,
) -> <T2 as AstInfo>::DatabaseName;
fn fold_item_name(
&mut self,
node: <T as AstInfo>::ItemName,
) -> <T2 as AstInfo>::ItemName;
fn fold_nested_statement(
&mut self,
node: <T as AstInfo>::NestedStatement,
) -> <T2 as AstInfo>::NestedStatement;
fn fold_network_policy_name(
&mut self,
node: <T as AstInfo>::NetworkPolicyName,
) -> <T2 as AstInfo>::NetworkPolicyName;
fn fold_object_name(
&mut self,
node: <T as AstInfo>::ObjectName,
) -> <T2 as AstInfo>::ObjectName;
fn fold_role_name(
&mut self,
node: <T as AstInfo>::RoleName,
) -> <T2 as AstInfo>::RoleName;
fn fold_schema_name(
&mut self,
node: <T as AstInfo>::SchemaName,
) -> <T2 as AstInfo>::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_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_continual_task_option(
&mut self,
node: ContinualTaskOption<T>,
) -> ContinualTaskOption<T2> { ... }
fn fold_continual_task_option_name(
&mut self,
node: ContinualTaskOptionName,
) -> ContinualTaskOptionName { ... }
fn fold_continual_task_stmt(
&mut self,
node: ContinualTaskStmt<T>,
) -> ContinualTaskStmt<T2> { ... }
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_continual_task_statement(
&mut self,
node: CreateContinualTaskStatement<T>,
) -> CreateContinualTaskStatement<T2> { ... }
fn fold_create_continual_task_sugar(
&mut self,
node: CreateContinualTaskSugar<T>,
) -> CreateContinualTaskSugar<T2> { ... }
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_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_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_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_sink_key(&mut self, node: KafkaSinkKey) -> KafkaSinkKey { ... }
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_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_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_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_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> { ... }