pub trait Fold<T: AstInfo, T2: AstInfo, > {
    fn fold_abbreviated_grant_or_revoke_statement(&mut self, node: AbbreviatedGrantOrRevokeStatement<T>) -> AbbreviatedGrantOrRevokeStatement<T2> {
        fold_abbreviated_grant_or_revoke_statement(self, node)
    }
    fn fold_abbreviated_grant_statement(&mut self, node: AbbreviatedGrantStatement<T>) -> AbbreviatedGrantStatement<T2> {
        fold_abbreviated_grant_statement(self, node)
    }
    fn fold_abbreviated_revoke_statement(&mut self, node: AbbreviatedRevokeStatement<T>) -> AbbreviatedRevokeStatement<T2> {
        fold_abbreviated_revoke_statement(self, node)
    }
    fn fold_alter_cluster_action(&mut self, node: AlterClusterAction<T>) -> AlterClusterAction<T2> {
        fold_alter_cluster_action(self, node)
    }
    fn fold_alter_cluster_statement(&mut self, node: AlterClusterStatement<T>) -> AlterClusterStatement<T2> {
        fold_alter_cluster_statement(self, node)
    }
    fn fold_alter_connection_action(&mut self, node: AlterConnectionAction<T>) -> AlterConnectionAction<T2> {
        fold_alter_connection_action(self, node)
    }
    fn fold_alter_connection_option(&mut self, node: AlterConnectionOption<T>) -> AlterConnectionOption<T2> {
        fold_alter_connection_option(self, node)
    }
    fn fold_alter_connection_option_name(&mut self, node: AlterConnectionOptionName) -> AlterConnectionOptionName {
        fold_alter_connection_option_name(self, node)
    }
    fn fold_alter_connection_statement(&mut self, node: AlterConnectionStatement<T>) -> AlterConnectionStatement<T2> {
        fold_alter_connection_statement(self, node)
    }
    fn fold_alter_default_privileges_statement(&mut self, node: AlterDefaultPrivilegesStatement<T>) -> AlterDefaultPrivilegesStatement<T2> {
        fold_alter_default_privileges_statement(self, node)
    }
    fn fold_alter_index_action(&mut self, node: AlterIndexAction<T>) -> AlterIndexAction<T2> {
        fold_alter_index_action(self, node)
    }
    fn fold_alter_index_statement(&mut self, node: AlterIndexStatement<T>) -> AlterIndexStatement<T2> {
        fold_alter_index_statement(self, node)
    }
    fn fold_alter_object_rename_statement(&mut self, node: AlterObjectRenameStatement) -> AlterObjectRenameStatement {
        fold_alter_object_rename_statement(self, node)
    }
    fn fold_alter_object_swap_statement(&mut self, node: AlterObjectSwapStatement) -> AlterObjectSwapStatement {
        fold_alter_object_swap_statement(self, node)
    }
    fn fold_alter_owner_statement(&mut self, node: AlterOwnerStatement<T>) -> AlterOwnerStatement<T2> {
        fold_alter_owner_statement(self, node)
    }
    fn fold_alter_retain_history_statement(&mut self, node: AlterRetainHistoryStatement<T>) -> AlterRetainHistoryStatement<T2> {
        fold_alter_retain_history_statement(self, node)
    }
    fn fold_alter_role_option(&mut self, node: AlterRoleOption) -> AlterRoleOption {
        fold_alter_role_option(self, node)
    }
    fn fold_alter_role_statement(&mut self, node: AlterRoleStatement<T>) -> AlterRoleStatement<T2> {
        fold_alter_role_statement(self, node)
    }
    fn fold_alter_secret_statement(&mut self, node: AlterSecretStatement<T>) -> AlterSecretStatement<T2> {
        fold_alter_secret_statement(self, node)
    }
    fn fold_alter_set_cluster_statement(&mut self, node: AlterSetClusterStatement<T>) -> AlterSetClusterStatement<T2> {
        fold_alter_set_cluster_statement(self, node)
    }
    fn fold_alter_sink_action(&mut self, node: AlterSinkAction<T>) -> AlterSinkAction<T2> {
        fold_alter_sink_action(self, node)
    }
    fn fold_alter_sink_statement(&mut self, node: AlterSinkStatement<T>) -> AlterSinkStatement<T2> {
        fold_alter_sink_statement(self, node)
    }
    fn fold_alter_source_action(&mut self, node: AlterSourceAction<T>) -> AlterSourceAction<T2> {
        fold_alter_source_action(self, node)
    }
    fn fold_alter_source_add_subsource_option(&mut self, node: AlterSourceAddSubsourceOption<T>) -> AlterSourceAddSubsourceOption<T2> {
        fold_alter_source_add_subsource_option(self, node)
    }
    fn fold_alter_source_add_subsource_option_name(&mut self, node: AlterSourceAddSubsourceOptionName) -> AlterSourceAddSubsourceOptionName {
        fold_alter_source_add_subsource_option_name(self, node)
    }
    fn fold_alter_source_statement(&mut self, node: AlterSourceStatement<T>) -> AlterSourceStatement<T2> {
        fold_alter_source_statement(self, node)
    }
    fn fold_alter_system_reset_all_statement(&mut self, node: AlterSystemResetAllStatement) -> AlterSystemResetAllStatement {
        fold_alter_system_reset_all_statement(self, node)
    }
    fn fold_alter_system_reset_statement(&mut self, node: AlterSystemResetStatement) -> AlterSystemResetStatement {
        fold_alter_system_reset_statement(self, node)
    }
    fn fold_alter_system_set_statement(&mut self, node: AlterSystemSetStatement) -> AlterSystemSetStatement {
        fold_alter_system_set_statement(self, node)
    }
    fn fold_alter_table_add_column_statement(&mut self, node: AlterTableAddColumnStatement<T>) -> AlterTableAddColumnStatement<T2> {
        fold_alter_table_add_column_statement(self, node)
    }
    fn fold_as_of(&mut self, node: AsOf<T>) -> AsOf<T2> {
        fold_as_of(self, node)
    }
    fn fold_assignment(&mut self, node: Assignment<T>) -> Assignment<T2> {
        fold_assignment(self, node)
    }
    fn fold_avro_doc_on(&mut self, node: AvroDocOn<T>) -> AvroDocOn<T2> {
        fold_avro_doc_on(self, node)
    }
    fn fold_avro_schema(&mut self, node: AvroSchema<T>) -> AvroSchema<T2> {
        fold_avro_schema(self, node)
    }
    fn fold_avro_schema_option(&mut self, node: AvroSchemaOption<T>) -> AvroSchemaOption<T2> {
        fold_avro_schema_option(self, node)
    }
    fn fold_avro_schema_option_name(&mut self, node: AvroSchemaOptionName) -> AvroSchemaOptionName {
        fold_avro_schema_option_name(self, node)
    }
    fn fold_catalog_name(&mut self, node: CatalogName) -> CatalogName {
        fold_catalog_name(self, node)
    }
    fn fold_close_statement(&mut self, node: CloseStatement) -> CloseStatement {
        fold_close_statement(self, node)
    }
    fn fold_cluster_alter_option(&mut self, node: ClusterAlterOption<T>) -> ClusterAlterOption<T2> {
        fold_cluster_alter_option(self, node)
    }
    fn fold_cluster_alter_option_name(&mut self, node: ClusterAlterOptionName) -> ClusterAlterOptionName {
        fold_cluster_alter_option_name(self, node)
    }
    fn fold_cluster_alter_option_value(&mut self, node: ClusterAlterOptionValue) -> ClusterAlterOptionValue {
        fold_cluster_alter_option_value(self, node)
    }
    fn fold_cluster_feature(&mut self, node: ClusterFeature<T>) -> ClusterFeature<T2> {
        fold_cluster_feature(self, node)
    }
    fn fold_cluster_feature_name(&mut self, node: ClusterFeatureName) -> ClusterFeatureName {
        fold_cluster_feature_name(self, node)
    }
    fn fold_cluster_option(&mut self, node: ClusterOption<T>) -> ClusterOption<T2> {
        fold_cluster_option(self, node)
    }
    fn fold_cluster_option_name(&mut self, node: ClusterOptionName) -> ClusterOptionName {
        fold_cluster_option_name(self, node)
    }
    fn fold_cluster_schedule_option_value(&mut self, node: ClusterScheduleOptionValue) -> ClusterScheduleOptionValue {
        fold_cluster_schedule_option_value(self, node)
    }
    fn fold_column_def(&mut self, node: ColumnDef<T>) -> ColumnDef<T2> {
        fold_column_def(self, node)
    }
    fn fold_column_name(&mut self, node: ColumnName<T>) -> ColumnName<T2> {
        fold_column_name(self, node)
    }
    fn fold_column_option(&mut self, node: ColumnOption<T>) -> ColumnOption<T2> {
        fold_column_option(self, node)
    }
    fn fold_column_option_def(&mut self, node: ColumnOptionDef<T>) -> ColumnOptionDef<T2> {
        fold_column_option_def(self, node)
    }
    fn fold_comment_object_type(&mut self, node: CommentObjectType<T>) -> CommentObjectType<T2> {
        fold_comment_object_type(self, node)
    }
    fn fold_comment_statement(&mut self, node: CommentStatement<T>) -> CommentStatement<T2> {
        fold_comment_statement(self, node)
    }
    fn fold_commit_statement(&mut self, node: CommitStatement) -> CommitStatement {
        fold_commit_statement(self, node)
    }
    fn fold_connection_default_aws_privatelink(&mut self, node: ConnectionDefaultAwsPrivatelink<T>) -> ConnectionDefaultAwsPrivatelink<T2> {
        fold_connection_default_aws_privatelink(self, node)
    }
    fn fold_connection_option(&mut self, node: ConnectionOption<T>) -> ConnectionOption<T2> {
        fold_connection_option(self, node)
    }
    fn fold_connection_option_name(&mut self, node: ConnectionOptionName) -> ConnectionOptionName {
        fold_connection_option_name(self, node)
    }
    fn fold_copy_direction(&mut self, node: CopyDirection) -> CopyDirection {
        fold_copy_direction(self, node)
    }
    fn fold_copy_option(&mut self, node: CopyOption<T>) -> CopyOption<T2> {
        fold_copy_option(self, node)
    }
    fn fold_copy_option_name(&mut self, node: CopyOptionName) -> CopyOptionName {
        fold_copy_option_name(self, node)
    }
    fn fold_copy_relation(&mut self, node: CopyRelation<T>) -> CopyRelation<T2> {
        fold_copy_relation(self, node)
    }
    fn fold_copy_statement(&mut self, node: CopyStatement<T>) -> CopyStatement<T2> {
        fold_copy_statement(self, node)
    }
    fn fold_copy_target(&mut self, node: CopyTarget<T>) -> CopyTarget<T2> {
        fold_copy_target(self, node)
    }
    fn fold_create_cluster_replica_statement(&mut self, node: CreateClusterReplicaStatement<T>) -> CreateClusterReplicaStatement<T2> {
        fold_create_cluster_replica_statement(self, node)
    }
    fn fold_create_cluster_statement(&mut self, node: CreateClusterStatement<T>) -> CreateClusterStatement<T2> {
        fold_create_cluster_statement(self, node)
    }
    fn fold_create_connection_option(&mut self, node: CreateConnectionOption<T>) -> CreateConnectionOption<T2> {
        fold_create_connection_option(self, node)
    }
    fn fold_create_connection_option_name(&mut self, node: CreateConnectionOptionName) -> CreateConnectionOptionName {
        fold_create_connection_option_name(self, node)
    }
    fn fold_create_connection_statement(&mut self, node: CreateConnectionStatement<T>) -> CreateConnectionStatement<T2> {
        fold_create_connection_statement(self, node)
    }
    fn fold_create_connection_type(&mut self, node: CreateConnectionType) -> CreateConnectionType {
        fold_create_connection_type(self, node)
    }
    fn fold_create_database_statement(&mut self, node: CreateDatabaseStatement) -> CreateDatabaseStatement {
        fold_create_database_statement(self, node)
    }
    fn fold_create_index_statement(&mut self, node: CreateIndexStatement<T>) -> CreateIndexStatement<T2> {
        fold_create_index_statement(self, node)
    }
    fn fold_create_materialized_view_statement(&mut self, node: CreateMaterializedViewStatement<T>) -> CreateMaterializedViewStatement<T2> {
        fold_create_materialized_view_statement(self, node)
    }
    fn fold_create_role_statement(&mut self, node: CreateRoleStatement) -> CreateRoleStatement {
        fold_create_role_statement(self, node)
    }
    fn fold_create_schema_statement(&mut self, node: CreateSchemaStatement) -> CreateSchemaStatement {
        fold_create_schema_statement(self, node)
    }
    fn fold_create_secret_statement(&mut self, node: CreateSecretStatement<T>) -> CreateSecretStatement<T2> {
        fold_create_secret_statement(self, node)
    }
    fn fold_create_sink_connection(&mut self, node: CreateSinkConnection<T>) -> CreateSinkConnection<T2> {
        fold_create_sink_connection(self, node)
    }
    fn fold_create_sink_option(&mut self, node: CreateSinkOption<T>) -> CreateSinkOption<T2> {
        fold_create_sink_option(self, node)
    }
    fn fold_create_sink_option_name(&mut self, node: CreateSinkOptionName) -> CreateSinkOptionName {
        fold_create_sink_option_name(self, node)
    }
    fn fold_create_sink_statement(&mut self, node: CreateSinkStatement<T>) -> CreateSinkStatement<T2> {
        fold_create_sink_statement(self, node)
    }
    fn fold_create_source_connection(&mut self, node: CreateSourceConnection<T>) -> CreateSourceConnection<T2> {
        fold_create_source_connection(self, node)
    }
    fn fold_create_source_option(&mut self, node: CreateSourceOption<T>) -> CreateSourceOption<T2> {
        fold_create_source_option(self, node)
    }
    fn fold_create_source_option_name(&mut self, node: CreateSourceOptionName) -> CreateSourceOptionName {
        fold_create_source_option_name(self, node)
    }
    fn fold_create_source_statement(&mut self, node: CreateSourceStatement<T>) -> CreateSourceStatement<T2> {
        fold_create_source_statement(self, node)
    }
    fn fold_create_subsource_option(&mut self, node: CreateSubsourceOption<T>) -> CreateSubsourceOption<T2> {
        fold_create_subsource_option(self, node)
    }
    fn fold_create_subsource_option_name(&mut self, node: CreateSubsourceOptionName) -> CreateSubsourceOptionName {
        fold_create_subsource_option_name(self, node)
    }
    fn fold_create_subsource_statement(&mut self, node: CreateSubsourceStatement<T>) -> CreateSubsourceStatement<T2> {
        fold_create_subsource_statement(self, node)
    }
    fn fold_create_table_from_source_statement(&mut self, node: CreateTableFromSourceStatement<T>) -> CreateTableFromSourceStatement<T2> {
        fold_create_table_from_source_statement(self, node)
    }
    fn fold_create_table_statement(&mut self, node: CreateTableStatement<T>) -> CreateTableStatement<T2> {
        fold_create_table_statement(self, node)
    }
    fn fold_create_type_as(&mut self, node: CreateTypeAs<T>) -> CreateTypeAs<T2> {
        fold_create_type_as(self, node)
    }
    fn fold_create_type_list_option(&mut self, node: CreateTypeListOption<T>) -> CreateTypeListOption<T2> {
        fold_create_type_list_option(self, node)
    }
    fn fold_create_type_list_option_name(&mut self, node: CreateTypeListOptionName) -> CreateTypeListOptionName {
        fold_create_type_list_option_name(self, node)
    }
    fn fold_create_type_map_option(&mut self, node: CreateTypeMapOption<T>) -> CreateTypeMapOption<T2> {
        fold_create_type_map_option(self, node)
    }
    fn fold_create_type_map_option_name(&mut self, node: CreateTypeMapOptionName) -> CreateTypeMapOptionName {
        fold_create_type_map_option_name(self, node)
    }
    fn fold_create_type_statement(&mut self, node: CreateTypeStatement<T>) -> CreateTypeStatement<T2> {
        fold_create_type_statement(self, node)
    }
    fn fold_create_view_statement(&mut self, node: CreateViewStatement<T>) -> CreateViewStatement<T2> {
        fold_create_view_statement(self, node)
    }
    fn fold_create_webhook_source_body(&mut self, node: CreateWebhookSourceBody) -> CreateWebhookSourceBody {
        fold_create_webhook_source_body(self, node)
    }
    fn fold_create_webhook_source_check(&mut self, node: CreateWebhookSourceCheck<T>) -> CreateWebhookSourceCheck<T2> {
        fold_create_webhook_source_check(self, node)
    }
    fn fold_create_webhook_source_check_options(&mut self, node: CreateWebhookSourceCheckOptions<T>) -> CreateWebhookSourceCheckOptions<T2> {
        fold_create_webhook_source_check_options(self, node)
    }
    fn fold_create_webhook_source_filter_header(&mut self, node: CreateWebhookSourceFilterHeader) -> CreateWebhookSourceFilterHeader {
        fold_create_webhook_source_filter_header(self, node)
    }
    fn fold_create_webhook_source_header(&mut self, node: CreateWebhookSourceHeader) -> CreateWebhookSourceHeader {
        fold_create_webhook_source_header(self, node)
    }
    fn fold_create_webhook_source_include_headers(&mut self, node: CreateWebhookSourceIncludeHeaders) -> CreateWebhookSourceIncludeHeaders {
        fold_create_webhook_source_include_headers(self, node)
    }
    fn fold_create_webhook_source_map_header(&mut self, node: CreateWebhookSourceMapHeader) -> CreateWebhookSourceMapHeader {
        fold_create_webhook_source_map_header(self, node)
    }
    fn fold_create_webhook_source_secret(&mut self, node: CreateWebhookSourceSecret<T>) -> CreateWebhookSourceSecret<T2> {
        fold_create_webhook_source_secret(self, node)
    }
    fn fold_create_webhook_source_statement(&mut self, node: CreateWebhookSourceStatement<T>) -> CreateWebhookSourceStatement<T2> {
        fold_create_webhook_source_statement(self, node)
    }
    fn fold_csr_config_option(&mut self, node: CsrConfigOption<T>) -> CsrConfigOption<T2> {
        fold_csr_config_option(self, node)
    }
    fn fold_csr_config_option_name(&mut self, node: CsrConfigOptionName<T>) -> CsrConfigOptionName<T2> {
        fold_csr_config_option_name(self, node)
    }
    fn fold_csr_connection(&mut self, node: CsrConnection<T>) -> CsrConnection<T2> {
        fold_csr_connection(self, node)
    }
    fn fold_csr_connection_avro(&mut self, node: CsrConnectionAvro<T>) -> CsrConnectionAvro<T2> {
        fold_csr_connection_avro(self, node)
    }
    fn fold_csr_connection_protobuf(&mut self, node: CsrConnectionProtobuf<T>) -> CsrConnectionProtobuf<T2> {
        fold_csr_connection_protobuf(self, node)
    }
    fn fold_csr_seed_avro(&mut self, node: CsrSeedAvro) -> CsrSeedAvro {
        fold_csr_seed_avro(self, node)
    }
    fn fold_csr_seed_protobuf(&mut self, node: CsrSeedProtobuf) -> CsrSeedProtobuf {
        fold_csr_seed_protobuf(self, node)
    }
    fn fold_csr_seed_protobuf_schema(&mut self, node: CsrSeedProtobufSchema) -> CsrSeedProtobufSchema {
        fold_csr_seed_protobuf_schema(self, node)
    }
    fn fold_csv_columns(&mut self, node: CsvColumns) -> CsvColumns {
        fold_csv_columns(self, node)
    }
    fn fold_cte(&mut self, node: Cte<T>) -> Cte<T2> {
        fold_cte(self, node)
    }
    fn fold_cte_block(&mut self, node: CteBlock<T>) -> CteBlock<T2> {
        fold_cte_block(self, node)
    }
    fn fold_cte_mut_rec(&mut self, node: CteMutRec<T>) -> CteMutRec<T2> {
        fold_cte_mut_rec(self, node)
    }
    fn fold_cte_mut_rec_column_def(&mut self, node: CteMutRecColumnDef<T>) -> CteMutRecColumnDef<T2> {
        fold_cte_mut_rec_column_def(self, node)
    }
    fn fold_date_time_field(&mut self, node: DateTimeField) -> DateTimeField {
        fold_date_time_field(self, node)
    }
    fn fold_deallocate_statement(&mut self, node: DeallocateStatement) -> DeallocateStatement {
        fold_deallocate_statement(self, node)
    }
    fn fold_declare_statement(&mut self, node: DeclareStatement<T>) -> DeclareStatement<T2> {
        fold_declare_statement(self, node)
    }
    fn fold_deferred_item_name(&mut self, node: DeferredItemName<T>) -> DeferredItemName<T2> {
        fold_deferred_item_name(self, node)
    }
    fn fold_delete_statement(&mut self, node: DeleteStatement<T>) -> DeleteStatement<T2> {
        fold_delete_statement(self, node)
    }
    fn fold_discard_statement(&mut self, node: DiscardStatement) -> DiscardStatement {
        fold_discard_statement(self, node)
    }
    fn fold_discard_target(&mut self, node: DiscardTarget) -> DiscardTarget {
        fold_discard_target(self, node)
    }
    fn fold_distinct(&mut self, node: Distinct<T>) -> Distinct<T2> {
        fold_distinct(self, node)
    }
    fn fold_doc_on_identifier(&mut self, node: DocOnIdentifier<T>) -> DocOnIdentifier<T2> {
        fold_doc_on_identifier(self, node)
    }
    fn fold_doc_on_schema(&mut self, node: DocOnSchema) -> DocOnSchema {
        fold_doc_on_schema(self, node)
    }
    fn fold_drop_objects_statement(&mut self, node: DropObjectsStatement) -> DropObjectsStatement {
        fold_drop_objects_statement(self, node)
    }
    fn fold_drop_owned_statement(&mut self, node: DropOwnedStatement<T>) -> DropOwnedStatement<T2> {
        fold_drop_owned_statement(self, node)
    }
    fn fold_execute_statement(&mut self, node: ExecuteStatement<T>) -> ExecuteStatement<T2> {
        fold_execute_statement(self, node)
    }
    fn fold_explain_format(&mut self, node: ExplainFormat) -> ExplainFormat {
        fold_explain_format(self, node)
    }
    fn fold_explain_plan_option(&mut self, node: ExplainPlanOption<T>) -> ExplainPlanOption<T2> {
        fold_explain_plan_option(self, node)
    }
    fn fold_explain_plan_option_name(&mut self, node: ExplainPlanOptionName) -> ExplainPlanOptionName {
        fold_explain_plan_option_name(self, node)
    }
    fn fold_explain_plan_statement(&mut self, node: ExplainPlanStatement<T>) -> ExplainPlanStatement<T2> {
        fold_explain_plan_statement(self, node)
    }
    fn fold_explain_pushdown_statement(&mut self, node: ExplainPushdownStatement<T>) -> ExplainPushdownStatement<T2> {
        fold_explain_pushdown_statement(self, node)
    }
    fn fold_explain_sink_schema_for(&mut self, node: ExplainSinkSchemaFor) -> ExplainSinkSchemaFor {
        fold_explain_sink_schema_for(self, node)
    }
    fn fold_explain_sink_schema_statement(&mut self, node: ExplainSinkSchemaStatement<T>) -> ExplainSinkSchemaStatement<T2> {
        fold_explain_sink_schema_statement(self, node)
    }
    fn fold_explain_stage(&mut self, node: ExplainStage) -> ExplainStage {
        fold_explain_stage(self, node)
    }
    fn fold_explain_timestamp_statement(&mut self, node: ExplainTimestampStatement<T>) -> ExplainTimestampStatement<T2> {
        fold_explain_timestamp_statement(self, node)
    }
    fn fold_explainee(&mut self, node: Explainee<T>) -> Explainee<T2> {
        fold_explainee(self, node)
    }
    fn fold_expr(&mut self, node: Expr<T>) -> Expr<T2> {
        fold_expr(self, node)
    }
    fn fold_external_reference_export(&mut self, node: ExternalReferenceExport) -> ExternalReferenceExport {
        fold_external_reference_export(self, node)
    }
    fn fold_external_references(&mut self, node: ExternalReferences) -> ExternalReferences {
        fold_external_references(self, node)
    }
    fn fold_fetch_direction(&mut self, node: FetchDirection) -> FetchDirection {
        fold_fetch_direction(self, node)
    }
    fn fold_fetch_option(&mut self, node: FetchOption<T>) -> FetchOption<T2> {
        fold_fetch_option(self, node)
    }
    fn fold_fetch_option_name(&mut self, node: FetchOptionName) -> FetchOptionName {
        fold_fetch_option_name(self, node)
    }
    fn fold_fetch_statement(&mut self, node: FetchStatement<T>) -> FetchStatement<T2> {
        fold_fetch_statement(self, node)
    }
    fn fold_format(&mut self, node: Format<T>) -> Format<T2> {
        fold_format(self, node)
    }
    fn fold_format_specifier(&mut self, node: FormatSpecifier<T>) -> FormatSpecifier<T2> {
        fold_format_specifier(self, node)
    }
    fn fold_function(&mut self, node: Function<T>) -> Function<T2> {
        fold_function(self, node)
    }
    fn fold_function_args(&mut self, node: FunctionArgs<T>) -> FunctionArgs<T2> {
        fold_function_args(self, node)
    }
    fn fold_grant_privileges_statement(&mut self, node: GrantPrivilegesStatement<T>) -> GrantPrivilegesStatement<T2> {
        fold_grant_privileges_statement(self, node)
    }
    fn fold_grant_role_statement(&mut self, node: GrantRoleStatement<T>) -> GrantRoleStatement<T2> {
        fold_grant_role_statement(self, node)
    }
    fn fold_grant_target_all_specification(&mut self, node: GrantTargetAllSpecification<T>) -> GrantTargetAllSpecification<T2> {
        fold_grant_target_all_specification(self, node)
    }
    fn fold_grant_target_specification(&mut self, node: GrantTargetSpecification<T>) -> GrantTargetSpecification<T2> {
        fold_grant_target_specification(self, node)
    }
    fn fold_grant_target_specification_inner(&mut self, node: GrantTargetSpecificationInner<T>) -> GrantTargetSpecificationInner<T2> {
        fold_grant_target_specification_inner(self, node)
    }
    fn fold_homogenizing_function(&mut self, node: HomogenizingFunction) -> HomogenizingFunction {
        fold_homogenizing_function(self, node)
    }
    fn fold_ident(&mut self, node: Ident) -> Ident {
        fold_ident(self, node)
    }
    fn fold_ident_error(&mut self, node: IdentError) -> IdentError {
        fold_ident_error(self, node)
    }
    fn fold_if_exists_behavior(&mut self, node: IfExistsBehavior) -> IfExistsBehavior {
        fold_if_exists_behavior(self, node)
    }
    fn fold_index_option(&mut self, node: IndexOption<T>) -> IndexOption<T2> {
        fold_index_option(self, node)
    }
    fn fold_index_option_name(&mut self, node: IndexOptionName) -> IndexOptionName {
        fold_index_option_name(self, node)
    }
    fn fold_insert_source(&mut self, node: InsertSource<T>) -> InsertSource<T2> {
        fold_insert_source(self, node)
    }
    fn fold_insert_statement(&mut self, node: InsertStatement<T>) -> InsertStatement<T2> {
        fold_insert_statement(self, node)
    }
    fn fold_inspect_shard_statement(&mut self, node: InspectShardStatement) -> InspectShardStatement {
        fold_inspect_shard_statement(self, node)
    }
    fn fold_interval_value(&mut self, node: IntervalValue) -> IntervalValue {
        fold_interval_value(self, node)
    }
    fn fold_is_expr_construct(&mut self, node: IsExprConstruct<T>) -> IsExprConstruct<T2> {
        fold_is_expr_construct(self, node)
    }
    fn fold_join(&mut self, node: Join<T>) -> Join<T2> {
        fold_join(self, node)
    }
    fn fold_join_constraint(&mut self, node: JoinConstraint<T>) -> JoinConstraint<T2> {
        fold_join_constraint(self, node)
    }
    fn fold_join_operator(&mut self, node: JoinOperator<T>) -> JoinOperator<T2> {
        fold_join_operator(self, node)
    }
    fn fold_kafka_broker(&mut self, node: KafkaBroker<T>) -> KafkaBroker<T2> {
        fold_kafka_broker(self, node)
    }
    fn fold_kafka_broker_aws_privatelink(&mut self, node: KafkaBrokerAwsPrivatelink<T>) -> KafkaBrokerAwsPrivatelink<T2> {
        fold_kafka_broker_aws_privatelink(self, node)
    }
    fn fold_kafka_broker_aws_privatelink_option(&mut self, node: KafkaBrokerAwsPrivatelinkOption<T>) -> KafkaBrokerAwsPrivatelinkOption<T2> {
        fold_kafka_broker_aws_privatelink_option(self, node)
    }
    fn fold_kafka_broker_aws_privatelink_option_name(&mut self, node: KafkaBrokerAwsPrivatelinkOptionName) -> KafkaBrokerAwsPrivatelinkOptionName {
        fold_kafka_broker_aws_privatelink_option_name(self, node)
    }
    fn fold_kafka_broker_tunnel(&mut self, node: KafkaBrokerTunnel<T>) -> KafkaBrokerTunnel<T2> {
        fold_kafka_broker_tunnel(self, node)
    }
    fn fold_kafka_sink_config_option(&mut self, node: KafkaSinkConfigOption<T>) -> KafkaSinkConfigOption<T2> {
        fold_kafka_sink_config_option(self, node)
    }
    fn fold_kafka_sink_config_option_name(&mut self, node: KafkaSinkConfigOptionName) -> KafkaSinkConfigOptionName {
        fold_kafka_sink_config_option_name(self, node)
    }
    fn fold_kafka_sink_key(&mut self, node: KafkaSinkKey) -> KafkaSinkKey {
        fold_kafka_sink_key(self, node)
    }
    fn fold_kafka_source_config_option(&mut self, node: KafkaSourceConfigOption<T>) -> KafkaSourceConfigOption<T2> {
        fold_kafka_source_config_option(self, node)
    }
    fn fold_kafka_source_config_option_name(&mut self, node: KafkaSourceConfigOptionName) -> KafkaSourceConfigOptionName {
        fold_kafka_source_config_option_name(self, node)
    }
    fn fold_key_constraint(&mut self, node: KeyConstraint) -> KeyConstraint {
        fold_key_constraint(self, node)
    }
    fn fold_limit(&mut self, node: Limit<T>) -> Limit<T2> {
        fold_limit(self, node)
    }
    fn fold_load_generator(&mut self, node: LoadGenerator) -> LoadGenerator {
        fold_load_generator(self, node)
    }
    fn fold_load_generator_option(&mut self, node: LoadGeneratorOption<T>) -> LoadGeneratorOption<T2> {
        fold_load_generator_option(self, node)
    }
    fn fold_load_generator_option_name(&mut self, node: LoadGeneratorOptionName) -> LoadGeneratorOptionName {
        fold_load_generator_option_name(self, node)
    }
    fn fold_map_entry(&mut self, node: MapEntry<T>) -> MapEntry<T2> {
        fold_map_entry(self, node)
    }
    fn fold_materialized_view_option(&mut self, node: MaterializedViewOption<T>) -> MaterializedViewOption<T2> {
        fold_materialized_view_option(self, node)
    }
    fn fold_materialized_view_option_name(&mut self, node: MaterializedViewOptionName) -> MaterializedViewOptionName {
        fold_materialized_view_option_name(self, node)
    }
    fn fold_mut_rec_block(&mut self, node: MutRecBlock<T>) -> MutRecBlock<T2> {
        fold_mut_rec_block(self, node)
    }
    fn fold_mut_rec_block_option(&mut self, node: MutRecBlockOption<T>) -> MutRecBlockOption<T2> {
        fold_mut_rec_block_option(self, node)
    }
    fn fold_mut_rec_block_option_name(&mut self, node: MutRecBlockOptionName) -> MutRecBlockOptionName {
        fold_mut_rec_block_option_name(self, node)
    }
    fn fold_my_sql_config_option(&mut self, node: MySqlConfigOption<T>) -> MySqlConfigOption<T2> {
        fold_my_sql_config_option(self, node)
    }
    fn fold_my_sql_config_option_name(&mut self, node: MySqlConfigOptionName) -> MySqlConfigOptionName {
        fold_my_sql_config_option_name(self, node)
    }
    fn fold_named_plan(&mut self, node: NamedPlan) -> NamedPlan {
        fold_named_plan(self, node)
    }
    fn fold_notice_severity(&mut self, node: NoticeSeverity) -> NoticeSeverity {
        fold_notice_severity(self, node)
    }
    fn fold_object_type(&mut self, node: ObjectType) -> ObjectType {
        fold_object_type(self, node)
    }
    fn fold_op(&mut self, node: Op) -> Op {
        fold_op(self, node)
    }
    fn fold_order_by_expr(&mut self, node: OrderByExpr<T>) -> OrderByExpr<T2> {
        fold_order_by_expr(self, node)
    }
    fn fold_pg_config_option(&mut self, node: PgConfigOption<T>) -> PgConfigOption<T2> {
        fold_pg_config_option(self, node)
    }
    fn fold_pg_config_option_name(&mut self, node: PgConfigOptionName) -> PgConfigOptionName {
        fold_pg_config_option_name(self, node)
    }
    fn fold_prepare_statement(&mut self, node: PrepareStatement<T>) -> PrepareStatement<T2> {
        fold_prepare_statement(self, node)
    }
    fn fold_privilege(&mut self, node: Privilege) -> Privilege {
        fold_privilege(self, node)
    }
    fn fold_privilege_specification(&mut self, node: PrivilegeSpecification) -> PrivilegeSpecification {
        fold_privilege_specification(self, node)
    }
    fn fold_protobuf_schema(&mut self, node: ProtobufSchema<T>) -> ProtobufSchema<T2> {
        fold_protobuf_schema(self, node)
    }
    fn fold_qualified_replica(&mut self, node: QualifiedReplica) -> QualifiedReplica {
        fold_qualified_replica(self, node)
    }
    fn fold_query(&mut self, node: Query<T>) -> Query<T2> {
        fold_query(self, node)
    }
    fn fold_raise_statement(&mut self, node: RaiseStatement) -> RaiseStatement {
        fold_raise_statement(self, node)
    }
    fn fold_reader_schema_selection_strategy(&mut self, node: ReaderSchemaSelectionStrategy) -> ReaderSchemaSelectionStrategy {
        fold_reader_schema_selection_strategy(self, node)
    }
    fn fold_reassign_owned_statement(&mut self, node: ReassignOwnedStatement<T>) -> ReassignOwnedStatement<T2> {
        fold_reassign_owned_statement(self, node)
    }
    fn fold_refresh_at_option_value(&mut self, node: RefreshAtOptionValue<T>) -> RefreshAtOptionValue<T2> {
        fold_refresh_at_option_value(self, node)
    }
    fn fold_refresh_every_option_value(&mut self, node: RefreshEveryOptionValue<T>) -> RefreshEveryOptionValue<T2> {
        fold_refresh_every_option_value(self, node)
    }
    fn fold_refresh_option_value(&mut self, node: RefreshOptionValue<T>) -> RefreshOptionValue<T2> {
        fold_refresh_option_value(self, node)
    }
    fn fold_replica_definition(&mut self, node: ReplicaDefinition<T>) -> ReplicaDefinition<T2> {
        fold_replica_definition(self, node)
    }
    fn fold_replica_option(&mut self, node: ReplicaOption<T>) -> ReplicaOption<T2> {
        fold_replica_option(self, node)
    }
    fn fold_replica_option_name(&mut self, node: ReplicaOptionName) -> ReplicaOptionName {
        fold_replica_option_name(self, node)
    }
    fn fold_reset_variable_statement(&mut self, node: ResetVariableStatement) -> ResetVariableStatement {
        fold_reset_variable_statement(self, node)
    }
    fn fold_revoke_privileges_statement(&mut self, node: RevokePrivilegesStatement<T>) -> RevokePrivilegesStatement<T2> {
        fold_revoke_privileges_statement(self, node)
    }
    fn fold_revoke_role_statement(&mut self, node: RevokeRoleStatement<T>) -> RevokeRoleStatement<T2> {
        fold_revoke_role_statement(self, node)
    }
    fn fold_role_attribute(&mut self, node: RoleAttribute) -> RoleAttribute {
        fold_role_attribute(self, node)
    }
    fn fold_rollback_statement(&mut self, node: RollbackStatement) -> RollbackStatement {
        fold_rollback_statement(self, node)
    }
    fn fold_schema(&mut self, node: Schema) -> Schema {
        fold_schema(self, node)
    }
    fn fold_select(&mut self, node: Select<T>) -> Select<T2> {
        fold_select(self, node)
    }
    fn fold_select_item(&mut self, node: SelectItem<T>) -> SelectItem<T2> {
        fold_select_item(self, node)
    }
    fn fold_select_option(&mut self, node: SelectOption<T>) -> SelectOption<T2> {
        fold_select_option(self, node)
    }
    fn fold_select_option_name(&mut self, node: SelectOptionName) -> SelectOptionName {
        fold_select_option_name(self, node)
    }
    fn fold_select_statement(&mut self, node: SelectStatement<T>) -> SelectStatement<T2> {
        fold_select_statement(self, node)
    }
    fn fold_set_expr(&mut self, node: SetExpr<T>) -> SetExpr<T2> {
        fold_set_expr(self, node)
    }
    fn fold_set_operator(&mut self, node: SetOperator) -> SetOperator {
        fold_set_operator(self, node)
    }
    fn fold_set_role_var(&mut self, node: SetRoleVar) -> SetRoleVar {
        fold_set_role_var(self, node)
    }
    fn fold_set_transaction_statement(&mut self, node: SetTransactionStatement) -> SetTransactionStatement {
        fold_set_transaction_statement(self, node)
    }
    fn fold_set_variable_statement(&mut self, node: SetVariableStatement) -> SetVariableStatement {
        fold_set_variable_statement(self, node)
    }
    fn fold_set_variable_to(&mut self, node: SetVariableTo) -> SetVariableTo {
        fold_set_variable_to(self, node)
    }
    fn fold_set_variable_value(&mut self, node: SetVariableValue) -> SetVariableValue {
        fold_set_variable_value(self, node)
    }
    fn fold_show_columns_statement(&mut self, node: ShowColumnsStatement<T>) -> ShowColumnsStatement<T2> {
        fold_show_columns_statement(self, node)
    }
    fn fold_show_create_cluster_statement(&mut self, node: ShowCreateClusterStatement<T>) -> ShowCreateClusterStatement<T2> {
        fold_show_create_cluster_statement(self, node)
    }
    fn fold_show_create_connection_statement(&mut self, node: ShowCreateConnectionStatement<T>) -> ShowCreateConnectionStatement<T2> {
        fold_show_create_connection_statement(self, node)
    }
    fn fold_show_create_index_statement(&mut self, node: ShowCreateIndexStatement<T>) -> ShowCreateIndexStatement<T2> {
        fold_show_create_index_statement(self, node)
    }
    fn fold_show_create_materialized_view_statement(&mut self, node: ShowCreateMaterializedViewStatement<T>) -> ShowCreateMaterializedViewStatement<T2> {
        fold_show_create_materialized_view_statement(self, node)
    }
    fn fold_show_create_sink_statement(&mut self, node: ShowCreateSinkStatement<T>) -> ShowCreateSinkStatement<T2> {
        fold_show_create_sink_statement(self, node)
    }
    fn fold_show_create_source_statement(&mut self, node: ShowCreateSourceStatement<T>) -> ShowCreateSourceStatement<T2> {
        fold_show_create_source_statement(self, node)
    }
    fn fold_show_create_table_statement(&mut self, node: ShowCreateTableStatement<T>) -> ShowCreateTableStatement<T2> {
        fold_show_create_table_statement(self, node)
    }
    fn fold_show_create_view_statement(&mut self, node: ShowCreateViewStatement<T>) -> ShowCreateViewStatement<T2> {
        fold_show_create_view_statement(self, node)
    }
    fn fold_show_object_type(&mut self, node: ShowObjectType<T>) -> ShowObjectType<T2> {
        fold_show_object_type(self, node)
    }
    fn fold_show_objects_statement(&mut self, node: ShowObjectsStatement<T>) -> ShowObjectsStatement<T2> {
        fold_show_objects_statement(self, node)
    }
    fn fold_show_statement(&mut self, node: ShowStatement<T>) -> ShowStatement<T2> {
        fold_show_statement(self, node)
    }
    fn fold_show_statement_filter(&mut self, node: ShowStatementFilter<T>) -> ShowStatementFilter<T2> {
        fold_show_statement_filter(self, node)
    }
    fn fold_show_variable_statement(&mut self, node: ShowVariableStatement) -> ShowVariableStatement {
        fold_show_variable_statement(self, node)
    }
    fn fold_sink_envelope(&mut self, node: SinkEnvelope) -> SinkEnvelope {
        fold_sink_envelope(self, node)
    }
    fn fold_source_envelope(&mut self, node: SourceEnvelope) -> SourceEnvelope {
        fold_source_envelope(self, node)
    }
    fn fold_source_error_policy(&mut self, node: SourceErrorPolicy) -> SourceErrorPolicy {
        fold_source_error_policy(self, node)
    }
    fn fold_source_include_metadata(&mut self, node: SourceIncludeMetadata) -> SourceIncludeMetadata {
        fold_source_include_metadata(self, node)
    }
    fn fold_start_transaction_statement(&mut self, node: StartTransactionStatement) -> StartTransactionStatement {
        fold_start_transaction_statement(self, node)
    }
    fn fold_statement(&mut self, node: Statement<T>) -> Statement<T2> {
        fold_statement(self, node)
    }
    fn fold_subscribe_option(&mut self, node: SubscribeOption<T>) -> SubscribeOption<T2> {
        fold_subscribe_option(self, node)
    }
    fn fold_subscribe_option_name(&mut self, node: SubscribeOptionName) -> SubscribeOptionName {
        fold_subscribe_option_name(self, node)
    }
    fn fold_subscribe_output(&mut self, node: SubscribeOutput<T>) -> SubscribeOutput<T2> {
        fold_subscribe_output(self, node)
    }
    fn fold_subscribe_relation(&mut self, node: SubscribeRelation<T>) -> SubscribeRelation<T2> {
        fold_subscribe_relation(self, node)
    }
    fn fold_subscribe_statement(&mut self, node: SubscribeStatement<T>) -> SubscribeStatement<T2> {
        fold_subscribe_statement(self, node)
    }
    fn fold_subscript_position(&mut self, node: SubscriptPosition<T>) -> SubscriptPosition<T2> {
        fold_subscript_position(self, node)
    }
    fn fold_system_object_type(&mut self, node: SystemObjectType) -> SystemObjectType {
        fold_system_object_type(self, node)
    }
    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_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;
    fn fold_table_alias(&mut self, node: TableAlias) -> TableAlias {
        fold_table_alias(self, node)
    }
    fn fold_table_constraint(&mut self, node: TableConstraint<T>) -> TableConstraint<T2> {
        fold_table_constraint(self, node)
    }
    fn fold_table_factor(&mut self, node: TableFactor<T>) -> TableFactor<T2> {
        fold_table_factor(self, node)
    }
    fn fold_table_option(&mut self, node: TableOption<T>) -> TableOption<T2> {
        fold_table_option(self, node)
    }
    fn fold_table_option_name(&mut self, node: TableOptionName) -> TableOptionName {
        fold_table_option_name(self, node)
    }
    fn fold_table_with_joins(&mut self, node: TableWithJoins<T>) -> TableWithJoins<T2> {
        fold_table_with_joins(self, node)
    }
    fn fold_target_role_specification(&mut self, node: TargetRoleSpecification<T>) -> TargetRoleSpecification<T2> {
        fold_target_role_specification(self, node)
    }
    fn fold_transaction_access_mode(&mut self, node: TransactionAccessMode) -> TransactionAccessMode {
        fold_transaction_access_mode(self, node)
    }
    fn fold_transaction_isolation_level(&mut self, node: TransactionIsolationLevel) -> TransactionIsolationLevel {
        fold_transaction_isolation_level(self, node)
    }
    fn fold_transaction_mode(&mut self, node: TransactionMode) -> TransactionMode {
        fold_transaction_mode(self, node)
    }
    fn fold_unresolved_database_name(&mut self, node: UnresolvedDatabaseName) -> UnresolvedDatabaseName {
        fold_unresolved_database_name(self, node)
    }
    fn fold_unresolved_item_name(&mut self, node: UnresolvedItemName) -> UnresolvedItemName {
        fold_unresolved_item_name(self, node)
    }
    fn fold_unresolved_object_name(&mut self, node: UnresolvedObjectName) -> UnresolvedObjectName {
        fold_unresolved_object_name(self, node)
    }
    fn fold_unresolved_schema_name(&mut self, node: UnresolvedSchemaName) -> UnresolvedSchemaName {
        fold_unresolved_schema_name(self, node)
    }
    fn fold_update_statement(&mut self, node: UpdateStatement<T>) -> UpdateStatement<T2> {
        fold_update_statement(self, node)
    }
    fn fold_validate_connection_statement(&mut self, node: ValidateConnectionStatement<T>) -> ValidateConnectionStatement<T2> {
        fold_validate_connection_statement(self, node)
    }
    fn fold_value(&mut self, node: Value) -> Value {
        fold_value(self, node)
    }
    fn fold_value_error(&mut self, node: ValueError) -> ValueError {
        fold_value_error(self, node)
    }
    fn fold_values(&mut self, node: Values<T>) -> Values<T2> {
        fold_values(self, node)
    }
    fn fold_view_definition(&mut self, node: ViewDefinition<T>) -> ViewDefinition<T2> {
        fold_view_definition(self, node)
    }
    fn fold_window_frame(&mut self, node: WindowFrame) -> WindowFrame {
        fold_window_frame(self, node)
    }
    fn fold_window_frame_bound(&mut self, node: WindowFrameBound) -> WindowFrameBound {
        fold_window_frame_bound(self, node)
    }
    fn fold_window_frame_units(&mut self, node: WindowFrameUnits) -> WindowFrameUnits {
        fold_window_frame_units(self, node)
    }
    fn fold_window_spec(&mut self, node: WindowSpec<T>) -> WindowSpec<T2> {
        fold_window_spec(self, node)
    }
    fn fold_with_option_value(&mut self, node: WithOptionValue<T>) -> WithOptionValue<T2> {
        fold_with_option_value(self, node)
    }
}
pub trait FoldNode<T: AstInfo, T2: AstInfo, > {
    type Folded;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded;
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AbbreviatedGrantOrRevokeStatement<T> {
    type Folded = AbbreviatedGrantOrRevokeStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_abbreviated_grant_or_revoke_statement(self)
    }
}
pub fn fold_abbreviated_grant_or_revoke_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AbbreviatedGrantOrRevokeStatement<T>) -> AbbreviatedGrantOrRevokeStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AbbreviatedGrantOrRevokeStatement::Grant {
            0: binding0,
        } => {
            AbbreviatedGrantOrRevokeStatement::Grant {
                0: folder.fold_abbreviated_grant_statement(binding0),
            }
        }
        AbbreviatedGrantOrRevokeStatement::Revoke {
            0: binding0,
        } => {
            AbbreviatedGrantOrRevokeStatement::Revoke {
                0: folder.fold_abbreviated_revoke_statement(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AbbreviatedGrantStatement<T> {
    type Folded = AbbreviatedGrantStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_abbreviated_grant_statement(self)
    }
}
pub fn fold_abbreviated_grant_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AbbreviatedGrantStatement<T>) -> AbbreviatedGrantStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AbbreviatedGrantStatement {
        privileges: folder.fold_privilege_specification(node.privileges),
        object_type: folder.fold_object_type(node.object_type),
        grantees: node.grantees.into_iter().map(|v| folder.fold_role_name(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AbbreviatedRevokeStatement<T> {
    type Folded = AbbreviatedRevokeStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_abbreviated_revoke_statement(self)
    }
}
pub fn fold_abbreviated_revoke_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AbbreviatedRevokeStatement<T>) -> AbbreviatedRevokeStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AbbreviatedRevokeStatement {
        privileges: folder.fold_privilege_specification(node.privileges),
        object_type: folder.fold_object_type(node.object_type),
        revokees: node.revokees.into_iter().map(|v| folder.fold_role_name(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterClusterAction<T> {
    type Folded = AlterClusterAction<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_cluster_action(self)
    }
}
pub fn fold_alter_cluster_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterClusterAction<T>) -> AlterClusterAction<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterClusterAction::SetOptions {
            options: binding0,
            with_options: binding1,
        } => {
            AlterClusterAction::SetOptions {
                options: binding0.into_iter().map(|v| folder.fold_cluster_option(v)).collect(),
                with_options: binding1.into_iter().map(|v| folder.fold_cluster_alter_option(v)).collect(),
            }
        }
        AlterClusterAction::ResetOptions {
            0: binding0,
        } => {
            AlterClusterAction::ResetOptions {
                0: binding0.into_iter().map(|v| folder.fold_cluster_option_name(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterClusterStatement<T> {
    type Folded = AlterClusterStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_cluster_statement(self)
    }
}
pub fn fold_alter_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterClusterStatement<T>) -> AlterClusterStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterClusterStatement {
        if_exists: node.if_exists,
        name: folder.fold_ident(node.name),
        action: folder.fold_alter_cluster_action(node.action),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionAction<T> {
    type Folded = AlterConnectionAction<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_connection_action(self)
    }
}
pub fn fold_alter_connection_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionAction<T>) -> AlterConnectionAction<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterConnectionAction::RotateKeys {
        } => {
            AlterConnectionAction::RotateKeys {
            }
        }
        AlterConnectionAction::SetOption {
            0: binding0,
        } => {
            AlterConnectionAction::SetOption {
                0: folder.fold_connection_option(binding0),
            }
        }
        AlterConnectionAction::DropOption {
            0: binding0,
        } => {
            AlterConnectionAction::DropOption {
                0: folder.fold_connection_option_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionOption<T> {
    type Folded = AlterConnectionOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_connection_option(self)
    }
}
pub fn fold_alter_connection_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionOption<T>) -> AlterConnectionOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterConnectionOption {
        name: folder.fold_alter_connection_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionOptionName {
    type Folded = AlterConnectionOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_connection_option_name(self)
    }
}
pub fn fold_alter_connection_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionOptionName) -> AlterConnectionOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterConnectionOptionName::Validate {
        } => {
            AlterConnectionOptionName::Validate {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionStatement<T> {
    type Folded = AlterConnectionStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_connection_statement(self)
    }
}
pub fn fold_alter_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionStatement<T>) -> AlterConnectionStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterConnectionStatement {
        name: folder.fold_unresolved_item_name(node.name),
        if_exists: node.if_exists,
        actions: node.actions.into_iter().map(|v| folder.fold_alter_connection_action(v)).collect(),
        with_options: node.with_options.into_iter().map(|v| folder.fold_alter_connection_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterDefaultPrivilegesStatement<T> {
    type Folded = AlterDefaultPrivilegesStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_default_privileges_statement(self)
    }
}
pub fn fold_alter_default_privileges_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterDefaultPrivilegesStatement<T>) -> AlterDefaultPrivilegesStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterDefaultPrivilegesStatement {
        target_roles: folder.fold_target_role_specification(node.target_roles),
        target_objects: folder.fold_grant_target_all_specification(node.target_objects),
        grant_or_revoke: folder.fold_abbreviated_grant_or_revoke_statement(node.grant_or_revoke),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterIndexAction<T> {
    type Folded = AlterIndexAction<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_index_action(self)
    }
}
pub fn fold_alter_index_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterIndexAction<T>) -> AlterIndexAction<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterIndexAction::SetOptions {
            0: binding0,
        } => {
            AlterIndexAction::SetOptions {
                0: binding0.into_iter().map(|v| folder.fold_index_option(v)).collect(),
            }
        }
        AlterIndexAction::ResetOptions {
            0: binding0,
        } => {
            AlterIndexAction::ResetOptions {
                0: binding0.into_iter().map(|v| folder.fold_index_option_name(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterIndexStatement<T> {
    type Folded = AlterIndexStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_index_statement(self)
    }
}
pub fn fold_alter_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterIndexStatement<T>) -> AlterIndexStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterIndexStatement {
        index_name: folder.fold_unresolved_item_name(node.index_name),
        if_exists: node.if_exists,
        action: folder.fold_alter_index_action(node.action),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterObjectRenameStatement {
    type Folded = AlterObjectRenameStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_object_rename_statement(self)
    }
}
pub fn fold_alter_object_rename_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterObjectRenameStatement) -> AlterObjectRenameStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterObjectRenameStatement {
        object_type: folder.fold_object_type(node.object_type),
        if_exists: node.if_exists,
        name: folder.fold_unresolved_object_name(node.name),
        to_item_name: folder.fold_ident(node.to_item_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterObjectSwapStatement {
    type Folded = AlterObjectSwapStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_object_swap_statement(self)
    }
}
pub fn fold_alter_object_swap_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterObjectSwapStatement) -> AlterObjectSwapStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterObjectSwapStatement {
        object_type: folder.fold_object_type(node.object_type),
        name_a: folder.fold_unresolved_object_name(node.name_a),
        name_b: folder.fold_ident(node.name_b),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterOwnerStatement<T> {
    type Folded = AlterOwnerStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_owner_statement(self)
    }
}
pub fn fold_alter_owner_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterOwnerStatement<T>) -> AlterOwnerStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterOwnerStatement {
        object_type: folder.fold_object_type(node.object_type),
        if_exists: node.if_exists,
        name: folder.fold_unresolved_object_name(node.name),
        new_owner: folder.fold_role_name(node.new_owner),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterRetainHistoryStatement<T> {
    type Folded = AlterRetainHistoryStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_retain_history_statement(self)
    }
}
pub fn fold_alter_retain_history_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterRetainHistoryStatement<T>) -> AlterRetainHistoryStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterRetainHistoryStatement {
        object_type: folder.fold_object_type(node.object_type),
        if_exists: node.if_exists,
        name: folder.fold_unresolved_object_name(node.name),
        history: node.history.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterRoleOption {
    type Folded = AlterRoleOption;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_role_option(self)
    }
}
pub fn fold_alter_role_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterRoleOption) -> AlterRoleOption
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterRoleOption::Attributes {
            0: binding0,
        } => {
            AlterRoleOption::Attributes {
                0: binding0.into_iter().map(|v| folder.fold_role_attribute(v)).collect(),
            }
        }
        AlterRoleOption::Variable {
            0: binding0,
        } => {
            AlterRoleOption::Variable {
                0: folder.fold_set_role_var(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterRoleStatement<T> {
    type Folded = AlterRoleStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_role_statement(self)
    }
}
pub fn fold_alter_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterRoleStatement<T>) -> AlterRoleStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterRoleStatement {
        name: folder.fold_role_name(node.name),
        option: folder.fold_alter_role_option(node.option),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSecretStatement<T> {
    type Folded = AlterSecretStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_secret_statement(self)
    }
}
pub fn fold_alter_secret_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSecretStatement<T>) -> AlterSecretStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSecretStatement {
        name: folder.fold_unresolved_item_name(node.name),
        if_exists: node.if_exists,
        value: folder.fold_expr(node.value),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSetClusterStatement<T> {
    type Folded = AlterSetClusterStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_set_cluster_statement(self)
    }
}
pub fn fold_alter_set_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSetClusterStatement<T>) -> AlterSetClusterStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSetClusterStatement {
        if_exists: node.if_exists,
        name: folder.fold_unresolved_item_name(node.name),
        object_type: folder.fold_object_type(node.object_type),
        set_cluster: folder.fold_cluster_name(node.set_cluster),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSinkAction<T> {
    type Folded = AlterSinkAction<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_sink_action(self)
    }
}
pub fn fold_alter_sink_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSinkAction<T>) -> AlterSinkAction<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterSinkAction::SetOptions {
            0: binding0,
        } => {
            AlterSinkAction::SetOptions {
                0: binding0.into_iter().map(|v| folder.fold_create_sink_option(v)).collect(),
            }
        }
        AlterSinkAction::ResetOptions {
            0: binding0,
        } => {
            AlterSinkAction::ResetOptions {
                0: binding0.into_iter().map(|v| folder.fold_create_sink_option_name(v)).collect(),
            }
        }
        AlterSinkAction::ChangeRelation {
            0: binding0,
        } => {
            AlterSinkAction::ChangeRelation {
                0: folder.fold_item_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSinkStatement<T> {
    type Folded = AlterSinkStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_sink_statement(self)
    }
}
pub fn fold_alter_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSinkStatement<T>) -> AlterSinkStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSinkStatement {
        sink_name: folder.fold_unresolved_item_name(node.sink_name),
        if_exists: node.if_exists,
        action: folder.fold_alter_sink_action(node.action),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceAction<T> {
    type Folded = AlterSourceAction<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_source_action(self)
    }
}
pub fn fold_alter_source_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceAction<T>) -> AlterSourceAction<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterSourceAction::SetOptions {
            0: binding0,
        } => {
            AlterSourceAction::SetOptions {
                0: binding0.into_iter().map(|v| folder.fold_create_source_option(v)).collect(),
            }
        }
        AlterSourceAction::ResetOptions {
            0: binding0,
        } => {
            AlterSourceAction::ResetOptions {
                0: binding0.into_iter().map(|v| folder.fold_create_source_option_name(v)).collect(),
            }
        }
        AlterSourceAction::AddSubsources {
            external_references: binding0,
            options: binding1,
        } => {
            AlterSourceAction::AddSubsources {
                external_references: binding0.into_iter().map(|v| folder.fold_external_reference_export(v)).collect(),
                options: binding1.into_iter().map(|v| folder.fold_alter_source_add_subsource_option(v)).collect(),
            }
        }
        AlterSourceAction::DropSubsources {
            if_exists: binding0,
            cascade: binding1,
            names: binding2,
        } => {
            AlterSourceAction::DropSubsources {
                if_exists: binding0,
                cascade: binding1,
                names: binding2.into_iter().map(|v| folder.fold_unresolved_item_name(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceAddSubsourceOption<T> {
    type Folded = AlterSourceAddSubsourceOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_source_add_subsource_option(self)
    }
}
pub fn fold_alter_source_add_subsource_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceAddSubsourceOption<T>) -> AlterSourceAddSubsourceOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSourceAddSubsourceOption {
        name: folder.fold_alter_source_add_subsource_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceAddSubsourceOptionName {
    type Folded = AlterSourceAddSubsourceOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_source_add_subsource_option_name(self)
    }
}
pub fn fold_alter_source_add_subsource_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceAddSubsourceOptionName) -> AlterSourceAddSubsourceOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AlterSourceAddSubsourceOptionName::TextColumns {
        } => {
            AlterSourceAddSubsourceOptionName::TextColumns {
            }
        }
        AlterSourceAddSubsourceOptionName::IgnoreColumns {
        } => {
            AlterSourceAddSubsourceOptionName::IgnoreColumns {
            }
        }
        AlterSourceAddSubsourceOptionName::Details {
        } => {
            AlterSourceAddSubsourceOptionName::Details {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceStatement<T> {
    type Folded = AlterSourceStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_source_statement(self)
    }
}
pub fn fold_alter_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceStatement<T>) -> AlterSourceStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSourceStatement {
        source_name: folder.fold_unresolved_item_name(node.source_name),
        if_exists: node.if_exists,
        action: folder.fold_alter_source_action(node.action),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSystemResetAllStatement {
    type Folded = AlterSystemResetAllStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_system_reset_all_statement(self)
    }
}
pub fn fold_alter_system_reset_all_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSystemResetAllStatement) -> AlterSystemResetAllStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSystemResetAllStatement {
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSystemResetStatement {
    type Folded = AlterSystemResetStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_system_reset_statement(self)
    }
}
pub fn fold_alter_system_reset_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSystemResetStatement) -> AlterSystemResetStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSystemResetStatement {
        name: folder.fold_ident(node.name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSystemSetStatement {
    type Folded = AlterSystemSetStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_system_set_statement(self)
    }
}
pub fn fold_alter_system_set_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSystemSetStatement) -> AlterSystemSetStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterSystemSetStatement {
        name: folder.fold_ident(node.name),
        to: folder.fold_set_variable_to(node.to),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterTableAddColumnStatement<T> {
    type Folded = AlterTableAddColumnStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_alter_table_add_column_statement(self)
    }
}
pub fn fold_alter_table_add_column_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterTableAddColumnStatement<T>) -> AlterTableAddColumnStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AlterTableAddColumnStatement {
        if_exists: node.if_exists,
        name: folder.fold_unresolved_item_name(node.name),
        if_col_not_exist: node.if_col_not_exist,
        column_name: folder.fold_ident(node.column_name),
        data_type: folder.fold_data_type(node.data_type),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AsOf<T> {
    type Folded = AsOf<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_as_of(self)
    }
}
pub fn fold_as_of<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AsOf<T>) -> AsOf<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AsOf::At {
            0: binding0,
        } => {
            AsOf::At {
                0: folder.fold_expr(binding0),
            }
        }
        AsOf::AtLeast {
            0: binding0,
        } => {
            AsOf::AtLeast {
                0: folder.fold_expr(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Assignment<T> {
    type Folded = Assignment<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_assignment(self)
    }
}
pub fn fold_assignment<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Assignment<T>) -> Assignment<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Assignment {
        id: folder.fold_ident(node.id),
        value: folder.fold_expr(node.value),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroDocOn<T> {
    type Folded = AvroDocOn<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_avro_doc_on(self)
    }
}
pub fn fold_avro_doc_on<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroDocOn<T>) -> AvroDocOn<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AvroDocOn {
        identifier: folder.fold_doc_on_identifier(node.identifier),
        for_schema: folder.fold_doc_on_schema(node.for_schema),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroSchema<T> {
    type Folded = AvroSchema<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_avro_schema(self)
    }
}
pub fn fold_avro_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchema<T>) -> AvroSchema<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AvroSchema::Csr {
            csr_connection: binding0,
        } => {
            AvroSchema::Csr {
                csr_connection: folder.fold_csr_connection_avro(binding0),
            }
        }
        AvroSchema::InlineSchema {
            schema: binding0,
            with_options: binding1,
        } => {
            AvroSchema::InlineSchema {
                schema: folder.fold_schema(binding0),
                with_options: binding1.into_iter().map(|v| folder.fold_avro_schema_option(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroSchemaOption<T> {
    type Folded = AvroSchemaOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_avro_schema_option(self)
    }
}
pub fn fold_avro_schema_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchemaOption<T>) -> AvroSchemaOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    AvroSchemaOption {
        name: folder.fold_avro_schema_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroSchemaOptionName {
    type Folded = AvroSchemaOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_avro_schema_option_name(self)
    }
}
pub fn fold_avro_schema_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchemaOptionName) -> AvroSchemaOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        AvroSchemaOptionName::ConfluentWireFormat {
        } => {
            AvroSchemaOptionName::ConfluentWireFormat {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CatalogName {
    type Folded = CatalogName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_catalog_name(self)
    }
}
pub fn fold_catalog_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CatalogName) -> CatalogName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CatalogName::ItemName {
            0: binding0,
        } => {
            CatalogName::ItemName {
                0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        CatalogName::FuncName {
            0: binding0,
        } => {
            CatalogName::FuncName {
                0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CloseStatement {
    type Folded = CloseStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_close_statement(self)
    }
}
pub fn fold_close_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CloseStatement) -> CloseStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    CloseStatement {
        name: folder.fold_ident(node.name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterOption<T> {
    type Folded = ClusterAlterOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_alter_option(self)
    }
}
pub fn fold_cluster_alter_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterOption<T>) -> ClusterAlterOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ClusterAlterOption {
        name: folder.fold_cluster_alter_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterOptionName {
    type Folded = ClusterAlterOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_alter_option_name(self)
    }
}
pub fn fold_cluster_alter_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterOptionName) -> ClusterAlterOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ClusterAlterOptionName::Wait {
        } => {
            ClusterAlterOptionName::Wait {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterOptionValue {
    type Folded = ClusterAlterOptionValue;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_alter_option_value(self)
    }
}
pub fn fold_cluster_alter_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterOptionValue) -> ClusterAlterOptionValue
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ClusterAlterOptionValue::For {
            0: binding0,
        } => {
            ClusterAlterOptionValue::For {
                0: folder.fold_value(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterFeature<T> {
    type Folded = ClusterFeature<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_feature(self)
    }
}
pub fn fold_cluster_feature<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterFeature<T>) -> ClusterFeature<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ClusterFeature {
        name: folder.fold_cluster_feature_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterFeatureName {
    type Folded = ClusterFeatureName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_feature_name(self)
    }
}
pub fn fold_cluster_feature_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterFeatureName) -> ClusterFeatureName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ClusterFeatureName::ReoptimizeImportedViews {
        } => {
            ClusterFeatureName::ReoptimizeImportedViews {
            }
        }
        ClusterFeatureName::EnableNewOuterJoinLowering {
        } => {
            ClusterFeatureName::EnableNewOuterJoinLowering {
            }
        }
        ClusterFeatureName::EnableEagerDeltaJoins {
        } => {
            ClusterFeatureName::EnableEagerDeltaJoins {
            }
        }
        ClusterFeatureName::EnableVariadicLeftJoinLowering {
        } => {
            ClusterFeatureName::EnableVariadicLeftJoinLowering {
            }
        }
        ClusterFeatureName::EnableLetrecFixpointAnalysis {
        } => {
            ClusterFeatureName::EnableLetrecFixpointAnalysis {
            }
        }
        ClusterFeatureName::EnableOuterJoinNullFilter {
        } => {
            ClusterFeatureName::EnableOuterJoinNullFilter {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterOption<T> {
    type Folded = ClusterOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_option(self)
    }
}
pub fn fold_cluster_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterOption<T>) -> ClusterOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ClusterOption {
        name: folder.fold_cluster_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterOptionName {
    type Folded = ClusterOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_option_name(self)
    }
}
pub fn fold_cluster_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterOptionName) -> ClusterOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ClusterOptionName::AvailabilityZones {
        } => {
            ClusterOptionName::AvailabilityZones {
            }
        }
        ClusterOptionName::Disk {
        } => {
            ClusterOptionName::Disk {
            }
        }
        ClusterOptionName::IntrospectionInterval {
        } => {
            ClusterOptionName::IntrospectionInterval {
            }
        }
        ClusterOptionName::IntrospectionDebugging {
        } => {
            ClusterOptionName::IntrospectionDebugging {
            }
        }
        ClusterOptionName::Managed {
        } => {
            ClusterOptionName::Managed {
            }
        }
        ClusterOptionName::Replicas {
        } => {
            ClusterOptionName::Replicas {
            }
        }
        ClusterOptionName::ReplicationFactor {
        } => {
            ClusterOptionName::ReplicationFactor {
            }
        }
        ClusterOptionName::Size {
        } => {
            ClusterOptionName::Size {
            }
        }
        ClusterOptionName::Schedule {
        } => {
            ClusterOptionName::Schedule {
            }
        }
        ClusterOptionName::WorkloadClass {
        } => {
            ClusterOptionName::WorkloadClass {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterScheduleOptionValue {
    type Folded = ClusterScheduleOptionValue;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cluster_schedule_option_value(self)
    }
}
pub fn fold_cluster_schedule_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterScheduleOptionValue) -> ClusterScheduleOptionValue
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ClusterScheduleOptionValue::Manual {
        } => {
            ClusterScheduleOptionValue::Manual {
            }
        }
        ClusterScheduleOptionValue::Refresh {
            hydration_time_estimate: binding0,
        } => {
            ClusterScheduleOptionValue::Refresh {
                hydration_time_estimate: binding0.map(|v| folder.fold_interval_value(v)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnDef<T> {
    type Folded = ColumnDef<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_column_def(self)
    }
}
pub fn fold_column_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnDef<T>) -> ColumnDef<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ColumnDef {
        name: folder.fold_ident(node.name),
        data_type: folder.fold_data_type(node.data_type),
        collation: node.collation.map(|v| folder.fold_unresolved_item_name(v)),
        options: node.options.into_iter().map(|v| folder.fold_column_option_def(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnName<T> {
    type Folded = ColumnName<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_column_name(self)
    }
}
pub fn fold_column_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnName<T>) -> ColumnName<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ColumnName {
        relation: folder.fold_item_name(node.relation),
        column: folder.fold_column_reference(node.column),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnOption<T> {
    type Folded = ColumnOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_column_option(self)
    }
}
pub fn fold_column_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnOption<T>) -> ColumnOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ColumnOption::Null {
        } => {
            ColumnOption::Null {
            }
        }
        ColumnOption::NotNull {
        } => {
            ColumnOption::NotNull {
            }
        }
        ColumnOption::Default {
            0: binding0,
        } => {
            ColumnOption::Default {
                0: folder.fold_expr(binding0),
            }
        }
        ColumnOption::Unique {
            is_primary: binding0,
        } => {
            ColumnOption::Unique {
                is_primary: binding0,
            }
        }
        ColumnOption::ForeignKey {
            foreign_table: binding0,
            referred_columns: binding1,
        } => {
            ColumnOption::ForeignKey {
                foreign_table: folder.fold_unresolved_item_name(binding0),
                referred_columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        ColumnOption::Check {
            0: binding0,
        } => {
            ColumnOption::Check {
                0: folder.fold_expr(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnOptionDef<T> {
    type Folded = ColumnOptionDef<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_column_option_def(self)
    }
}
pub fn fold_column_option_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnOptionDef<T>) -> ColumnOptionDef<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ColumnOptionDef {
        name: node.name.map(|v| folder.fold_ident(v)),
        option: folder.fold_column_option(node.option),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CommentObjectType<T> {
    type Folded = CommentObjectType<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_comment_object_type(self)
    }
}
pub fn fold_comment_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommentObjectType<T>) -> CommentObjectType<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CommentObjectType::Table {
            name: binding0,
        } => {
            CommentObjectType::Table {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::View {
            name: binding0,
        } => {
            CommentObjectType::View {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Column {
            name: binding0,
        } => {
            CommentObjectType::Column {
                name: folder.fold_column_name(binding0),
            }
        }
        CommentObjectType::MaterializedView {
            name: binding0,
        } => {
            CommentObjectType::MaterializedView {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Source {
            name: binding0,
        } => {
            CommentObjectType::Source {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Sink {
            name: binding0,
        } => {
            CommentObjectType::Sink {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Index {
            name: binding0,
        } => {
            CommentObjectType::Index {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Func {
            name: binding0,
        } => {
            CommentObjectType::Func {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Connection {
            name: binding0,
        } => {
            CommentObjectType::Connection {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Type {
            ty: binding0,
        } => {
            CommentObjectType::Type {
                ty: folder.fold_data_type(binding0),
            }
        }
        CommentObjectType::Secret {
            name: binding0,
        } => {
            CommentObjectType::Secret {
                name: folder.fold_item_name(binding0),
            }
        }
        CommentObjectType::Role {
            name: binding0,
        } => {
            CommentObjectType::Role {
                name: folder.fold_role_name(binding0),
            }
        }
        CommentObjectType::Database {
            name: binding0,
        } => {
            CommentObjectType::Database {
                name: folder.fold_database_name(binding0),
            }
        }
        CommentObjectType::Schema {
            name: binding0,
        } => {
            CommentObjectType::Schema {
                name: folder.fold_schema_name(binding0),
            }
        }
        CommentObjectType::Cluster {
            name: binding0,
        } => {
            CommentObjectType::Cluster {
                name: folder.fold_cluster_name(binding0),
            }
        }
        CommentObjectType::ClusterReplica {
            name: binding0,
        } => {
            CommentObjectType::ClusterReplica {
                name: folder.fold_qualified_replica(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CommentStatement<T> {
    type Folded = CommentStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_comment_statement(self)
    }
}
pub fn fold_comment_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommentStatement<T>) -> CommentStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CommentStatement {
        object: folder.fold_comment_object_type(node.object),
        comment: node.comment.map(|v| v),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CommitStatement {
    type Folded = CommitStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_commit_statement(self)
    }
}
pub fn fold_commit_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommitStatement) -> CommitStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    CommitStatement {
        chain: node.chain,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ConnectionDefaultAwsPrivatelink<T> {
    type Folded = ConnectionDefaultAwsPrivatelink<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_connection_default_aws_privatelink(self)
    }
}
pub fn fold_connection_default_aws_privatelink<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ConnectionDefaultAwsPrivatelink<T>) -> ConnectionDefaultAwsPrivatelink<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ConnectionDefaultAwsPrivatelink {
        connection: folder.fold_item_name(node.connection),
        port: node.port.map(|v| v),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ConnectionOption<T> {
    type Folded = ConnectionOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_connection_option(self)
    }
}
pub fn fold_connection_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ConnectionOption<T>) -> ConnectionOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ConnectionOption {
        name: folder.fold_connection_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ConnectionOptionName {
    type Folded = ConnectionOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_connection_option_name(self)
    }
}
pub fn fold_connection_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ConnectionOptionName) -> ConnectionOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ConnectionOptionName::AccessKeyId {
        } => {
            ConnectionOptionName::AccessKeyId {
            }
        }
        ConnectionOptionName::AssumeRoleArn {
        } => {
            ConnectionOptionName::AssumeRoleArn {
            }
        }
        ConnectionOptionName::AssumeRoleSessionName {
        } => {
            ConnectionOptionName::AssumeRoleSessionName {
            }
        }
        ConnectionOptionName::AvailabilityZones {
        } => {
            ConnectionOptionName::AvailabilityZones {
            }
        }
        ConnectionOptionName::AwsConnection {
        } => {
            ConnectionOptionName::AwsConnection {
            }
        }
        ConnectionOptionName::AwsPrivatelink {
        } => {
            ConnectionOptionName::AwsPrivatelink {
            }
        }
        ConnectionOptionName::Broker {
        } => {
            ConnectionOptionName::Broker {
            }
        }
        ConnectionOptionName::Brokers {
        } => {
            ConnectionOptionName::Brokers {
            }
        }
        ConnectionOptionName::Database {
        } => {
            ConnectionOptionName::Database {
            }
        }
        ConnectionOptionName::Endpoint {
        } => {
            ConnectionOptionName::Endpoint {
            }
        }
        ConnectionOptionName::Host {
        } => {
            ConnectionOptionName::Host {
            }
        }
        ConnectionOptionName::Password {
        } => {
            ConnectionOptionName::Password {
            }
        }
        ConnectionOptionName::Port {
        } => {
            ConnectionOptionName::Port {
            }
        }
        ConnectionOptionName::ProgressTopic {
        } => {
            ConnectionOptionName::ProgressTopic {
            }
        }
        ConnectionOptionName::ProgressTopicReplicationFactor {
        } => {
            ConnectionOptionName::ProgressTopicReplicationFactor {
            }
        }
        ConnectionOptionName::Region {
        } => {
            ConnectionOptionName::Region {
            }
        }
        ConnectionOptionName::SaslMechanisms {
        } => {
            ConnectionOptionName::SaslMechanisms {
            }
        }
        ConnectionOptionName::SaslPassword {
        } => {
            ConnectionOptionName::SaslPassword {
            }
        }
        ConnectionOptionName::SaslUsername {
        } => {
            ConnectionOptionName::SaslUsername {
            }
        }
        ConnectionOptionName::SecretAccessKey {
        } => {
            ConnectionOptionName::SecretAccessKey {
            }
        }
        ConnectionOptionName::SecurityProtocol {
        } => {
            ConnectionOptionName::SecurityProtocol {
            }
        }
        ConnectionOptionName::ServiceName {
        } => {
            ConnectionOptionName::ServiceName {
            }
        }
        ConnectionOptionName::SshTunnel {
        } => {
            ConnectionOptionName::SshTunnel {
            }
        }
        ConnectionOptionName::SslCertificate {
        } => {
            ConnectionOptionName::SslCertificate {
            }
        }
        ConnectionOptionName::SslCertificateAuthority {
        } => {
            ConnectionOptionName::SslCertificateAuthority {
            }
        }
        ConnectionOptionName::SslKey {
        } => {
            ConnectionOptionName::SslKey {
            }
        }
        ConnectionOptionName::SslMode {
        } => {
            ConnectionOptionName::SslMode {
            }
        }
        ConnectionOptionName::SessionToken {
        } => {
            ConnectionOptionName::SessionToken {
            }
        }
        ConnectionOptionName::Url {
        } => {
            ConnectionOptionName::Url {
            }
        }
        ConnectionOptionName::User {
        } => {
            ConnectionOptionName::User {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyDirection {
    type Folded = CopyDirection;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_copy_direction(self)
    }
}
pub fn fold_copy_direction<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyDirection) -> CopyDirection
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CopyDirection::To {
        } => {
            CopyDirection::To {
            }
        }
        CopyDirection::From {
        } => {
            CopyDirection::From {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyOption<T> {
    type Folded = CopyOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_copy_option(self)
    }
}
pub fn fold_copy_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyOption<T>) -> CopyOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CopyOption {
        name: folder.fold_copy_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyOptionName {
    type Folded = CopyOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_copy_option_name(self)
    }
}
pub fn fold_copy_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyOptionName) -> CopyOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CopyOptionName::Format {
        } => {
            CopyOptionName::Format {
            }
        }
        CopyOptionName::Delimiter {
        } => {
            CopyOptionName::Delimiter {
            }
        }
        CopyOptionName::Null {
        } => {
            CopyOptionName::Null {
            }
        }
        CopyOptionName::Escape {
        } => {
            CopyOptionName::Escape {
            }
        }
        CopyOptionName::Quote {
        } => {
            CopyOptionName::Quote {
            }
        }
        CopyOptionName::Header {
        } => {
            CopyOptionName::Header {
            }
        }
        CopyOptionName::AwsConnection {
        } => {
            CopyOptionName::AwsConnection {
            }
        }
        CopyOptionName::MaxFileSize {
        } => {
            CopyOptionName::MaxFileSize {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyRelation<T> {
    type Folded = CopyRelation<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_copy_relation(self)
    }
}
pub fn fold_copy_relation<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyRelation<T>) -> CopyRelation<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CopyRelation::Named {
            name: binding0,
            columns: binding1,
        } => {
            CopyRelation::Named {
                name: folder.fold_item_name(binding0),
                columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        CopyRelation::Select {
            0: binding0,
        } => {
            CopyRelation::Select {
                0: folder.fold_select_statement(binding0),
            }
        }
        CopyRelation::Subscribe {
            0: binding0,
        } => {
            CopyRelation::Subscribe {
                0: folder.fold_subscribe_statement(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyStatement<T> {
    type Folded = CopyStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_copy_statement(self)
    }
}
pub fn fold_copy_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyStatement<T>) -> CopyStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CopyStatement {
        relation: folder.fold_copy_relation(node.relation),
        direction: folder.fold_copy_direction(node.direction),
        target: folder.fold_copy_target(node.target),
        options: node.options.into_iter().map(|v| folder.fold_copy_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyTarget<T> {
    type Folded = CopyTarget<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_copy_target(self)
    }
}
pub fn fold_copy_target<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyTarget<T>) -> CopyTarget<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CopyTarget::Stdin {
        } => {
            CopyTarget::Stdin {
            }
        }
        CopyTarget::Stdout {
        } => {
            CopyTarget::Stdout {
            }
        }
        CopyTarget::Expr {
            0: binding0,
        } => {
            CopyTarget::Expr {
                0: folder.fold_expr(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateClusterReplicaStatement<T> {
    type Folded = CreateClusterReplicaStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_cluster_replica_statement(self)
    }
}
pub fn fold_create_cluster_replica_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateClusterReplicaStatement<T>) -> CreateClusterReplicaStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateClusterReplicaStatement {
        of_cluster: folder.fold_ident(node.of_cluster),
        definition: folder.fold_replica_definition(node.definition),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateClusterStatement<T> {
    type Folded = CreateClusterStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_cluster_statement(self)
    }
}
pub fn fold_create_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateClusterStatement<T>) -> CreateClusterStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateClusterStatement {
        name: folder.fold_ident(node.name),
        options: node.options.into_iter().map(|v| folder.fold_cluster_option(v)).collect(),
        features: node.features.into_iter().map(|v| folder.fold_cluster_feature(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionOption<T> {
    type Folded = CreateConnectionOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_connection_option(self)
    }
}
pub fn fold_create_connection_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionOption<T>) -> CreateConnectionOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateConnectionOption {
        name: folder.fold_create_connection_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionOptionName {
    type Folded = CreateConnectionOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_connection_option_name(self)
    }
}
pub fn fold_create_connection_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionOptionName) -> CreateConnectionOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateConnectionOptionName::Validate {
        } => {
            CreateConnectionOptionName::Validate {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionStatement<T> {
    type Folded = CreateConnectionStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_connection_statement(self)
    }
}
pub fn fold_create_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionStatement<T>) -> CreateConnectionStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateConnectionStatement {
        name: folder.fold_unresolved_item_name(node.name),
        connection_type: folder.fold_create_connection_type(node.connection_type),
        if_not_exists: node.if_not_exists,
        values: node.values.into_iter().map(|v| folder.fold_connection_option(v)).collect(),
        with_options: node.with_options.into_iter().map(|v| folder.fold_create_connection_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionType {
    type Folded = CreateConnectionType;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_connection_type(self)
    }
}
pub fn fold_create_connection_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionType) -> CreateConnectionType
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateConnectionType::Aws {
        } => {
            CreateConnectionType::Aws {
            }
        }
        CreateConnectionType::AwsPrivatelink {
        } => {
            CreateConnectionType::AwsPrivatelink {
            }
        }
        CreateConnectionType::Kafka {
        } => {
            CreateConnectionType::Kafka {
            }
        }
        CreateConnectionType::Csr {
        } => {
            CreateConnectionType::Csr {
            }
        }
        CreateConnectionType::Postgres {
        } => {
            CreateConnectionType::Postgres {
            }
        }
        CreateConnectionType::Ssh {
        } => {
            CreateConnectionType::Ssh {
            }
        }
        CreateConnectionType::MySql {
        } => {
            CreateConnectionType::MySql {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateDatabaseStatement {
    type Folded = CreateDatabaseStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_database_statement(self)
    }
}
pub fn fold_create_database_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateDatabaseStatement) -> CreateDatabaseStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateDatabaseStatement {
        name: folder.fold_unresolved_database_name(node.name),
        if_not_exists: node.if_not_exists,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateIndexStatement<T> {
    type Folded = CreateIndexStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_index_statement(self)
    }
}
pub fn fold_create_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateIndexStatement<T>) -> CreateIndexStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateIndexStatement {
        name: node.name.map(|v| folder.fold_ident(v)),
        in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
        on_name: folder.fold_item_name(node.on_name),
        key_parts: node.key_parts.map(|v| v.into_iter().map(|v| folder.fold_expr(v)).collect()),
        with_options: node.with_options.into_iter().map(|v| folder.fold_index_option(v)).collect(),
        if_not_exists: node.if_not_exists,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateMaterializedViewStatement<T> {
    type Folded = CreateMaterializedViewStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_materialized_view_statement(self)
    }
}
pub fn fold_create_materialized_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateMaterializedViewStatement<T>) -> CreateMaterializedViewStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateMaterializedViewStatement {
        if_exists: folder.fold_if_exists_behavior(node.if_exists),
        name: folder.fold_unresolved_item_name(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
        in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
        query: folder.fold_query(node.query),
        as_of: node.as_of.map(|v| v),
        with_options: node.with_options.into_iter().map(|v| folder.fold_materialized_view_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateRoleStatement {
    type Folded = CreateRoleStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_role_statement(self)
    }
}
pub fn fold_create_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateRoleStatement) -> CreateRoleStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateRoleStatement {
        name: folder.fold_ident(node.name),
        options: node.options.into_iter().map(|v| folder.fold_role_attribute(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSchemaStatement {
    type Folded = CreateSchemaStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_schema_statement(self)
    }
}
pub fn fold_create_schema_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSchemaStatement) -> CreateSchemaStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSchemaStatement {
        name: folder.fold_unresolved_schema_name(node.name),
        if_not_exists: node.if_not_exists,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSecretStatement<T> {
    type Folded = CreateSecretStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_secret_statement(self)
    }
}
pub fn fold_create_secret_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSecretStatement<T>) -> CreateSecretStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSecretStatement {
        name: folder.fold_unresolved_item_name(node.name),
        if_not_exists: node.if_not_exists,
        value: folder.fold_expr(node.value),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkConnection<T> {
    type Folded = CreateSinkConnection<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_sink_connection(self)
    }
}
pub fn fold_create_sink_connection<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkConnection<T>) -> CreateSinkConnection<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateSinkConnection::Kafka {
            connection: binding0,
            options: binding1,
            key: binding2,
            headers: binding3,
        } => {
            CreateSinkConnection::Kafka {
                connection: folder.fold_item_name(binding0),
                options: binding1.into_iter().map(|v| folder.fold_kafka_sink_config_option(v)).collect(),
                key: binding2.map(|v| folder.fold_kafka_sink_key(v)),
                headers: binding3.map(|v| folder.fold_ident(v)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkOption<T> {
    type Folded = CreateSinkOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_sink_option(self)
    }
}
pub fn fold_create_sink_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkOption<T>) -> CreateSinkOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSinkOption {
        name: folder.fold_create_sink_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkOptionName {
    type Folded = CreateSinkOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_sink_option_name(self)
    }
}
pub fn fold_create_sink_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkOptionName) -> CreateSinkOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateSinkOptionName::Snapshot {
        } => {
            CreateSinkOptionName::Snapshot {
            }
        }
        CreateSinkOptionName::Version {
        } => {
            CreateSinkOptionName::Version {
            }
        }
        CreateSinkOptionName::PartitionStrategy {
        } => {
            CreateSinkOptionName::PartitionStrategy {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkStatement<T> {
    type Folded = CreateSinkStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_sink_statement(self)
    }
}
pub fn fold_create_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkStatement<T>) -> CreateSinkStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSinkStatement {
        name: node.name.map(|v| folder.fold_unresolved_item_name(v)),
        in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
        if_not_exists: node.if_not_exists,
        from: folder.fold_item_name(node.from),
        connection: folder.fold_create_sink_connection(node.connection),
        format: node.format.map(|v| folder.fold_format_specifier(v)),
        envelope: node.envelope.map(|v| folder.fold_sink_envelope(v)),
        with_options: node.with_options.into_iter().map(|v| folder.fold_create_sink_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceConnection<T> {
    type Folded = CreateSourceConnection<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_source_connection(self)
    }
}
pub fn fold_create_source_connection<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceConnection<T>) -> CreateSourceConnection<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateSourceConnection::Kafka {
            connection: binding0,
            options: binding1,
        } => {
            CreateSourceConnection::Kafka {
                connection: folder.fold_item_name(binding0),
                options: binding1.into_iter().map(|v| folder.fold_kafka_source_config_option(v)).collect(),
            }
        }
        CreateSourceConnection::Postgres {
            connection: binding0,
            options: binding1,
        } => {
            CreateSourceConnection::Postgres {
                connection: folder.fold_item_name(binding0),
                options: binding1.into_iter().map(|v| folder.fold_pg_config_option(v)).collect(),
            }
        }
        CreateSourceConnection::MySql {
            connection: binding0,
            options: binding1,
        } => {
            CreateSourceConnection::MySql {
                connection: folder.fold_item_name(binding0),
                options: binding1.into_iter().map(|v| folder.fold_my_sql_config_option(v)).collect(),
            }
        }
        CreateSourceConnection::LoadGenerator {
            generator: binding0,
            options: binding1,
        } => {
            CreateSourceConnection::LoadGenerator {
                generator: folder.fold_load_generator(binding0),
                options: binding1.into_iter().map(|v| folder.fold_load_generator_option(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceOption<T> {
    type Folded = CreateSourceOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_source_option(self)
    }
}
pub fn fold_create_source_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceOption<T>) -> CreateSourceOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSourceOption {
        name: folder.fold_create_source_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceOptionName {
    type Folded = CreateSourceOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_source_option_name(self)
    }
}
pub fn fold_create_source_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceOptionName) -> CreateSourceOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateSourceOptionName::IgnoreKeys {
        } => {
            CreateSourceOptionName::IgnoreKeys {
            }
        }
        CreateSourceOptionName::Timeline {
        } => {
            CreateSourceOptionName::Timeline {
            }
        }
        CreateSourceOptionName::TimestampInterval {
        } => {
            CreateSourceOptionName::TimestampInterval {
            }
        }
        CreateSourceOptionName::RetainHistory {
        } => {
            CreateSourceOptionName::RetainHistory {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceStatement<T> {
    type Folded = CreateSourceStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_source_statement(self)
    }
}
pub fn fold_create_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceStatement<T>) -> CreateSourceStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSourceStatement {
        name: folder.fold_unresolved_item_name(node.name),
        in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
        col_names: node.col_names.into_iter().map(|v| folder.fold_ident(v)).collect(),
        connection: folder.fold_create_source_connection(node.connection),
        include_metadata: node.include_metadata.into_iter().map(|v| folder.fold_source_include_metadata(v)).collect(),
        format: node.format.map(|v| folder.fold_format_specifier(v)),
        envelope: node.envelope.map(|v| folder.fold_source_envelope(v)),
        if_not_exists: node.if_not_exists,
        key_constraint: node.key_constraint.map(|v| folder.fold_key_constraint(v)),
        with_options: node.with_options.into_iter().map(|v| folder.fold_create_source_option(v)).collect(),
        external_references: node.external_references.map(|v| folder.fold_external_references(v)),
        progress_subsource: node.progress_subsource.map(|v| folder.fold_deferred_item_name(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSubsourceOption<T> {
    type Folded = CreateSubsourceOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_subsource_option(self)
    }
}
pub fn fold_create_subsource_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSubsourceOption<T>) -> CreateSubsourceOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSubsourceOption {
        name: folder.fold_create_subsource_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSubsourceOptionName {
    type Folded = CreateSubsourceOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_subsource_option_name(self)
    }
}
pub fn fold_create_subsource_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSubsourceOptionName) -> CreateSubsourceOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateSubsourceOptionName::Progress {
        } => {
            CreateSubsourceOptionName::Progress {
            }
        }
        CreateSubsourceOptionName::ExternalReference {
        } => {
            CreateSubsourceOptionName::ExternalReference {
            }
        }
        CreateSubsourceOptionName::TextColumns {
        } => {
            CreateSubsourceOptionName::TextColumns {
            }
        }
        CreateSubsourceOptionName::IgnoreColumns {
        } => {
            CreateSubsourceOptionName::IgnoreColumns {
            }
        }
        CreateSubsourceOptionName::Details {
        } => {
            CreateSubsourceOptionName::Details {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSubsourceStatement<T> {
    type Folded = CreateSubsourceStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_subsource_statement(self)
    }
}
pub fn fold_create_subsource_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSubsourceStatement<T>) -> CreateSubsourceStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateSubsourceStatement {
        name: folder.fold_unresolved_item_name(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_column_def(v)).collect(),
        of_source: node.of_source.map(|v| folder.fold_item_name(v)),
        constraints: node.constraints.into_iter().map(|v| folder.fold_table_constraint(v)).collect(),
        if_not_exists: node.if_not_exists,
        with_options: node.with_options.into_iter().map(|v| folder.fold_create_subsource_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTableFromSourceStatement<T> {
    type Folded = CreateTableFromSourceStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_table_from_source_statement(self)
    }
}
pub fn fold_create_table_from_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTableFromSourceStatement<T>) -> CreateTableFromSourceStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateTableFromSourceStatement {
        name: folder.fold_unresolved_item_name(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
        if_not_exists: node.if_not_exists,
        source: folder.fold_item_name(node.source),
        external_reference: folder.fold_unresolved_item_name(node.external_reference),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTableStatement<T> {
    type Folded = CreateTableStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_table_statement(self)
    }
}
pub fn fold_create_table_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTableStatement<T>) -> CreateTableStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateTableStatement {
        name: folder.fold_unresolved_item_name(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_column_def(v)).collect(),
        constraints: node.constraints.into_iter().map(|v| folder.fold_table_constraint(v)).collect(),
        if_not_exists: node.if_not_exists,
        temporary: node.temporary,
        with_options: node.with_options.into_iter().map(|v| folder.fold_table_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeAs<T> {
    type Folded = CreateTypeAs<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_type_as(self)
    }
}
pub fn fold_create_type_as<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeAs<T>) -> CreateTypeAs<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateTypeAs::List {
            options: binding0,
        } => {
            CreateTypeAs::List {
                options: binding0.into_iter().map(|v| folder.fold_create_type_list_option(v)).collect(),
            }
        }
        CreateTypeAs::Map {
            options: binding0,
        } => {
            CreateTypeAs::Map {
                options: binding0.into_iter().map(|v| folder.fold_create_type_map_option(v)).collect(),
            }
        }
        CreateTypeAs::Record {
            column_defs: binding0,
        } => {
            CreateTypeAs::Record {
                column_defs: binding0.into_iter().map(|v| folder.fold_column_def(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeListOption<T> {
    type Folded = CreateTypeListOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_type_list_option(self)
    }
}
pub fn fold_create_type_list_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeListOption<T>) -> CreateTypeListOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateTypeListOption {
        name: folder.fold_create_type_list_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeListOptionName {
    type Folded = CreateTypeListOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_type_list_option_name(self)
    }
}
pub fn fold_create_type_list_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeListOptionName) -> CreateTypeListOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateTypeListOptionName::ElementType {
        } => {
            CreateTypeListOptionName::ElementType {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeMapOption<T> {
    type Folded = CreateTypeMapOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_type_map_option(self)
    }
}
pub fn fold_create_type_map_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeMapOption<T>) -> CreateTypeMapOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateTypeMapOption {
        name: folder.fold_create_type_map_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeMapOptionName {
    type Folded = CreateTypeMapOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_type_map_option_name(self)
    }
}
pub fn fold_create_type_map_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeMapOptionName) -> CreateTypeMapOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CreateTypeMapOptionName::KeyType {
        } => {
            CreateTypeMapOptionName::KeyType {
            }
        }
        CreateTypeMapOptionName::ValueType {
        } => {
            CreateTypeMapOptionName::ValueType {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeStatement<T> {
    type Folded = CreateTypeStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_type_statement(self)
    }
}
pub fn fold_create_type_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeStatement<T>) -> CreateTypeStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateTypeStatement {
        name: folder.fold_unresolved_item_name(node.name),
        as_type: folder.fold_create_type_as(node.as_type),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateViewStatement<T> {
    type Folded = CreateViewStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_view_statement(self)
    }
}
pub fn fold_create_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateViewStatement<T>) -> CreateViewStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateViewStatement {
        if_exists: folder.fold_if_exists_behavior(node.if_exists),
        temporary: node.temporary,
        definition: folder.fold_view_definition(node.definition),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceBody {
    type Folded = CreateWebhookSourceBody;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_body(self)
    }
}
pub fn fold_create_webhook_source_body<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceBody) -> CreateWebhookSourceBody
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceBody {
        alias: node.alias.map(|v| folder.fold_ident(v)),
        use_bytes: node.use_bytes,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceCheck<T> {
    type Folded = CreateWebhookSourceCheck<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_check(self)
    }
}
pub fn fold_create_webhook_source_check<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceCheck<T>) -> CreateWebhookSourceCheck<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceCheck {
        options: node.options.map(|v| folder.fold_create_webhook_source_check_options(v)),
        using: folder.fold_expr(node.using),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceCheckOptions<T> {
    type Folded = CreateWebhookSourceCheckOptions<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_check_options(self)
    }
}
pub fn fold_create_webhook_source_check_options<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceCheckOptions<T>) -> CreateWebhookSourceCheckOptions<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceCheckOptions {
        secrets: node.secrets.into_iter().map(|v| folder.fold_create_webhook_source_secret(v)).collect(),
        headers: node.headers.into_iter().map(|v| folder.fold_create_webhook_source_header(v)).collect(),
        bodies: node.bodies.into_iter().map(|v| folder.fold_create_webhook_source_body(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceFilterHeader {
    type Folded = CreateWebhookSourceFilterHeader;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_filter_header(self)
    }
}
pub fn fold_create_webhook_source_filter_header<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceFilterHeader) -> CreateWebhookSourceFilterHeader
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceFilterHeader {
        block: node.block,
        header_name: node.header_name,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceHeader {
    type Folded = CreateWebhookSourceHeader;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_header(self)
    }
}
pub fn fold_create_webhook_source_header<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceHeader) -> CreateWebhookSourceHeader
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceHeader {
        alias: node.alias.map(|v| folder.fold_ident(v)),
        use_bytes: node.use_bytes,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceIncludeHeaders {
    type Folded = CreateWebhookSourceIncludeHeaders;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_include_headers(self)
    }
}
pub fn fold_create_webhook_source_include_headers<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceIncludeHeaders) -> CreateWebhookSourceIncludeHeaders
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceIncludeHeaders {
        mappings: node.mappings.into_iter().map(|v| folder.fold_create_webhook_source_map_header(v)).collect(),
        column: node.column.map(|v| v.into_iter().map(|v| folder.fold_create_webhook_source_filter_header(v)).collect()),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceMapHeader {
    type Folded = CreateWebhookSourceMapHeader;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_map_header(self)
    }
}
pub fn fold_create_webhook_source_map_header<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceMapHeader) -> CreateWebhookSourceMapHeader
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceMapHeader {
        header_name: node.header_name,
        column_name: folder.fold_ident(node.column_name),
        use_bytes: node.use_bytes,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceSecret<T> {
    type Folded = CreateWebhookSourceSecret<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_secret(self)
    }
}
pub fn fold_create_webhook_source_secret<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceSecret<T>) -> CreateWebhookSourceSecret<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceSecret {
        secret: folder.fold_item_name(node.secret),
        alias: node.alias.map(|v| folder.fold_ident(v)),
        use_bytes: node.use_bytes,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceStatement<T> {
    type Folded = CreateWebhookSourceStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_create_webhook_source_statement(self)
    }
}
pub fn fold_create_webhook_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceStatement<T>) -> CreateWebhookSourceStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CreateWebhookSourceStatement {
        name: folder.fold_unresolved_item_name(node.name),
        if_not_exists: node.if_not_exists,
        body_format: folder.fold_format(node.body_format),
        include_headers: folder.fold_create_webhook_source_include_headers(node.include_headers),
        validate_using: node.validate_using.map(|v| folder.fold_create_webhook_source_check(v)),
        in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConfigOption<T> {
    type Folded = CsrConfigOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_config_option(self)
    }
}
pub fn fold_csr_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConfigOption<T>) -> CsrConfigOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrConfigOption {
        name: folder.fold_csr_config_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConfigOptionName<T> {
    type Folded = CsrConfigOptionName<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_config_option_name(self)
    }
}
pub fn fold_csr_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConfigOptionName<T>) -> CsrConfigOptionName<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CsrConfigOptionName::AvroKeyFullname {
        } => {
            CsrConfigOptionName::AvroKeyFullname {
            }
        }
        CsrConfigOptionName::AvroValueFullname {
        } => {
            CsrConfigOptionName::AvroValueFullname {
            }
        }
        CsrConfigOptionName::NullDefaults {
        } => {
            CsrConfigOptionName::NullDefaults {
            }
        }
        CsrConfigOptionName::AvroDocOn {
            0: binding0,
        } => {
            CsrConfigOptionName::AvroDocOn {
                0: folder.fold_avro_doc_on(binding0),
            }
        }
        CsrConfigOptionName::KeyCompatibilityLevel {
        } => {
            CsrConfigOptionName::KeyCompatibilityLevel {
            }
        }
        CsrConfigOptionName::ValueCompatibilityLevel {
        } => {
            CsrConfigOptionName::ValueCompatibilityLevel {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConnection<T> {
    type Folded = CsrConnection<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_connection(self)
    }
}
pub fn fold_csr_connection<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConnection<T>) -> CsrConnection<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrConnection {
        connection: folder.fold_item_name(node.connection),
        options: node.options.into_iter().map(|v| folder.fold_csr_config_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConnectionAvro<T> {
    type Folded = CsrConnectionAvro<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_connection_avro(self)
    }
}
pub fn fold_csr_connection_avro<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConnectionAvro<T>) -> CsrConnectionAvro<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrConnectionAvro {
        connection: folder.fold_csr_connection(node.connection),
        key_strategy: node.key_strategy.map(|v| folder.fold_reader_schema_selection_strategy(v)),
        value_strategy: node.value_strategy.map(|v| folder.fold_reader_schema_selection_strategy(v)),
        seed: node.seed.map(|v| folder.fold_csr_seed_avro(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConnectionProtobuf<T> {
    type Folded = CsrConnectionProtobuf<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_connection_protobuf(self)
    }
}
pub fn fold_csr_connection_protobuf<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConnectionProtobuf<T>) -> CsrConnectionProtobuf<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrConnectionProtobuf {
        connection: folder.fold_csr_connection(node.connection),
        seed: node.seed.map(|v| folder.fold_csr_seed_protobuf(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrSeedAvro {
    type Folded = CsrSeedAvro;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_seed_avro(self)
    }
}
pub fn fold_csr_seed_avro<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeedAvro) -> CsrSeedAvro
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrSeedAvro {
        key_schema: node.key_schema.map(|v| v),
        value_schema: node.value_schema,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrSeedProtobuf {
    type Folded = CsrSeedProtobuf;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_seed_protobuf(self)
    }
}
pub fn fold_csr_seed_protobuf<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeedProtobuf) -> CsrSeedProtobuf
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrSeedProtobuf {
        key: node.key.map(|v| folder.fold_csr_seed_protobuf_schema(v)),
        value: folder.fold_csr_seed_protobuf_schema(node.value),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrSeedProtobufSchema {
    type Folded = CsrSeedProtobufSchema;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csr_seed_protobuf_schema(self)
    }
}
pub fn fold_csr_seed_protobuf_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeedProtobufSchema) -> CsrSeedProtobufSchema
where
    F: Fold<T, T2, > + ?Sized,
{
    CsrSeedProtobufSchema {
        schema: node.schema,
        message_name: node.message_name,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsvColumns {
    type Folded = CsvColumns;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_csv_columns(self)
    }
}
pub fn fold_csv_columns<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsvColumns) -> CsvColumns
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CsvColumns::Count {
            0: binding0,
        } => {
            CsvColumns::Count {
                0: binding0,
            }
        }
        CsvColumns::Header {
            names: binding0,
        } => {
            CsvColumns::Header {
                names: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Cte<T> {
    type Folded = Cte<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cte(self)
    }
}
pub fn fold_cte<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Cte<T>) -> Cte<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Cte {
        alias: folder.fold_table_alias(node.alias),
        id: folder.fold_cte_id(node.id),
        query: folder.fold_query(node.query),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CteBlock<T> {
    type Folded = CteBlock<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cte_block(self)
    }
}
pub fn fold_cte_block<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CteBlock<T>) -> CteBlock<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        CteBlock::Simple {
            0: binding0,
        } => {
            CteBlock::Simple {
                0: binding0.into_iter().map(|v| folder.fold_cte(v)).collect(),
            }
        }
        CteBlock::MutuallyRecursive {
            0: binding0,
        } => {
            CteBlock::MutuallyRecursive {
                0: folder.fold_mut_rec_block(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CteMutRec<T> {
    type Folded = CteMutRec<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cte_mut_rec(self)
    }
}
pub fn fold_cte_mut_rec<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CteMutRec<T>) -> CteMutRec<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CteMutRec {
        name: folder.fold_ident(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_cte_mut_rec_column_def(v)).collect(),
        id: folder.fold_cte_id(node.id),
        query: folder.fold_query(node.query),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CteMutRecColumnDef<T> {
    type Folded = CteMutRecColumnDef<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_cte_mut_rec_column_def(self)
    }
}
pub fn fold_cte_mut_rec_column_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CteMutRecColumnDef<T>) -> CteMutRecColumnDef<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    CteMutRecColumnDef {
        name: folder.fold_ident(node.name),
        data_type: folder.fold_data_type(node.data_type),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DateTimeField {
    type Folded = DateTimeField;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_date_time_field(self)
    }
}
pub fn fold_date_time_field<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DateTimeField) -> DateTimeField
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        DateTimeField::Millennium {
        } => {
            DateTimeField::Millennium {
            }
        }
        DateTimeField::Century {
        } => {
            DateTimeField::Century {
            }
        }
        DateTimeField::Decade {
        } => {
            DateTimeField::Decade {
            }
        }
        DateTimeField::Year {
        } => {
            DateTimeField::Year {
            }
        }
        DateTimeField::Month {
        } => {
            DateTimeField::Month {
            }
        }
        DateTimeField::Day {
        } => {
            DateTimeField::Day {
            }
        }
        DateTimeField::Hour {
        } => {
            DateTimeField::Hour {
            }
        }
        DateTimeField::Minute {
        } => {
            DateTimeField::Minute {
            }
        }
        DateTimeField::Second {
        } => {
            DateTimeField::Second {
            }
        }
        DateTimeField::Milliseconds {
        } => {
            DateTimeField::Milliseconds {
            }
        }
        DateTimeField::Microseconds {
        } => {
            DateTimeField::Microseconds {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeallocateStatement {
    type Folded = DeallocateStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_deallocate_statement(self)
    }
}
pub fn fold_deallocate_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeallocateStatement) -> DeallocateStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    DeallocateStatement {
        name: node.name.map(|v| folder.fold_ident(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeclareStatement<T> {
    type Folded = DeclareStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_declare_statement(self)
    }
}
pub fn fold_declare_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeclareStatement<T>) -> DeclareStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    DeclareStatement {
        name: folder.fold_ident(node.name),
        stmt: Box::new(folder.fold_nested_statement(*node.stmt)),
        sql: node.sql,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeferredItemName<T> {
    type Folded = DeferredItemName<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_deferred_item_name(self)
    }
}
pub fn fold_deferred_item_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeferredItemName<T>) -> DeferredItemName<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        DeferredItemName::Named {
            0: binding0,
        } => {
            DeferredItemName::Named {
                0: folder.fold_item_name(binding0),
            }
        }
        DeferredItemName::Deferred {
            0: binding0,
        } => {
            DeferredItemName::Deferred {
                0: folder.fold_unresolved_item_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeleteStatement<T> {
    type Folded = DeleteStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_delete_statement(self)
    }
}
pub fn fold_delete_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeleteStatement<T>) -> DeleteStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    DeleteStatement {
        table_name: folder.fold_item_name(node.table_name),
        alias: node.alias.map(|v| folder.fold_table_alias(v)),
        using: node.using.into_iter().map(|v| folder.fold_table_with_joins(v)).collect(),
        selection: node.selection.map(|v| folder.fold_expr(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DiscardStatement {
    type Folded = DiscardStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_discard_statement(self)
    }
}
pub fn fold_discard_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DiscardStatement) -> DiscardStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    DiscardStatement {
        target: folder.fold_discard_target(node.target),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DiscardTarget {
    type Folded = DiscardTarget;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_discard_target(self)
    }
}
pub fn fold_discard_target<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DiscardTarget) -> DiscardTarget
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        DiscardTarget::Plans {
        } => {
            DiscardTarget::Plans {
            }
        }
        DiscardTarget::Sequences {
        } => {
            DiscardTarget::Sequences {
            }
        }
        DiscardTarget::Temp {
        } => {
            DiscardTarget::Temp {
            }
        }
        DiscardTarget::All {
        } => {
            DiscardTarget::All {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Distinct<T> {
    type Folded = Distinct<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_distinct(self)
    }
}
pub fn fold_distinct<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Distinct<T>) -> Distinct<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Distinct::EntireRow {
        } => {
            Distinct::EntireRow {
            }
        }
        Distinct::On {
            0: binding0,
        } => {
            Distinct::On {
                0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DocOnIdentifier<T> {
    type Folded = DocOnIdentifier<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_doc_on_identifier(self)
    }
}
pub fn fold_doc_on_identifier<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DocOnIdentifier<T>) -> DocOnIdentifier<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        DocOnIdentifier::Column {
            0: binding0,
        } => {
            DocOnIdentifier::Column {
                0: folder.fold_column_name(binding0),
            }
        }
        DocOnIdentifier::Type {
            0: binding0,
        } => {
            DocOnIdentifier::Type {
                0: folder.fold_item_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DocOnSchema {
    type Folded = DocOnSchema;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_doc_on_schema(self)
    }
}
pub fn fold_doc_on_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DocOnSchema) -> DocOnSchema
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        DocOnSchema::KeyOnly {
        } => {
            DocOnSchema::KeyOnly {
            }
        }
        DocOnSchema::ValueOnly {
        } => {
            DocOnSchema::ValueOnly {
            }
        }
        DocOnSchema::All {
        } => {
            DocOnSchema::All {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DropObjectsStatement {
    type Folded = DropObjectsStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_drop_objects_statement(self)
    }
}
pub fn fold_drop_objects_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DropObjectsStatement) -> DropObjectsStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    DropObjectsStatement {
        object_type: folder.fold_object_type(node.object_type),
        if_exists: node.if_exists,
        names: node.names.into_iter().map(|v| folder.fold_unresolved_object_name(v)).collect(),
        cascade: node.cascade,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DropOwnedStatement<T> {
    type Folded = DropOwnedStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_drop_owned_statement(self)
    }
}
pub fn fold_drop_owned_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DropOwnedStatement<T>) -> DropOwnedStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    DropOwnedStatement {
        role_names: node.role_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
        cascade: node.cascade.map(|v| v),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExecuteStatement<T> {
    type Folded = ExecuteStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_execute_statement(self)
    }
}
pub fn fold_execute_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExecuteStatement<T>) -> ExecuteStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ExecuteStatement {
        name: folder.fold_ident(node.name),
        params: node.params.into_iter().map(|v| folder.fold_expr(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainFormat {
    type Folded = ExplainFormat;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_format(self)
    }
}
pub fn fold_explain_format<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainFormat) -> ExplainFormat
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ExplainFormat::Text {
        } => {
            ExplainFormat::Text {
            }
        }
        ExplainFormat::Json {
        } => {
            ExplainFormat::Json {
            }
        }
        ExplainFormat::Dot {
        } => {
            ExplainFormat::Dot {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPlanOption<T> {
    type Folded = ExplainPlanOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_plan_option(self)
    }
}
pub fn fold_explain_plan_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPlanOption<T>) -> ExplainPlanOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ExplainPlanOption {
        name: folder.fold_explain_plan_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPlanOptionName {
    type Folded = ExplainPlanOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_plan_option_name(self)
    }
}
pub fn fold_explain_plan_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPlanOptionName) -> ExplainPlanOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ExplainPlanOptionName::Arity {
        } => {
            ExplainPlanOptionName::Arity {
            }
        }
        ExplainPlanOptionName::Cardinality {
        } => {
            ExplainPlanOptionName::Cardinality {
            }
        }
        ExplainPlanOptionName::ColumnNames {
        } => {
            ExplainPlanOptionName::ColumnNames {
            }
        }
        ExplainPlanOptionName::FilterPushdown {
        } => {
            ExplainPlanOptionName::FilterPushdown {
            }
        }
        ExplainPlanOptionName::HumanizedExpressions {
        } => {
            ExplainPlanOptionName::HumanizedExpressions {
            }
        }
        ExplainPlanOptionName::JoinImplementations {
        } => {
            ExplainPlanOptionName::JoinImplementations {
            }
        }
        ExplainPlanOptionName::Keys {
        } => {
            ExplainPlanOptionName::Keys {
            }
        }
        ExplainPlanOptionName::LinearChains {
        } => {
            ExplainPlanOptionName::LinearChains {
            }
        }
        ExplainPlanOptionName::NonNegative {
        } => {
            ExplainPlanOptionName::NonNegative {
            }
        }
        ExplainPlanOptionName::NoFastPath {
        } => {
            ExplainPlanOptionName::NoFastPath {
            }
        }
        ExplainPlanOptionName::NoNotices {
        } => {
            ExplainPlanOptionName::NoNotices {
            }
        }
        ExplainPlanOptionName::NodeIdentifiers {
        } => {
            ExplainPlanOptionName::NodeIdentifiers {
            }
        }
        ExplainPlanOptionName::RawPlans {
        } => {
            ExplainPlanOptionName::RawPlans {
            }
        }
        ExplainPlanOptionName::RawSyntax {
        } => {
            ExplainPlanOptionName::RawSyntax {
            }
        }
        ExplainPlanOptionName::Raw {
        } => {
            ExplainPlanOptionName::Raw {
            }
        }
        ExplainPlanOptionName::Redacted {
        } => {
            ExplainPlanOptionName::Redacted {
            }
        }
        ExplainPlanOptionName::SubtreeSize {
        } => {
            ExplainPlanOptionName::SubtreeSize {
            }
        }
        ExplainPlanOptionName::Timing {
        } => {
            ExplainPlanOptionName::Timing {
            }
        }
        ExplainPlanOptionName::Types {
        } => {
            ExplainPlanOptionName::Types {
            }
        }
        ExplainPlanOptionName::ReoptimizeImportedViews {
        } => {
            ExplainPlanOptionName::ReoptimizeImportedViews {
            }
        }
        ExplainPlanOptionName::EnableNewOuterJoinLowering {
        } => {
            ExplainPlanOptionName::EnableNewOuterJoinLowering {
            }
        }
        ExplainPlanOptionName::EnableEagerDeltaJoins {
        } => {
            ExplainPlanOptionName::EnableEagerDeltaJoins {
            }
        }
        ExplainPlanOptionName::EnableVariadicLeftJoinLowering {
        } => {
            ExplainPlanOptionName::EnableVariadicLeftJoinLowering {
            }
        }
        ExplainPlanOptionName::EnableLetrecFixpointAnalysis {
        } => {
            ExplainPlanOptionName::EnableLetrecFixpointAnalysis {
            }
        }
        ExplainPlanOptionName::EnableOuterJoinNullFilter {
        } => {
            ExplainPlanOptionName::EnableOuterJoinNullFilter {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPlanStatement<T> {
    type Folded = ExplainPlanStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_plan_statement(self)
    }
}
pub fn fold_explain_plan_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPlanStatement<T>) -> ExplainPlanStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ExplainPlanStatement {
        stage: node.stage.map(|v| folder.fold_explain_stage(v)),
        with_options: node.with_options.into_iter().map(|v| folder.fold_explain_plan_option(v)).collect(),
        format: node.format.map(|v| folder.fold_explain_format(v)),
        explainee: folder.fold_explainee(node.explainee),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPushdownStatement<T> {
    type Folded = ExplainPushdownStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_pushdown_statement(self)
    }
}
pub fn fold_explain_pushdown_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPushdownStatement<T>) -> ExplainPushdownStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ExplainPushdownStatement {
        explainee: folder.fold_explainee(node.explainee),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainSinkSchemaFor {
    type Folded = ExplainSinkSchemaFor;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_sink_schema_for(self)
    }
}
pub fn fold_explain_sink_schema_for<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainSinkSchemaFor) -> ExplainSinkSchemaFor
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ExplainSinkSchemaFor::Key {
        } => {
            ExplainSinkSchemaFor::Key {
            }
        }
        ExplainSinkSchemaFor::Value {
        } => {
            ExplainSinkSchemaFor::Value {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainSinkSchemaStatement<T> {
    type Folded = ExplainSinkSchemaStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_sink_schema_statement(self)
    }
}
pub fn fold_explain_sink_schema_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainSinkSchemaStatement<T>) -> ExplainSinkSchemaStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ExplainSinkSchemaStatement {
        schema_for: folder.fold_explain_sink_schema_for(node.schema_for),
        format: node.format.map(|v| folder.fold_explain_format(v)),
        statement: folder.fold_create_sink_statement(node.statement),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainStage {
    type Folded = ExplainStage;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_stage(self)
    }
}
pub fn fold_explain_stage<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainStage) -> ExplainStage
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ExplainStage::RawPlan {
        } => {
            ExplainStage::RawPlan {
            }
        }
        ExplainStage::DecorrelatedPlan {
        } => {
            ExplainStage::DecorrelatedPlan {
            }
        }
        ExplainStage::LocalPlan {
        } => {
            ExplainStage::LocalPlan {
            }
        }
        ExplainStage::GlobalPlan {
        } => {
            ExplainStage::GlobalPlan {
            }
        }
        ExplainStage::PhysicalPlan {
        } => {
            ExplainStage::PhysicalPlan {
            }
        }
        ExplainStage::Trace {
        } => {
            ExplainStage::Trace {
            }
        }
        ExplainStage::PlanInsights {
        } => {
            ExplainStage::PlanInsights {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainTimestampStatement<T> {
    type Folded = ExplainTimestampStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explain_timestamp_statement(self)
    }
}
pub fn fold_explain_timestamp_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainTimestampStatement<T>) -> ExplainTimestampStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ExplainTimestampStatement {
        format: node.format.map(|v| folder.fold_explain_format(v)),
        select: folder.fold_select_statement(node.select),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Explainee<T> {
    type Folded = Explainee<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_explainee(self)
    }
}
pub fn fold_explainee<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Explainee<T>) -> Explainee<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Explainee::View {
            0: binding0,
        } => {
            Explainee::View {
                0: folder.fold_item_name(binding0),
            }
        }
        Explainee::MaterializedView {
            0: binding0,
        } => {
            Explainee::MaterializedView {
                0: folder.fold_item_name(binding0),
            }
        }
        Explainee::Index {
            0: binding0,
        } => {
            Explainee::Index {
                0: folder.fold_item_name(binding0),
            }
        }
        Explainee::ReplanView {
            0: binding0,
        } => {
            Explainee::ReplanView {
                0: folder.fold_item_name(binding0),
            }
        }
        Explainee::ReplanMaterializedView {
            0: binding0,
        } => {
            Explainee::ReplanMaterializedView {
                0: folder.fold_item_name(binding0),
            }
        }
        Explainee::ReplanIndex {
            0: binding0,
        } => {
            Explainee::ReplanIndex {
                0: folder.fold_item_name(binding0),
            }
        }
        Explainee::Select {
            0: binding0,
            1: binding1,
        } => {
            Explainee::Select {
                0: Box::new(folder.fold_select_statement(*binding0)),
                1: binding1,
            }
        }
        Explainee::CreateView {
            0: binding0,
            1: binding1,
        } => {
            Explainee::CreateView {
                0: Box::new(folder.fold_create_view_statement(*binding0)),
                1: binding1,
            }
        }
        Explainee::CreateMaterializedView {
            0: binding0,
            1: binding1,
        } => {
            Explainee::CreateMaterializedView {
                0: Box::new(folder.fold_create_materialized_view_statement(*binding0)),
                1: binding1,
            }
        }
        Explainee::CreateIndex {
            0: binding0,
            1: binding1,
        } => {
            Explainee::CreateIndex {
                0: Box::new(folder.fold_create_index_statement(*binding0)),
                1: binding1,
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Expr<T> {
    type Folded = Expr<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_expr(self)
    }
}
pub fn fold_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Expr<T>) -> Expr<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Expr::Identifier {
            0: binding0,
        } => {
            Expr::Identifier {
                0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        Expr::QualifiedWildcard {
            0: binding0,
        } => {
            Expr::QualifiedWildcard {
                0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        Expr::FieldAccess {
            expr: binding0,
            field: binding1,
        } => {
            Expr::FieldAccess {
                expr: Box::new(folder.fold_expr(*binding0)),
                field: folder.fold_ident(binding1),
            }
        }
        Expr::WildcardAccess {
            0: binding0,
        } => {
            Expr::WildcardAccess {
                0: Box::new(folder.fold_expr(*binding0)),
            }
        }
        Expr::Parameter {
            0: binding0,
        } => {
            Expr::Parameter {
                0: binding0,
            }
        }
        Expr::Not {
            expr: binding0,
        } => {
            Expr::Not {
                expr: Box::new(folder.fold_expr(*binding0)),
            }
        }
        Expr::And {
            left: binding0,
            right: binding1,
        } => {
            Expr::And {
                left: Box::new(folder.fold_expr(*binding0)),
                right: Box::new(folder.fold_expr(*binding1)),
            }
        }
        Expr::Or {
            left: binding0,
            right: binding1,
        } => {
            Expr::Or {
                left: Box::new(folder.fold_expr(*binding0)),
                right: Box::new(folder.fold_expr(*binding1)),
            }
        }
        Expr::IsExpr {
            expr: binding0,
            construct: binding1,
            negated: binding2,
        } => {
            Expr::IsExpr {
                expr: Box::new(folder.fold_expr(*binding0)),
                construct: folder.fold_is_expr_construct(binding1),
                negated: binding2,
            }
        }
        Expr::InList {
            expr: binding0,
            list: binding1,
            negated: binding2,
        } => {
            Expr::InList {
                expr: Box::new(folder.fold_expr(*binding0)),
                list: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(),
                negated: binding2,
            }
        }
        Expr::InSubquery {
            expr: binding0,
            subquery: binding1,
            negated: binding2,
        } => {
            Expr::InSubquery {
                expr: Box::new(folder.fold_expr(*binding0)),
                subquery: Box::new(folder.fold_query(*binding1)),
                negated: binding2,
            }
        }
        Expr::Like {
            expr: binding0,
            pattern: binding1,
            escape: binding2,
            case_insensitive: binding3,
            negated: binding4,
        } => {
            Expr::Like {
                expr: Box::new(folder.fold_expr(*binding0)),
                pattern: Box::new(folder.fold_expr(*binding1)),
                escape: binding2.map(|v| Box::new(folder.fold_expr(*v))),
                case_insensitive: binding3,
                negated: binding4,
            }
        }
        Expr::Between {
            expr: binding0,
            negated: binding1,
            low: binding2,
            high: binding3,
        } => {
            Expr::Between {
                expr: Box::new(folder.fold_expr(*binding0)),
                negated: binding1,
                low: Box::new(folder.fold_expr(*binding2)),
                high: Box::new(folder.fold_expr(*binding3)),
            }
        }
        Expr::Op {
            op: binding0,
            expr1: binding1,
            expr2: binding2,
        } => {
            Expr::Op {
                op: folder.fold_op(binding0),
                expr1: Box::new(folder.fold_expr(*binding1)),
                expr2: binding2.map(|v| Box::new(folder.fold_expr(*v))),
            }
        }
        Expr::Cast {
            expr: binding0,
            data_type: binding1,
        } => {
            Expr::Cast {
                expr: Box::new(folder.fold_expr(*binding0)),
                data_type: folder.fold_data_type(binding1),
            }
        }
        Expr::Collate {
            expr: binding0,
            collation: binding1,
        } => {
            Expr::Collate {
                expr: Box::new(folder.fold_expr(*binding0)),
                collation: folder.fold_unresolved_item_name(binding1),
            }
        }
        Expr::HomogenizingFunction {
            function: binding0,
            exprs: binding1,
        } => {
            Expr::HomogenizingFunction {
                function: folder.fold_homogenizing_function(binding0),
                exprs: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(),
            }
        }
        Expr::NullIf {
            l_expr: binding0,
            r_expr: binding1,
        } => {
            Expr::NullIf {
                l_expr: Box::new(folder.fold_expr(*binding0)),
                r_expr: Box::new(folder.fold_expr(*binding1)),
            }
        }
        Expr::Nested {
            0: binding0,
        } => {
            Expr::Nested {
                0: Box::new(folder.fold_expr(*binding0)),
            }
        }
        Expr::Row {
            exprs: binding0,
        } => {
            Expr::Row {
                exprs: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
            }
        }
        Expr::Value {
            0: binding0,
        } => {
            Expr::Value {
                0: folder.fold_value(binding0),
            }
        }
        Expr::Function {
            0: binding0,
        } => {
            Expr::Function {
                0: folder.fold_function(binding0),
            }
        }
        Expr::Case {
            operand: binding0,
            conditions: binding1,
            results: binding2,
            else_result: binding3,
        } => {
            Expr::Case {
                operand: binding0.map(|v| Box::new(folder.fold_expr(*v))),
                conditions: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(),
                results: binding2.into_iter().map(|v| folder.fold_expr(v)).collect(),
                else_result: binding3.map(|v| Box::new(folder.fold_expr(*v))),
            }
        }
        Expr::Exists {
            0: binding0,
        } => {
            Expr::Exists {
                0: Box::new(folder.fold_query(*binding0)),
            }
        }
        Expr::Subquery {
            0: binding0,
        } => {
            Expr::Subquery {
                0: Box::new(folder.fold_query(*binding0)),
            }
        }
        Expr::AnySubquery {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            Expr::AnySubquery {
                left: Box::new(folder.fold_expr(*binding0)),
                op: folder.fold_op(binding1),
                right: Box::new(folder.fold_query(*binding2)),
            }
        }
        Expr::AnyExpr {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            Expr::AnyExpr {
                left: Box::new(folder.fold_expr(*binding0)),
                op: folder.fold_op(binding1),
                right: Box::new(folder.fold_expr(*binding2)),
            }
        }
        Expr::AllSubquery {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            Expr::AllSubquery {
                left: Box::new(folder.fold_expr(*binding0)),
                op: folder.fold_op(binding1),
                right: Box::new(folder.fold_query(*binding2)),
            }
        }
        Expr::AllExpr {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            Expr::AllExpr {
                left: Box::new(folder.fold_expr(*binding0)),
                op: folder.fold_op(binding1),
                right: Box::new(folder.fold_expr(*binding2)),
            }
        }
        Expr::Array {
            0: binding0,
        } => {
            Expr::Array {
                0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
            }
        }
        Expr::ArraySubquery {
            0: binding0,
        } => {
            Expr::ArraySubquery {
                0: Box::new(folder.fold_query(*binding0)),
            }
        }
        Expr::List {
            0: binding0,
        } => {
            Expr::List {
                0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
            }
        }
        Expr::ListSubquery {
            0: binding0,
        } => {
            Expr::ListSubquery {
                0: Box::new(folder.fold_query(*binding0)),
            }
        }
        Expr::Map {
            0: binding0,
        } => {
            Expr::Map {
                0: binding0.into_iter().map(|v| folder.fold_map_entry(v)).collect(),
            }
        }
        Expr::MapSubquery {
            0: binding0,
        } => {
            Expr::MapSubquery {
                0: Box::new(folder.fold_query(*binding0)),
            }
        }
        Expr::Subscript {
            expr: binding0,
            positions: binding1,
        } => {
            Expr::Subscript {
                expr: Box::new(folder.fold_expr(*binding0)),
                positions: binding1.into_iter().map(|v| folder.fold_subscript_position(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExternalReferenceExport {
    type Folded = ExternalReferenceExport;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_external_reference_export(self)
    }
}
pub fn fold_external_reference_export<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExternalReferenceExport) -> ExternalReferenceExport
where
    F: Fold<T, T2, > + ?Sized,
{
    ExternalReferenceExport {
        reference: folder.fold_unresolved_item_name(node.reference),
        alias: node.alias.map(|v| folder.fold_unresolved_item_name(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExternalReferences {
    type Folded = ExternalReferences;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_external_references(self)
    }
}
pub fn fold_external_references<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExternalReferences) -> ExternalReferences
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ExternalReferences::SubsetTables {
            0: binding0,
        } => {
            ExternalReferences::SubsetTables {
                0: binding0.into_iter().map(|v| folder.fold_external_reference_export(v)).collect(),
            }
        }
        ExternalReferences::SubsetSchemas {
            0: binding0,
        } => {
            ExternalReferences::SubsetSchemas {
                0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        ExternalReferences::All {
        } => {
            ExternalReferences::All {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchDirection {
    type Folded = FetchDirection;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_fetch_direction(self)
    }
}
pub fn fold_fetch_direction<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchDirection) -> FetchDirection
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        FetchDirection::ForwardAll {
        } => {
            FetchDirection::ForwardAll {
            }
        }
        FetchDirection::ForwardCount {
            0: binding0,
        } => {
            FetchDirection::ForwardCount {
                0: binding0,
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchOption<T> {
    type Folded = FetchOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_fetch_option(self)
    }
}
pub fn fold_fetch_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchOption<T>) -> FetchOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    FetchOption {
        name: folder.fold_fetch_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchOptionName {
    type Folded = FetchOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_fetch_option_name(self)
    }
}
pub fn fold_fetch_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchOptionName) -> FetchOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        FetchOptionName::Timeout {
        } => {
            FetchOptionName::Timeout {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchStatement<T> {
    type Folded = FetchStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_fetch_statement(self)
    }
}
pub fn fold_fetch_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchStatement<T>) -> FetchStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    FetchStatement {
        name: folder.fold_ident(node.name),
        count: node.count.map(|v| folder.fold_fetch_direction(v)),
        options: node.options.into_iter().map(|v| folder.fold_fetch_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Format<T> {
    type Folded = Format<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_format(self)
    }
}
pub fn fold_format<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Format<T>) -> Format<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Format::Bytes {
        } => {
            Format::Bytes {
            }
        }
        Format::Avro {
            0: binding0,
        } => {
            Format::Avro {
                0: folder.fold_avro_schema(binding0),
            }
        }
        Format::Protobuf {
            0: binding0,
        } => {
            Format::Protobuf {
                0: folder.fold_protobuf_schema(binding0),
            }
        }
        Format::Regex {
            0: binding0,
        } => {
            Format::Regex {
                0: binding0,
            }
        }
        Format::Csv {
            columns: binding0,
            delimiter: binding1,
        } => {
            Format::Csv {
                columns: folder.fold_csv_columns(binding0),
                delimiter: binding1,
            }
        }
        Format::Json {
            array: binding0,
        } => {
            Format::Json {
                array: binding0,
            }
        }
        Format::Text {
        } => {
            Format::Text {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FormatSpecifier<T> {
    type Folded = FormatSpecifier<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_format_specifier(self)
    }
}
pub fn fold_format_specifier<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FormatSpecifier<T>) -> FormatSpecifier<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        FormatSpecifier::Bare {
            0: binding0,
        } => {
            FormatSpecifier::Bare {
                0: folder.fold_format(binding0),
            }
        }
        FormatSpecifier::KeyValue {
            key: binding0,
            value: binding1,
        } => {
            FormatSpecifier::KeyValue {
                key: folder.fold_format(binding0),
                value: folder.fold_format(binding1),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Function<T> {
    type Folded = Function<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_function(self)
    }
}
pub fn fold_function<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Function<T>) -> Function<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Function {
        name: folder.fold_item_name(node.name),
        args: folder.fold_function_args(node.args),
        filter: node.filter.map(|v| Box::new(folder.fold_expr(*v))),
        over: node.over.map(|v| folder.fold_window_spec(v)),
        distinct: node.distinct,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FunctionArgs<T> {
    type Folded = FunctionArgs<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_function_args(self)
    }
}
pub fn fold_function_args<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FunctionArgs<T>) -> FunctionArgs<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        FunctionArgs::Star {
        } => {
            FunctionArgs::Star {
            }
        }
        FunctionArgs::Args {
            args: binding0,
            order_by: binding1,
        } => {
            FunctionArgs::Args {
                args: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
                order_by: binding1.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantPrivilegesStatement<T> {
    type Folded = GrantPrivilegesStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_grant_privileges_statement(self)
    }
}
pub fn fold_grant_privileges_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantPrivilegesStatement<T>) -> GrantPrivilegesStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    GrantPrivilegesStatement {
        privileges: folder.fold_privilege_specification(node.privileges),
        target: folder.fold_grant_target_specification(node.target),
        roles: node.roles.into_iter().map(|v| folder.fold_role_name(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantRoleStatement<T> {
    type Folded = GrantRoleStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_grant_role_statement(self)
    }
}
pub fn fold_grant_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantRoleStatement<T>) -> GrantRoleStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    GrantRoleStatement {
        role_names: node.role_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
        member_names: node.member_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantTargetAllSpecification<T> {
    type Folded = GrantTargetAllSpecification<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_grant_target_all_specification(self)
    }
}
pub fn fold_grant_target_all_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantTargetAllSpecification<T>) -> GrantTargetAllSpecification<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        GrantTargetAllSpecification::All {
        } => {
            GrantTargetAllSpecification::All {
            }
        }
        GrantTargetAllSpecification::AllDatabases {
            databases: binding0,
        } => {
            GrantTargetAllSpecification::AllDatabases {
                databases: binding0.into_iter().map(|v| folder.fold_database_name(v)).collect(),
            }
        }
        GrantTargetAllSpecification::AllSchemas {
            schemas: binding0,
        } => {
            GrantTargetAllSpecification::AllSchemas {
                schemas: binding0.into_iter().map(|v| folder.fold_schema_name(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantTargetSpecification<T> {
    type Folded = GrantTargetSpecification<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_grant_target_specification(self)
    }
}
pub fn fold_grant_target_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantTargetSpecification<T>) -> GrantTargetSpecification<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        GrantTargetSpecification::Object {
            object_type: binding0,
            object_spec_inner: binding1,
        } => {
            GrantTargetSpecification::Object {
                object_type: folder.fold_object_type(binding0),
                object_spec_inner: folder.fold_grant_target_specification_inner(binding1),
            }
        }
        GrantTargetSpecification::System {
        } => {
            GrantTargetSpecification::System {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantTargetSpecificationInner<T> {
    type Folded = GrantTargetSpecificationInner<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_grant_target_specification_inner(self)
    }
}
pub fn fold_grant_target_specification_inner<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantTargetSpecificationInner<T>) -> GrantTargetSpecificationInner<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        GrantTargetSpecificationInner::All {
            0: binding0,
        } => {
            GrantTargetSpecificationInner::All {
                0: folder.fold_grant_target_all_specification(binding0),
            }
        }
        GrantTargetSpecificationInner::Objects {
            names: binding0,
        } => {
            GrantTargetSpecificationInner::Objects {
                names: binding0.into_iter().map(|v| folder.fold_object_name(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for HomogenizingFunction {
    type Folded = HomogenizingFunction;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_homogenizing_function(self)
    }
}
pub fn fold_homogenizing_function<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: HomogenizingFunction) -> HomogenizingFunction
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        HomogenizingFunction::Coalesce {
        } => {
            HomogenizingFunction::Coalesce {
            }
        }
        HomogenizingFunction::Greatest {
        } => {
            HomogenizingFunction::Greatest {
            }
        }
        HomogenizingFunction::Least {
        } => {
            HomogenizingFunction::Least {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Ident {
    type Folded = Ident;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_ident(self)
    }
}
pub fn fold_ident<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Ident) -> Ident
where
    F: Fold<T, T2, > + ?Sized,
{
    Ident {
        0: node.0,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IdentError {
    type Folded = IdentError;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_ident_error(self)
    }
}
pub fn fold_ident_error<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IdentError) -> IdentError
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        IdentError::TooLong {
            0: binding0,
        } => {
            IdentError::TooLong {
                0: binding0,
            }
        }
        IdentError::FailedToGenerate {
            prefix: binding0,
            suffix: binding1,
            attempts: binding2,
        } => {
            IdentError::FailedToGenerate {
                prefix: binding0,
                suffix: binding1,
                attempts: binding2,
            }
        }
        IdentError::Invalid {
            0: binding0,
        } => {
            IdentError::Invalid {
                0: binding0,
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IfExistsBehavior {
    type Folded = IfExistsBehavior;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_if_exists_behavior(self)
    }
}
pub fn fold_if_exists_behavior<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IfExistsBehavior) -> IfExistsBehavior
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        IfExistsBehavior::Error {
        } => {
            IfExistsBehavior::Error {
            }
        }
        IfExistsBehavior::Skip {
        } => {
            IfExistsBehavior::Skip {
            }
        }
        IfExistsBehavior::Replace {
        } => {
            IfExistsBehavior::Replace {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IndexOption<T> {
    type Folded = IndexOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_index_option(self)
    }
}
pub fn fold_index_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IndexOption<T>) -> IndexOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    IndexOption {
        name: folder.fold_index_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IndexOptionName {
    type Folded = IndexOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_index_option_name(self)
    }
}
pub fn fold_index_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IndexOptionName) -> IndexOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        IndexOptionName::RetainHistory {
        } => {
            IndexOptionName::RetainHistory {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for InsertSource<T> {
    type Folded = InsertSource<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_insert_source(self)
    }
}
pub fn fold_insert_source<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InsertSource<T>) -> InsertSource<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        InsertSource::Query {
            0: binding0,
        } => {
            InsertSource::Query {
                0: folder.fold_query(binding0),
            }
        }
        InsertSource::DefaultValues {
        } => {
            InsertSource::DefaultValues {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for InsertStatement<T> {
    type Folded = InsertStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_insert_statement(self)
    }
}
pub fn fold_insert_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InsertStatement<T>) -> InsertStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    InsertStatement {
        table_name: folder.fold_item_name(node.table_name),
        columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
        source: folder.fold_insert_source(node.source),
        returning: node.returning.into_iter().map(|v| folder.fold_select_item(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for InspectShardStatement {
    type Folded = InspectShardStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_inspect_shard_statement(self)
    }
}
pub fn fold_inspect_shard_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InspectShardStatement) -> InspectShardStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    InspectShardStatement {
        id: node.id,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IntervalValue {
    type Folded = IntervalValue;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_interval_value(self)
    }
}
pub fn fold_interval_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IntervalValue) -> IntervalValue
where
    F: Fold<T, T2, > + ?Sized,
{
    IntervalValue {
        value: node.value,
        precision_high: folder.fold_date_time_field(node.precision_high),
        precision_low: folder.fold_date_time_field(node.precision_low),
        fsec_max_precision: node.fsec_max_precision.map(|v| v),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IsExprConstruct<T> {
    type Folded = IsExprConstruct<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_is_expr_construct(self)
    }
}
pub fn fold_is_expr_construct<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IsExprConstruct<T>) -> IsExprConstruct<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        IsExprConstruct::Null {
        } => {
            IsExprConstruct::Null {
            }
        }
        IsExprConstruct::True {
        } => {
            IsExprConstruct::True {
            }
        }
        IsExprConstruct::False {
        } => {
            IsExprConstruct::False {
            }
        }
        IsExprConstruct::Unknown {
        } => {
            IsExprConstruct::Unknown {
            }
        }
        IsExprConstruct::DistinctFrom {
            0: binding0,
        } => {
            IsExprConstruct::DistinctFrom {
                0: Box::new(folder.fold_expr(*binding0)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Join<T> {
    type Folded = Join<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_join(self)
    }
}
pub fn fold_join<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Join<T>) -> Join<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Join {
        relation: folder.fold_table_factor(node.relation),
        join_operator: folder.fold_join_operator(node.join_operator),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for JoinConstraint<T> {
    type Folded = JoinConstraint<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_join_constraint(self)
    }
}
pub fn fold_join_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: JoinConstraint<T>) -> JoinConstraint<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        JoinConstraint::On {
            0: binding0,
        } => {
            JoinConstraint::On {
                0: folder.fold_expr(binding0),
            }
        }
        JoinConstraint::Using {
            columns: binding0,
            alias: binding1,
        } => {
            JoinConstraint::Using {
                columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
                alias: binding1.map(|v| folder.fold_ident(v)),
            }
        }
        JoinConstraint::Natural {
        } => {
            JoinConstraint::Natural {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for JoinOperator<T> {
    type Folded = JoinOperator<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_join_operator(self)
    }
}
pub fn fold_join_operator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: JoinOperator<T>) -> JoinOperator<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        JoinOperator::Inner {
            0: binding0,
        } => {
            JoinOperator::Inner {
                0: folder.fold_join_constraint(binding0),
            }
        }
        JoinOperator::LeftOuter {
            0: binding0,
        } => {
            JoinOperator::LeftOuter {
                0: folder.fold_join_constraint(binding0),
            }
        }
        JoinOperator::RightOuter {
            0: binding0,
        } => {
            JoinOperator::RightOuter {
                0: folder.fold_join_constraint(binding0),
            }
        }
        JoinOperator::FullOuter {
            0: binding0,
        } => {
            JoinOperator::FullOuter {
                0: folder.fold_join_constraint(binding0),
            }
        }
        JoinOperator::CrossJoin {
        } => {
            JoinOperator::CrossJoin {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBroker<T> {
    type Folded = KafkaBroker<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_broker(self)
    }
}
pub fn fold_kafka_broker<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBroker<T>) -> KafkaBroker<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    KafkaBroker {
        address: node.address,
        tunnel: folder.fold_kafka_broker_tunnel(node.tunnel),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerAwsPrivatelink<T> {
    type Folded = KafkaBrokerAwsPrivatelink<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_broker_aws_privatelink(self)
    }
}
pub fn fold_kafka_broker_aws_privatelink<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerAwsPrivatelink<T>) -> KafkaBrokerAwsPrivatelink<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    KafkaBrokerAwsPrivatelink {
        connection: folder.fold_item_name(node.connection),
        options: node.options.into_iter().map(|v| folder.fold_kafka_broker_aws_privatelink_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerAwsPrivatelinkOption<T> {
    type Folded = KafkaBrokerAwsPrivatelinkOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_broker_aws_privatelink_option(self)
    }
}
pub fn fold_kafka_broker_aws_privatelink_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerAwsPrivatelinkOption<T>) -> KafkaBrokerAwsPrivatelinkOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    KafkaBrokerAwsPrivatelinkOption {
        name: folder.fold_kafka_broker_aws_privatelink_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerAwsPrivatelinkOptionName {
    type Folded = KafkaBrokerAwsPrivatelinkOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_broker_aws_privatelink_option_name(self)
    }
}
pub fn fold_kafka_broker_aws_privatelink_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerAwsPrivatelinkOptionName) -> KafkaBrokerAwsPrivatelinkOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone {
        } => {
            KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone {
            }
        }
        KafkaBrokerAwsPrivatelinkOptionName::Port {
        } => {
            KafkaBrokerAwsPrivatelinkOptionName::Port {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerTunnel<T> {
    type Folded = KafkaBrokerTunnel<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_broker_tunnel(self)
    }
}
pub fn fold_kafka_broker_tunnel<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerTunnel<T>) -> KafkaBrokerTunnel<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        KafkaBrokerTunnel::Direct {
        } => {
            KafkaBrokerTunnel::Direct {
            }
        }
        KafkaBrokerTunnel::AwsPrivatelink {
            0: binding0,
        } => {
            KafkaBrokerTunnel::AwsPrivatelink {
                0: folder.fold_kafka_broker_aws_privatelink(binding0),
            }
        }
        KafkaBrokerTunnel::SshTunnel {
            0: binding0,
        } => {
            KafkaBrokerTunnel::SshTunnel {
                0: folder.fold_item_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSinkConfigOption<T> {
    type Folded = KafkaSinkConfigOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_sink_config_option(self)
    }
}
pub fn fold_kafka_sink_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSinkConfigOption<T>) -> KafkaSinkConfigOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    KafkaSinkConfigOption {
        name: folder.fold_kafka_sink_config_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSinkConfigOptionName {
    type Folded = KafkaSinkConfigOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_sink_config_option_name(self)
    }
}
pub fn fold_kafka_sink_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSinkConfigOptionName) -> KafkaSinkConfigOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        KafkaSinkConfigOptionName::CompressionType {
        } => {
            KafkaSinkConfigOptionName::CompressionType {
            }
        }
        KafkaSinkConfigOptionName::ProgressGroupIdPrefix {
        } => {
            KafkaSinkConfigOptionName::ProgressGroupIdPrefix {
            }
        }
        KafkaSinkConfigOptionName::Topic {
        } => {
            KafkaSinkConfigOptionName::Topic {
            }
        }
        KafkaSinkConfigOptionName::TransactionalIdPrefix {
        } => {
            KafkaSinkConfigOptionName::TransactionalIdPrefix {
            }
        }
        KafkaSinkConfigOptionName::LegacyIds {
        } => {
            KafkaSinkConfigOptionName::LegacyIds {
            }
        }
        KafkaSinkConfigOptionName::TopicConfig {
        } => {
            KafkaSinkConfigOptionName::TopicConfig {
            }
        }
        KafkaSinkConfigOptionName::TopicMetadataRefreshInterval {
        } => {
            KafkaSinkConfigOptionName::TopicMetadataRefreshInterval {
            }
        }
        KafkaSinkConfigOptionName::TopicPartitionCount {
        } => {
            KafkaSinkConfigOptionName::TopicPartitionCount {
            }
        }
        KafkaSinkConfigOptionName::TopicReplicationFactor {
        } => {
            KafkaSinkConfigOptionName::TopicReplicationFactor {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSinkKey {
    type Folded = KafkaSinkKey;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_sink_key(self)
    }
}
pub fn fold_kafka_sink_key<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSinkKey) -> KafkaSinkKey
where
    F: Fold<T, T2, > + ?Sized,
{
    KafkaSinkKey {
        key_columns: node.key_columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
        not_enforced: node.not_enforced,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSourceConfigOption<T> {
    type Folded = KafkaSourceConfigOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_source_config_option(self)
    }
}
pub fn fold_kafka_source_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSourceConfigOption<T>) -> KafkaSourceConfigOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    KafkaSourceConfigOption {
        name: folder.fold_kafka_source_config_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSourceConfigOptionName {
    type Folded = KafkaSourceConfigOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_kafka_source_config_option_name(self)
    }
}
pub fn fold_kafka_source_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSourceConfigOptionName) -> KafkaSourceConfigOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        KafkaSourceConfigOptionName::GroupIdPrefix {
        } => {
            KafkaSourceConfigOptionName::GroupIdPrefix {
            }
        }
        KafkaSourceConfigOptionName::Topic {
        } => {
            KafkaSourceConfigOptionName::Topic {
            }
        }
        KafkaSourceConfigOptionName::TopicMetadataRefreshInterval {
        } => {
            KafkaSourceConfigOptionName::TopicMetadataRefreshInterval {
            }
        }
        KafkaSourceConfigOptionName::StartTimestamp {
        } => {
            KafkaSourceConfigOptionName::StartTimestamp {
            }
        }
        KafkaSourceConfigOptionName::StartOffset {
        } => {
            KafkaSourceConfigOptionName::StartOffset {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KeyConstraint {
    type Folded = KeyConstraint;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_key_constraint(self)
    }
}
pub fn fold_key_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KeyConstraint) -> KeyConstraint
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        KeyConstraint::PrimaryKeyNotEnforced {
            columns: binding0,
        } => {
            KeyConstraint::PrimaryKeyNotEnforced {
                columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Limit<T> {
    type Folded = Limit<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_limit(self)
    }
}
pub fn fold_limit<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Limit<T>) -> Limit<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Limit {
        with_ties: node.with_ties,
        quantity: folder.fold_expr(node.quantity),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for LoadGenerator {
    type Folded = LoadGenerator;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_load_generator(self)
    }
}
pub fn fold_load_generator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: LoadGenerator) -> LoadGenerator
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        LoadGenerator::Clock {
        } => {
            LoadGenerator::Clock {
            }
        }
        LoadGenerator::Counter {
        } => {
            LoadGenerator::Counter {
            }
        }
        LoadGenerator::Marketing {
        } => {
            LoadGenerator::Marketing {
            }
        }
        LoadGenerator::Auction {
        } => {
            LoadGenerator::Auction {
            }
        }
        LoadGenerator::Datums {
        } => {
            LoadGenerator::Datums {
            }
        }
        LoadGenerator::Tpch {
        } => {
            LoadGenerator::Tpch {
            }
        }
        LoadGenerator::KeyValue {
        } => {
            LoadGenerator::KeyValue {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for LoadGeneratorOption<T> {
    type Folded = LoadGeneratorOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_load_generator_option(self)
    }
}
pub fn fold_load_generator_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: LoadGeneratorOption<T>) -> LoadGeneratorOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    LoadGeneratorOption {
        name: folder.fold_load_generator_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for LoadGeneratorOptionName {
    type Folded = LoadGeneratorOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_load_generator_option_name(self)
    }
}
pub fn fold_load_generator_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: LoadGeneratorOptionName) -> LoadGeneratorOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        LoadGeneratorOptionName::ScaleFactor {
        } => {
            LoadGeneratorOptionName::ScaleFactor {
            }
        }
        LoadGeneratorOptionName::TickInterval {
        } => {
            LoadGeneratorOptionName::TickInterval {
            }
        }
        LoadGeneratorOptionName::AsOf {
        } => {
            LoadGeneratorOptionName::AsOf {
            }
        }
        LoadGeneratorOptionName::UpTo {
        } => {
            LoadGeneratorOptionName::UpTo {
            }
        }
        LoadGeneratorOptionName::MaxCardinality {
        } => {
            LoadGeneratorOptionName::MaxCardinality {
            }
        }
        LoadGeneratorOptionName::Keys {
        } => {
            LoadGeneratorOptionName::Keys {
            }
        }
        LoadGeneratorOptionName::SnapshotRounds {
        } => {
            LoadGeneratorOptionName::SnapshotRounds {
            }
        }
        LoadGeneratorOptionName::TransactionalSnapshot {
        } => {
            LoadGeneratorOptionName::TransactionalSnapshot {
            }
        }
        LoadGeneratorOptionName::ValueSize {
        } => {
            LoadGeneratorOptionName::ValueSize {
            }
        }
        LoadGeneratorOptionName::Seed {
        } => {
            LoadGeneratorOptionName::Seed {
            }
        }
        LoadGeneratorOptionName::Partitions {
        } => {
            LoadGeneratorOptionName::Partitions {
            }
        }
        LoadGeneratorOptionName::BatchSize {
        } => {
            LoadGeneratorOptionName::BatchSize {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MapEntry<T> {
    type Folded = MapEntry<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_map_entry(self)
    }
}
pub fn fold_map_entry<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MapEntry<T>) -> MapEntry<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    MapEntry {
        key: folder.fold_expr(node.key),
        value: folder.fold_expr(node.value),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MaterializedViewOption<T> {
    type Folded = MaterializedViewOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_materialized_view_option(self)
    }
}
pub fn fold_materialized_view_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MaterializedViewOption<T>) -> MaterializedViewOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    MaterializedViewOption {
        name: folder.fold_materialized_view_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MaterializedViewOptionName {
    type Folded = MaterializedViewOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_materialized_view_option_name(self)
    }
}
pub fn fold_materialized_view_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MaterializedViewOptionName) -> MaterializedViewOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        MaterializedViewOptionName::AssertNotNull {
        } => {
            MaterializedViewOptionName::AssertNotNull {
            }
        }
        MaterializedViewOptionName::RetainHistory {
        } => {
            MaterializedViewOptionName::RetainHistory {
            }
        }
        MaterializedViewOptionName::Refresh {
        } => {
            MaterializedViewOptionName::Refresh {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MutRecBlock<T> {
    type Folded = MutRecBlock<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_mut_rec_block(self)
    }
}
pub fn fold_mut_rec_block<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MutRecBlock<T>) -> MutRecBlock<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    MutRecBlock {
        options: node.options.into_iter().map(|v| folder.fold_mut_rec_block_option(v)).collect(),
        ctes: node.ctes.into_iter().map(|v| folder.fold_cte_mut_rec(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MutRecBlockOption<T> {
    type Folded = MutRecBlockOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_mut_rec_block_option(self)
    }
}
pub fn fold_mut_rec_block_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MutRecBlockOption<T>) -> MutRecBlockOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    MutRecBlockOption {
        name: folder.fold_mut_rec_block_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MutRecBlockOptionName {
    type Folded = MutRecBlockOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_mut_rec_block_option_name(self)
    }
}
pub fn fold_mut_rec_block_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MutRecBlockOptionName) -> MutRecBlockOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        MutRecBlockOptionName::RecursionLimit {
        } => {
            MutRecBlockOptionName::RecursionLimit {
            }
        }
        MutRecBlockOptionName::ErrorAtRecursionLimit {
        } => {
            MutRecBlockOptionName::ErrorAtRecursionLimit {
            }
        }
        MutRecBlockOptionName::ReturnAtRecursionLimit {
        } => {
            MutRecBlockOptionName::ReturnAtRecursionLimit {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MySqlConfigOption<T> {
    type Folded = MySqlConfigOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_my_sql_config_option(self)
    }
}
pub fn fold_my_sql_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MySqlConfigOption<T>) -> MySqlConfigOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    MySqlConfigOption {
        name: folder.fold_my_sql_config_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MySqlConfigOptionName {
    type Folded = MySqlConfigOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_my_sql_config_option_name(self)
    }
}
pub fn fold_my_sql_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MySqlConfigOptionName) -> MySqlConfigOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        MySqlConfigOptionName::Details {
        } => {
            MySqlConfigOptionName::Details {
            }
        }
        MySqlConfigOptionName::TextColumns {
        } => {
            MySqlConfigOptionName::TextColumns {
            }
        }
        MySqlConfigOptionName::IgnoreColumns {
        } => {
            MySqlConfigOptionName::IgnoreColumns {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NamedPlan {
    type Folded = NamedPlan;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_named_plan(self)
    }
}
pub fn fold_named_plan<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NamedPlan) -> NamedPlan
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        NamedPlan::Raw {
        } => {
            NamedPlan::Raw {
            }
        }
        NamedPlan::Decorrelated {
        } => {
            NamedPlan::Decorrelated {
            }
        }
        NamedPlan::Local {
        } => {
            NamedPlan::Local {
            }
        }
        NamedPlan::Global {
        } => {
            NamedPlan::Global {
            }
        }
        NamedPlan::Physical {
        } => {
            NamedPlan::Physical {
            }
        }
        NamedPlan::FastPath {
        } => {
            NamedPlan::FastPath {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NoticeSeverity {
    type Folded = NoticeSeverity;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_notice_severity(self)
    }
}
pub fn fold_notice_severity<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NoticeSeverity) -> NoticeSeverity
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        NoticeSeverity::Debug {
        } => {
            NoticeSeverity::Debug {
            }
        }
        NoticeSeverity::Info {
        } => {
            NoticeSeverity::Info {
            }
        }
        NoticeSeverity::Log {
        } => {
            NoticeSeverity::Log {
            }
        }
        NoticeSeverity::Notice {
        } => {
            NoticeSeverity::Notice {
            }
        }
        NoticeSeverity::Warning {
        } => {
            NoticeSeverity::Warning {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ObjectType {
    type Folded = ObjectType;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_object_type(self)
    }
}
pub fn fold_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ObjectType) -> ObjectType
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ObjectType::Table {
        } => {
            ObjectType::Table {
            }
        }
        ObjectType::View {
        } => {
            ObjectType::View {
            }
        }
        ObjectType::MaterializedView {
        } => {
            ObjectType::MaterializedView {
            }
        }
        ObjectType::Source {
        } => {
            ObjectType::Source {
            }
        }
        ObjectType::Sink {
        } => {
            ObjectType::Sink {
            }
        }
        ObjectType::Index {
        } => {
            ObjectType::Index {
            }
        }
        ObjectType::Type {
        } => {
            ObjectType::Type {
            }
        }
        ObjectType::Role {
        } => {
            ObjectType::Role {
            }
        }
        ObjectType::Cluster {
        } => {
            ObjectType::Cluster {
            }
        }
        ObjectType::ClusterReplica {
        } => {
            ObjectType::ClusterReplica {
            }
        }
        ObjectType::Secret {
        } => {
            ObjectType::Secret {
            }
        }
        ObjectType::Connection {
        } => {
            ObjectType::Connection {
            }
        }
        ObjectType::Database {
        } => {
            ObjectType::Database {
            }
        }
        ObjectType::Schema {
        } => {
            ObjectType::Schema {
            }
        }
        ObjectType::Func {
        } => {
            ObjectType::Func {
            }
        }
        ObjectType::Subsource {
        } => {
            ObjectType::Subsource {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Op {
    type Folded = Op;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_op(self)
    }
}
pub fn fold_op<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Op) -> Op
where
    F: Fold<T, T2, > + ?Sized,
{
    Op {
        namespace: node.namespace.map(|v| v.into_iter().map(|v| folder.fold_ident(v)).collect()),
        op: node.op,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for OrderByExpr<T> {
    type Folded = OrderByExpr<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_order_by_expr(self)
    }
}
pub fn fold_order_by_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: OrderByExpr<T>) -> OrderByExpr<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    OrderByExpr {
        expr: folder.fold_expr(node.expr),
        asc: node.asc.map(|v| v),
        nulls_last: node.nulls_last.map(|v| v),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PgConfigOption<T> {
    type Folded = PgConfigOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_pg_config_option(self)
    }
}
pub fn fold_pg_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PgConfigOption<T>) -> PgConfigOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    PgConfigOption {
        name: folder.fold_pg_config_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PgConfigOptionName {
    type Folded = PgConfigOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_pg_config_option_name(self)
    }
}
pub fn fold_pg_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PgConfigOptionName) -> PgConfigOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        PgConfigOptionName::Details {
        } => {
            PgConfigOptionName::Details {
            }
        }
        PgConfigOptionName::Publication {
        } => {
            PgConfigOptionName::Publication {
            }
        }
        PgConfigOptionName::TextColumns {
        } => {
            PgConfigOptionName::TextColumns {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PrepareStatement<T> {
    type Folded = PrepareStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_prepare_statement(self)
    }
}
pub fn fold_prepare_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PrepareStatement<T>) -> PrepareStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    PrepareStatement {
        name: folder.fold_ident(node.name),
        stmt: Box::new(folder.fold_nested_statement(*node.stmt)),
        sql: node.sql,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Privilege {
    type Folded = Privilege;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_privilege(self)
    }
}
pub fn fold_privilege<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Privilege) -> Privilege
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Privilege::SELECT {
        } => {
            Privilege::SELECT {
            }
        }
        Privilege::INSERT {
        } => {
            Privilege::INSERT {
            }
        }
        Privilege::UPDATE {
        } => {
            Privilege::UPDATE {
            }
        }
        Privilege::DELETE {
        } => {
            Privilege::DELETE {
            }
        }
        Privilege::USAGE {
        } => {
            Privilege::USAGE {
            }
        }
        Privilege::CREATE {
        } => {
            Privilege::CREATE {
            }
        }
        Privilege::CREATEROLE {
        } => {
            Privilege::CREATEROLE {
            }
        }
        Privilege::CREATEDB {
        } => {
            Privilege::CREATEDB {
            }
        }
        Privilege::CREATECLUSTER {
        } => {
            Privilege::CREATECLUSTER {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PrivilegeSpecification {
    type Folded = PrivilegeSpecification;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_privilege_specification(self)
    }
}
pub fn fold_privilege_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PrivilegeSpecification) -> PrivilegeSpecification
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        PrivilegeSpecification::All {
        } => {
            PrivilegeSpecification::All {
            }
        }
        PrivilegeSpecification::Privileges {
            0: binding0,
        } => {
            PrivilegeSpecification::Privileges {
                0: binding0.into_iter().map(|v| folder.fold_privilege(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ProtobufSchema<T> {
    type Folded = ProtobufSchema<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_protobuf_schema(self)
    }
}
pub fn fold_protobuf_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ProtobufSchema<T>) -> ProtobufSchema<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ProtobufSchema::Csr {
            csr_connection: binding0,
        } => {
            ProtobufSchema::Csr {
                csr_connection: folder.fold_csr_connection_protobuf(binding0),
            }
        }
        ProtobufSchema::InlineSchema {
            message_name: binding0,
            schema: binding1,
        } => {
            ProtobufSchema::InlineSchema {
                message_name: binding0,
                schema: folder.fold_schema(binding1),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for QualifiedReplica {
    type Folded = QualifiedReplica;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_qualified_replica(self)
    }
}
pub fn fold_qualified_replica<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: QualifiedReplica) -> QualifiedReplica
where
    F: Fold<T, T2, > + ?Sized,
{
    QualifiedReplica {
        cluster: folder.fold_ident(node.cluster),
        replica: folder.fold_ident(node.replica),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Query<T> {
    type Folded = Query<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_query(self)
    }
}
pub fn fold_query<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Query<T>) -> Query<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Query {
        ctes: folder.fold_cte_block(node.ctes),
        body: folder.fold_set_expr(node.body),
        order_by: node.order_by.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
        limit: node.limit.map(|v| folder.fold_limit(v)),
        offset: node.offset.map(|v| folder.fold_expr(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RaiseStatement {
    type Folded = RaiseStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_raise_statement(self)
    }
}
pub fn fold_raise_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RaiseStatement) -> RaiseStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    RaiseStatement {
        severity: folder.fold_notice_severity(node.severity),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReaderSchemaSelectionStrategy {
    type Folded = ReaderSchemaSelectionStrategy;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_reader_schema_selection_strategy(self)
    }
}
pub fn fold_reader_schema_selection_strategy<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReaderSchemaSelectionStrategy) -> ReaderSchemaSelectionStrategy
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ReaderSchemaSelectionStrategy::Latest {
        } => {
            ReaderSchemaSelectionStrategy::Latest {
            }
        }
        ReaderSchemaSelectionStrategy::Inline {
            0: binding0,
        } => {
            ReaderSchemaSelectionStrategy::Inline {
                0: binding0,
            }
        }
        ReaderSchemaSelectionStrategy::ById {
            0: binding0,
        } => {
            ReaderSchemaSelectionStrategy::ById {
                0: binding0,
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReassignOwnedStatement<T> {
    type Folded = ReassignOwnedStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_reassign_owned_statement(self)
    }
}
pub fn fold_reassign_owned_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReassignOwnedStatement<T>) -> ReassignOwnedStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ReassignOwnedStatement {
        old_roles: node.old_roles.into_iter().map(|v| folder.fold_role_name(v)).collect(),
        new_role: folder.fold_role_name(node.new_role),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RefreshAtOptionValue<T> {
    type Folded = RefreshAtOptionValue<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_refresh_at_option_value(self)
    }
}
pub fn fold_refresh_at_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RefreshAtOptionValue<T>) -> RefreshAtOptionValue<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    RefreshAtOptionValue {
        time: folder.fold_expr(node.time),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RefreshEveryOptionValue<T> {
    type Folded = RefreshEveryOptionValue<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_refresh_every_option_value(self)
    }
}
pub fn fold_refresh_every_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RefreshEveryOptionValue<T>) -> RefreshEveryOptionValue<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    RefreshEveryOptionValue {
        interval: folder.fold_interval_value(node.interval),
        aligned_to: node.aligned_to.map(|v| folder.fold_expr(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RefreshOptionValue<T> {
    type Folded = RefreshOptionValue<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_refresh_option_value(self)
    }
}
pub fn fold_refresh_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RefreshOptionValue<T>) -> RefreshOptionValue<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        RefreshOptionValue::OnCommit {
        } => {
            RefreshOptionValue::OnCommit {
            }
        }
        RefreshOptionValue::AtCreation {
        } => {
            RefreshOptionValue::AtCreation {
            }
        }
        RefreshOptionValue::At {
            0: binding0,
        } => {
            RefreshOptionValue::At {
                0: folder.fold_refresh_at_option_value(binding0),
            }
        }
        RefreshOptionValue::Every {
            0: binding0,
        } => {
            RefreshOptionValue::Every {
                0: folder.fold_refresh_every_option_value(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReplicaDefinition<T> {
    type Folded = ReplicaDefinition<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_replica_definition(self)
    }
}
pub fn fold_replica_definition<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReplicaDefinition<T>) -> ReplicaDefinition<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ReplicaDefinition {
        name: folder.fold_ident(node.name),
        options: node.options.into_iter().map(|v| folder.fold_replica_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReplicaOption<T> {
    type Folded = ReplicaOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_replica_option(self)
    }
}
pub fn fold_replica_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReplicaOption<T>) -> ReplicaOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ReplicaOption {
        name: folder.fold_replica_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReplicaOptionName {
    type Folded = ReplicaOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_replica_option_name(self)
    }
}
pub fn fold_replica_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReplicaOptionName) -> ReplicaOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ReplicaOptionName::BilledAs {
        } => {
            ReplicaOptionName::BilledAs {
            }
        }
        ReplicaOptionName::Size {
        } => {
            ReplicaOptionName::Size {
            }
        }
        ReplicaOptionName::AvailabilityZone {
        } => {
            ReplicaOptionName::AvailabilityZone {
            }
        }
        ReplicaOptionName::StorageAddresses {
        } => {
            ReplicaOptionName::StorageAddresses {
            }
        }
        ReplicaOptionName::StoragectlAddresses {
        } => {
            ReplicaOptionName::StoragectlAddresses {
            }
        }
        ReplicaOptionName::ComputectlAddresses {
        } => {
            ReplicaOptionName::ComputectlAddresses {
            }
        }
        ReplicaOptionName::ComputeAddresses {
        } => {
            ReplicaOptionName::ComputeAddresses {
            }
        }
        ReplicaOptionName::Workers {
        } => {
            ReplicaOptionName::Workers {
            }
        }
        ReplicaOptionName::Internal {
        } => {
            ReplicaOptionName::Internal {
            }
        }
        ReplicaOptionName::IntrospectionInterval {
        } => {
            ReplicaOptionName::IntrospectionInterval {
            }
        }
        ReplicaOptionName::IntrospectionDebugging {
        } => {
            ReplicaOptionName::IntrospectionDebugging {
            }
        }
        ReplicaOptionName::Disk {
        } => {
            ReplicaOptionName::Disk {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ResetVariableStatement {
    type Folded = ResetVariableStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_reset_variable_statement(self)
    }
}
pub fn fold_reset_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ResetVariableStatement) -> ResetVariableStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    ResetVariableStatement {
        variable: folder.fold_ident(node.variable),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RevokePrivilegesStatement<T> {
    type Folded = RevokePrivilegesStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_revoke_privileges_statement(self)
    }
}
pub fn fold_revoke_privileges_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RevokePrivilegesStatement<T>) -> RevokePrivilegesStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    RevokePrivilegesStatement {
        privileges: folder.fold_privilege_specification(node.privileges),
        target: folder.fold_grant_target_specification(node.target),
        roles: node.roles.into_iter().map(|v| folder.fold_role_name(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RevokeRoleStatement<T> {
    type Folded = RevokeRoleStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_revoke_role_statement(self)
    }
}
pub fn fold_revoke_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RevokeRoleStatement<T>) -> RevokeRoleStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    RevokeRoleStatement {
        role_names: node.role_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
        member_names: node.member_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RoleAttribute {
    type Folded = RoleAttribute;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_role_attribute(self)
    }
}
pub fn fold_role_attribute<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RoleAttribute) -> RoleAttribute
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        RoleAttribute::Inherit {
        } => {
            RoleAttribute::Inherit {
            }
        }
        RoleAttribute::NoInherit {
        } => {
            RoleAttribute::NoInherit {
            }
        }
        RoleAttribute::Login {
        } => {
            RoleAttribute::Login {
            }
        }
        RoleAttribute::NoLogin {
        } => {
            RoleAttribute::NoLogin {
            }
        }
        RoleAttribute::SuperUser {
        } => {
            RoleAttribute::SuperUser {
            }
        }
        RoleAttribute::NoSuperUser {
        } => {
            RoleAttribute::NoSuperUser {
            }
        }
        RoleAttribute::CreateCluster {
        } => {
            RoleAttribute::CreateCluster {
            }
        }
        RoleAttribute::NoCreateCluster {
        } => {
            RoleAttribute::NoCreateCluster {
            }
        }
        RoleAttribute::CreateDB {
        } => {
            RoleAttribute::CreateDB {
            }
        }
        RoleAttribute::NoCreateDB {
        } => {
            RoleAttribute::NoCreateDB {
            }
        }
        RoleAttribute::CreateRole {
        } => {
            RoleAttribute::CreateRole {
            }
        }
        RoleAttribute::NoCreateRole {
        } => {
            RoleAttribute::NoCreateRole {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RollbackStatement {
    type Folded = RollbackStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_rollback_statement(self)
    }
}
pub fn fold_rollback_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RollbackStatement) -> RollbackStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    RollbackStatement {
        chain: node.chain,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Schema {
    type Folded = Schema;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_schema(self)
    }
}
pub fn fold_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Schema) -> Schema
where
    F: Fold<T, T2, > + ?Sized,
{
    Schema {
        schema: node.schema,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Select<T> {
    type Folded = Select<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_select(self)
    }
}
pub fn fold_select<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Select<T>) -> Select<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Select {
        distinct: node.distinct.map(|v| folder.fold_distinct(v)),
        projection: node.projection.into_iter().map(|v| folder.fold_select_item(v)).collect(),
        from: node.from.into_iter().map(|v| folder.fold_table_with_joins(v)).collect(),
        selection: node.selection.map(|v| folder.fold_expr(v)),
        group_by: node.group_by.into_iter().map(|v| folder.fold_expr(v)).collect(),
        having: node.having.map(|v| folder.fold_expr(v)),
        options: node.options.into_iter().map(|v| folder.fold_select_option(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectItem<T> {
    type Folded = SelectItem<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_select_item(self)
    }
}
pub fn fold_select_item<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectItem<T>) -> SelectItem<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SelectItem::Expr {
            expr: binding0,
            alias: binding1,
        } => {
            SelectItem::Expr {
                expr: folder.fold_expr(binding0),
                alias: binding1.map(|v| folder.fold_ident(v)),
            }
        }
        SelectItem::Wildcard {
        } => {
            SelectItem::Wildcard {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectOption<T> {
    type Folded = SelectOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_select_option(self)
    }
}
pub fn fold_select_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectOption<T>) -> SelectOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    SelectOption {
        name: folder.fold_select_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectOptionName {
    type Folded = SelectOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_select_option_name(self)
    }
}
pub fn fold_select_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectOptionName) -> SelectOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SelectOptionName::ExpectedGroupSize {
        } => {
            SelectOptionName::ExpectedGroupSize {
            }
        }
        SelectOptionName::AggregateInputGroupSize {
        } => {
            SelectOptionName::AggregateInputGroupSize {
            }
        }
        SelectOptionName::DistinctOnInputGroupSize {
        } => {
            SelectOptionName::DistinctOnInputGroupSize {
            }
        }
        SelectOptionName::LimitInputGroupSize {
        } => {
            SelectOptionName::LimitInputGroupSize {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectStatement<T> {
    type Folded = SelectStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_select_statement(self)
    }
}
pub fn fold_select_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectStatement<T>) -> SelectStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    SelectStatement {
        query: folder.fold_query(node.query),
        as_of: node.as_of.map(|v| folder.fold_as_of(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetExpr<T> {
    type Folded = SetExpr<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_expr(self)
    }
}
pub fn fold_set_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetExpr<T>) -> SetExpr<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SetExpr::Select {
            0: binding0,
        } => {
            SetExpr::Select {
                0: Box::new(folder.fold_select(*binding0)),
            }
        }
        SetExpr::Query {
            0: binding0,
        } => {
            SetExpr::Query {
                0: Box::new(folder.fold_query(*binding0)),
            }
        }
        SetExpr::SetOperation {
            op: binding0,
            all: binding1,
            left: binding2,
            right: binding3,
        } => {
            SetExpr::SetOperation {
                op: folder.fold_set_operator(binding0),
                all: binding1,
                left: Box::new(folder.fold_set_expr(*binding2)),
                right: Box::new(folder.fold_set_expr(*binding3)),
            }
        }
        SetExpr::Values {
            0: binding0,
        } => {
            SetExpr::Values {
                0: folder.fold_values(binding0),
            }
        }
        SetExpr::Show {
            0: binding0,
        } => {
            SetExpr::Show {
                0: folder.fold_show_statement(binding0),
            }
        }
        SetExpr::Table {
            0: binding0,
        } => {
            SetExpr::Table {
                0: folder.fold_item_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetOperator {
    type Folded = SetOperator;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_operator(self)
    }
}
pub fn fold_set_operator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetOperator) -> SetOperator
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SetOperator::Union {
        } => {
            SetOperator::Union {
            }
        }
        SetOperator::Except {
        } => {
            SetOperator::Except {
            }
        }
        SetOperator::Intersect {
        } => {
            SetOperator::Intersect {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetRoleVar {
    type Folded = SetRoleVar;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_role_var(self)
    }
}
pub fn fold_set_role_var<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetRoleVar) -> SetRoleVar
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SetRoleVar::Set {
            name: binding0,
            value: binding1,
        } => {
            SetRoleVar::Set {
                name: folder.fold_ident(binding0),
                value: folder.fold_set_variable_to(binding1),
            }
        }
        SetRoleVar::Reset {
            name: binding0,
        } => {
            SetRoleVar::Reset {
                name: folder.fold_ident(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetTransactionStatement {
    type Folded = SetTransactionStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_transaction_statement(self)
    }
}
pub fn fold_set_transaction_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetTransactionStatement) -> SetTransactionStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    SetTransactionStatement {
        local: node.local,
        modes: node.modes.into_iter().map(|v| folder.fold_transaction_mode(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetVariableStatement {
    type Folded = SetVariableStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_variable_statement(self)
    }
}
pub fn fold_set_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableStatement) -> SetVariableStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    SetVariableStatement {
        local: node.local,
        variable: folder.fold_ident(node.variable),
        to: folder.fold_set_variable_to(node.to),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetVariableTo {
    type Folded = SetVariableTo;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_variable_to(self)
    }
}
pub fn fold_set_variable_to<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableTo) -> SetVariableTo
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SetVariableTo::Default {
        } => {
            SetVariableTo::Default {
            }
        }
        SetVariableTo::Values {
            0: binding0,
        } => {
            SetVariableTo::Values {
                0: binding0.into_iter().map(|v| folder.fold_set_variable_value(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetVariableValue {
    type Folded = SetVariableValue;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_set_variable_value(self)
    }
}
pub fn fold_set_variable_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableValue) -> SetVariableValue
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SetVariableValue::Ident {
            0: binding0,
        } => {
            SetVariableValue::Ident {
                0: folder.fold_ident(binding0),
            }
        }
        SetVariableValue::Literal {
            0: binding0,
        } => {
            SetVariableValue::Literal {
                0: folder.fold_value(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowColumnsStatement<T> {
    type Folded = ShowColumnsStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_columns_statement(self)
    }
}
pub fn fold_show_columns_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowColumnsStatement<T>) -> ShowColumnsStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowColumnsStatement {
        table_name: folder.fold_item_name(node.table_name),
        filter: node.filter.map(|v| folder.fold_show_statement_filter(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateClusterStatement<T> {
    type Folded = ShowCreateClusterStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_cluster_statement(self)
    }
}
pub fn fold_show_create_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateClusterStatement<T>) -> ShowCreateClusterStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateClusterStatement {
        cluster_name: folder.fold_cluster_name(node.cluster_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateConnectionStatement<T> {
    type Folded = ShowCreateConnectionStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_connection_statement(self)
    }
}
pub fn fold_show_create_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateConnectionStatement<T>) -> ShowCreateConnectionStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateConnectionStatement {
        connection_name: folder.fold_item_name(node.connection_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateIndexStatement<T> {
    type Folded = ShowCreateIndexStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_index_statement(self)
    }
}
pub fn fold_show_create_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateIndexStatement<T>) -> ShowCreateIndexStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateIndexStatement {
        index_name: folder.fold_item_name(node.index_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateMaterializedViewStatement<T> {
    type Folded = ShowCreateMaterializedViewStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_materialized_view_statement(self)
    }
}
pub fn fold_show_create_materialized_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateMaterializedViewStatement<T>) -> ShowCreateMaterializedViewStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateMaterializedViewStatement {
        materialized_view_name: folder.fold_item_name(node.materialized_view_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateSinkStatement<T> {
    type Folded = ShowCreateSinkStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_sink_statement(self)
    }
}
pub fn fold_show_create_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateSinkStatement<T>) -> ShowCreateSinkStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateSinkStatement {
        sink_name: folder.fold_item_name(node.sink_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateSourceStatement<T> {
    type Folded = ShowCreateSourceStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_source_statement(self)
    }
}
pub fn fold_show_create_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateSourceStatement<T>) -> ShowCreateSourceStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateSourceStatement {
        source_name: folder.fold_item_name(node.source_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateTableStatement<T> {
    type Folded = ShowCreateTableStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_table_statement(self)
    }
}
pub fn fold_show_create_table_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateTableStatement<T>) -> ShowCreateTableStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateTableStatement {
        table_name: folder.fold_item_name(node.table_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateViewStatement<T> {
    type Folded = ShowCreateViewStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_create_view_statement(self)
    }
}
pub fn fold_show_create_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateViewStatement<T>) -> ShowCreateViewStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowCreateViewStatement {
        view_name: folder.fold_item_name(node.view_name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowObjectType<T> {
    type Folded = ShowObjectType<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_object_type(self)
    }
}
pub fn fold_show_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowObjectType<T>) -> ShowObjectType<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ShowObjectType::MaterializedView {
            in_cluster: binding0,
        } => {
            ShowObjectType::MaterializedView {
                in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
            }
        }
        ShowObjectType::Index {
            in_cluster: binding0,
            on_object: binding1,
        } => {
            ShowObjectType::Index {
                in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
                on_object: binding1.map(|v| folder.fold_item_name(v)),
            }
        }
        ShowObjectType::Table {
        } => {
            ShowObjectType::Table {
            }
        }
        ShowObjectType::View {
        } => {
            ShowObjectType::View {
            }
        }
        ShowObjectType::Source {
            in_cluster: binding0,
        } => {
            ShowObjectType::Source {
                in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
            }
        }
        ShowObjectType::Sink {
            in_cluster: binding0,
        } => {
            ShowObjectType::Sink {
                in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
            }
        }
        ShowObjectType::Type {
        } => {
            ShowObjectType::Type {
            }
        }
        ShowObjectType::Role {
        } => {
            ShowObjectType::Role {
            }
        }
        ShowObjectType::Cluster {
        } => {
            ShowObjectType::Cluster {
            }
        }
        ShowObjectType::ClusterReplica {
        } => {
            ShowObjectType::ClusterReplica {
            }
        }
        ShowObjectType::Object {
        } => {
            ShowObjectType::Object {
            }
        }
        ShowObjectType::Secret {
        } => {
            ShowObjectType::Secret {
            }
        }
        ShowObjectType::Connection {
        } => {
            ShowObjectType::Connection {
            }
        }
        ShowObjectType::Database {
        } => {
            ShowObjectType::Database {
            }
        }
        ShowObjectType::Schema {
            from: binding0,
        } => {
            ShowObjectType::Schema {
                from: binding0.map(|v| folder.fold_database_name(v)),
            }
        }
        ShowObjectType::Subsource {
            on_source: binding0,
        } => {
            ShowObjectType::Subsource {
                on_source: binding0.map(|v| folder.fold_item_name(v)),
            }
        }
        ShowObjectType::Privileges {
            object_type: binding0,
            role: binding1,
        } => {
            ShowObjectType::Privileges {
                object_type: binding0.map(|v| folder.fold_system_object_type(v)),
                role: binding1.map(|v| folder.fold_role_name(v)),
            }
        }
        ShowObjectType::DefaultPrivileges {
            object_type: binding0,
            role: binding1,
        } => {
            ShowObjectType::DefaultPrivileges {
                object_type: binding0.map(|v| folder.fold_object_type(v)),
                role: binding1.map(|v| folder.fold_role_name(v)),
            }
        }
        ShowObjectType::RoleMembership {
            role: binding0,
        } => {
            ShowObjectType::RoleMembership {
                role: binding0.map(|v| folder.fold_role_name(v)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowObjectsStatement<T> {
    type Folded = ShowObjectsStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_objects_statement(self)
    }
}
pub fn fold_show_objects_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowObjectsStatement<T>) -> ShowObjectsStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowObjectsStatement {
        object_type: folder.fold_show_object_type(node.object_type),
        from: node.from.map(|v| folder.fold_schema_name(v)),
        filter: node.filter.map(|v| folder.fold_show_statement_filter(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowStatement<T> {
    type Folded = ShowStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_statement(self)
    }
}
pub fn fold_show_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowStatement<T>) -> ShowStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ShowStatement::ShowObjects {
            0: binding0,
        } => {
            ShowStatement::ShowObjects {
                0: folder.fold_show_objects_statement(binding0),
            }
        }
        ShowStatement::ShowColumns {
            0: binding0,
        } => {
            ShowStatement::ShowColumns {
                0: folder.fold_show_columns_statement(binding0),
            }
        }
        ShowStatement::ShowCreateView {
            0: binding0,
        } => {
            ShowStatement::ShowCreateView {
                0: folder.fold_show_create_view_statement(binding0),
            }
        }
        ShowStatement::ShowCreateMaterializedView {
            0: binding0,
        } => {
            ShowStatement::ShowCreateMaterializedView {
                0: folder.fold_show_create_materialized_view_statement(binding0),
            }
        }
        ShowStatement::ShowCreateSource {
            0: binding0,
        } => {
            ShowStatement::ShowCreateSource {
                0: folder.fold_show_create_source_statement(binding0),
            }
        }
        ShowStatement::ShowCreateTable {
            0: binding0,
        } => {
            ShowStatement::ShowCreateTable {
                0: folder.fold_show_create_table_statement(binding0),
            }
        }
        ShowStatement::ShowCreateSink {
            0: binding0,
        } => {
            ShowStatement::ShowCreateSink {
                0: folder.fold_show_create_sink_statement(binding0),
            }
        }
        ShowStatement::ShowCreateIndex {
            0: binding0,
        } => {
            ShowStatement::ShowCreateIndex {
                0: folder.fold_show_create_index_statement(binding0),
            }
        }
        ShowStatement::ShowCreateConnection {
            0: binding0,
        } => {
            ShowStatement::ShowCreateConnection {
                0: folder.fold_show_create_connection_statement(binding0),
            }
        }
        ShowStatement::ShowCreateCluster {
            0: binding0,
        } => {
            ShowStatement::ShowCreateCluster {
                0: folder.fold_show_create_cluster_statement(binding0),
            }
        }
        ShowStatement::ShowVariable {
            0: binding0,
        } => {
            ShowStatement::ShowVariable {
                0: folder.fold_show_variable_statement(binding0),
            }
        }
        ShowStatement::InspectShard {
            0: binding0,
        } => {
            ShowStatement::InspectShard {
                0: folder.fold_inspect_shard_statement(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowStatementFilter<T> {
    type Folded = ShowStatementFilter<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_statement_filter(self)
    }
}
pub fn fold_show_statement_filter<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowStatementFilter<T>) -> ShowStatementFilter<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        ShowStatementFilter::Like {
            0: binding0,
        } => {
            ShowStatementFilter::Like {
                0: binding0,
            }
        }
        ShowStatementFilter::Where {
            0: binding0,
        } => {
            ShowStatementFilter::Where {
                0: folder.fold_expr(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowVariableStatement {
    type Folded = ShowVariableStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_show_variable_statement(self)
    }
}
pub fn fold_show_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowVariableStatement) -> ShowVariableStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    ShowVariableStatement {
        variable: folder.fold_ident(node.variable),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SinkEnvelope {
    type Folded = SinkEnvelope;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_sink_envelope(self)
    }
}
pub fn fold_sink_envelope<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SinkEnvelope) -> SinkEnvelope
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SinkEnvelope::Debezium {
        } => {
            SinkEnvelope::Debezium {
            }
        }
        SinkEnvelope::Upsert {
        } => {
            SinkEnvelope::Upsert {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SourceEnvelope {
    type Folded = SourceEnvelope;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_source_envelope(self)
    }
}
pub fn fold_source_envelope<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SourceEnvelope) -> SourceEnvelope
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SourceEnvelope::None {
        } => {
            SourceEnvelope::None {
            }
        }
        SourceEnvelope::Debezium {
        } => {
            SourceEnvelope::Debezium {
            }
        }
        SourceEnvelope::Upsert {
            value_decode_err_policy: binding0,
        } => {
            SourceEnvelope::Upsert {
                value_decode_err_policy: binding0.into_iter().map(|v| folder.fold_source_error_policy(v)).collect(),
            }
        }
        SourceEnvelope::CdcV2 {
        } => {
            SourceEnvelope::CdcV2 {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SourceErrorPolicy {
    type Folded = SourceErrorPolicy;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_source_error_policy(self)
    }
}
pub fn fold_source_error_policy<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SourceErrorPolicy) -> SourceErrorPolicy
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SourceErrorPolicy::Inline {
            alias: binding0,
        } => {
            SourceErrorPolicy::Inline {
                alias: binding0.map(|v| folder.fold_ident(v)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SourceIncludeMetadata {
    type Folded = SourceIncludeMetadata;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_source_include_metadata(self)
    }
}
pub fn fold_source_include_metadata<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SourceIncludeMetadata) -> SourceIncludeMetadata
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SourceIncludeMetadata::Key {
            alias: binding0,
        } => {
            SourceIncludeMetadata::Key {
                alias: binding0.map(|v| folder.fold_ident(v)),
            }
        }
        SourceIncludeMetadata::Timestamp {
            alias: binding0,
        } => {
            SourceIncludeMetadata::Timestamp {
                alias: binding0.map(|v| folder.fold_ident(v)),
            }
        }
        SourceIncludeMetadata::Partition {
            alias: binding0,
        } => {
            SourceIncludeMetadata::Partition {
                alias: binding0.map(|v| folder.fold_ident(v)),
            }
        }
        SourceIncludeMetadata::Offset {
            alias: binding0,
        } => {
            SourceIncludeMetadata::Offset {
                alias: binding0.map(|v| folder.fold_ident(v)),
            }
        }
        SourceIncludeMetadata::Headers {
            alias: binding0,
        } => {
            SourceIncludeMetadata::Headers {
                alias: binding0.map(|v| folder.fold_ident(v)),
            }
        }
        SourceIncludeMetadata::Header {
            key: binding0,
            alias: binding1,
            use_bytes: binding2,
        } => {
            SourceIncludeMetadata::Header {
                key: binding0,
                alias: folder.fold_ident(binding1),
                use_bytes: binding2,
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for StartTransactionStatement {
    type Folded = StartTransactionStatement;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_start_transaction_statement(self)
    }
}
pub fn fold_start_transaction_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: StartTransactionStatement) -> StartTransactionStatement
where
    F: Fold<T, T2, > + ?Sized,
{
    StartTransactionStatement {
        modes: node.modes.into_iter().map(|v| folder.fold_transaction_mode(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Statement<T> {
    type Folded = Statement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_statement(self)
    }
}
pub fn fold_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Statement<T>) -> Statement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Statement::Select {
            0: binding0,
        } => {
            Statement::Select {
                0: folder.fold_select_statement(binding0),
            }
        }
        Statement::Insert {
            0: binding0,
        } => {
            Statement::Insert {
                0: folder.fold_insert_statement(binding0),
            }
        }
        Statement::Copy {
            0: binding0,
        } => {
            Statement::Copy {
                0: folder.fold_copy_statement(binding0),
            }
        }
        Statement::Update {
            0: binding0,
        } => {
            Statement::Update {
                0: folder.fold_update_statement(binding0),
            }
        }
        Statement::Delete {
            0: binding0,
        } => {
            Statement::Delete {
                0: folder.fold_delete_statement(binding0),
            }
        }
        Statement::CreateConnection {
            0: binding0,
        } => {
            Statement::CreateConnection {
                0: folder.fold_create_connection_statement(binding0),
            }
        }
        Statement::CreateDatabase {
            0: binding0,
        } => {
            Statement::CreateDatabase {
                0: folder.fold_create_database_statement(binding0),
            }
        }
        Statement::CreateSchema {
            0: binding0,
        } => {
            Statement::CreateSchema {
                0: folder.fold_create_schema_statement(binding0),
            }
        }
        Statement::CreateWebhookSource {
            0: binding0,
        } => {
            Statement::CreateWebhookSource {
                0: folder.fold_create_webhook_source_statement(binding0),
            }
        }
        Statement::CreateSource {
            0: binding0,
        } => {
            Statement::CreateSource {
                0: folder.fold_create_source_statement(binding0),
            }
        }
        Statement::CreateSubsource {
            0: binding0,
        } => {
            Statement::CreateSubsource {
                0: folder.fold_create_subsource_statement(binding0),
            }
        }
        Statement::CreateSink {
            0: binding0,
        } => {
            Statement::CreateSink {
                0: folder.fold_create_sink_statement(binding0),
            }
        }
        Statement::CreateView {
            0: binding0,
        } => {
            Statement::CreateView {
                0: folder.fold_create_view_statement(binding0),
            }
        }
        Statement::CreateMaterializedView {
            0: binding0,
        } => {
            Statement::CreateMaterializedView {
                0: folder.fold_create_materialized_view_statement(binding0),
            }
        }
        Statement::CreateTable {
            0: binding0,
        } => {
            Statement::CreateTable {
                0: folder.fold_create_table_statement(binding0),
            }
        }
        Statement::CreateTableFromSource {
            0: binding0,
        } => {
            Statement::CreateTableFromSource {
                0: folder.fold_create_table_from_source_statement(binding0),
            }
        }
        Statement::CreateIndex {
            0: binding0,
        } => {
            Statement::CreateIndex {
                0: folder.fold_create_index_statement(binding0),
            }
        }
        Statement::CreateType {
            0: binding0,
        } => {
            Statement::CreateType {
                0: folder.fold_create_type_statement(binding0),
            }
        }
        Statement::CreateRole {
            0: binding0,
        } => {
            Statement::CreateRole {
                0: folder.fold_create_role_statement(binding0),
            }
        }
        Statement::CreateCluster {
            0: binding0,
        } => {
            Statement::CreateCluster {
                0: folder.fold_create_cluster_statement(binding0),
            }
        }
        Statement::CreateClusterReplica {
            0: binding0,
        } => {
            Statement::CreateClusterReplica {
                0: folder.fold_create_cluster_replica_statement(binding0),
            }
        }
        Statement::CreateSecret {
            0: binding0,
        } => {
            Statement::CreateSecret {
                0: folder.fold_create_secret_statement(binding0),
            }
        }
        Statement::AlterCluster {
            0: binding0,
        } => {
            Statement::AlterCluster {
                0: folder.fold_alter_cluster_statement(binding0),
            }
        }
        Statement::AlterOwner {
            0: binding0,
        } => {
            Statement::AlterOwner {
                0: folder.fold_alter_owner_statement(binding0),
            }
        }
        Statement::AlterObjectRename {
            0: binding0,
        } => {
            Statement::AlterObjectRename {
                0: folder.fold_alter_object_rename_statement(binding0),
            }
        }
        Statement::AlterObjectSwap {
            0: binding0,
        } => {
            Statement::AlterObjectSwap {
                0: folder.fold_alter_object_swap_statement(binding0),
            }
        }
        Statement::AlterRetainHistory {
            0: binding0,
        } => {
            Statement::AlterRetainHistory {
                0: folder.fold_alter_retain_history_statement(binding0),
            }
        }
        Statement::AlterIndex {
            0: binding0,
        } => {
            Statement::AlterIndex {
                0: folder.fold_alter_index_statement(binding0),
            }
        }
        Statement::AlterSecret {
            0: binding0,
        } => {
            Statement::AlterSecret {
                0: folder.fold_alter_secret_statement(binding0),
            }
        }
        Statement::AlterSetCluster {
            0: binding0,
        } => {
            Statement::AlterSetCluster {
                0: folder.fold_alter_set_cluster_statement(binding0),
            }
        }
        Statement::AlterSink {
            0: binding0,
        } => {
            Statement::AlterSink {
                0: folder.fold_alter_sink_statement(binding0),
            }
        }
        Statement::AlterSource {
            0: binding0,
        } => {
            Statement::AlterSource {
                0: folder.fold_alter_source_statement(binding0),
            }
        }
        Statement::AlterSystemSet {
            0: binding0,
        } => {
            Statement::AlterSystemSet {
                0: folder.fold_alter_system_set_statement(binding0),
            }
        }
        Statement::AlterSystemReset {
            0: binding0,
        } => {
            Statement::AlterSystemReset {
                0: folder.fold_alter_system_reset_statement(binding0),
            }
        }
        Statement::AlterSystemResetAll {
            0: binding0,
        } => {
            Statement::AlterSystemResetAll {
                0: folder.fold_alter_system_reset_all_statement(binding0),
            }
        }
        Statement::AlterConnection {
            0: binding0,
        } => {
            Statement::AlterConnection {
                0: folder.fold_alter_connection_statement(binding0),
            }
        }
        Statement::AlterRole {
            0: binding0,
        } => {
            Statement::AlterRole {
                0: folder.fold_alter_role_statement(binding0),
            }
        }
        Statement::AlterTableAddColumn {
            0: binding0,
        } => {
            Statement::AlterTableAddColumn {
                0: folder.fold_alter_table_add_column_statement(binding0),
            }
        }
        Statement::Discard {
            0: binding0,
        } => {
            Statement::Discard {
                0: folder.fold_discard_statement(binding0),
            }
        }
        Statement::DropObjects {
            0: binding0,
        } => {
            Statement::DropObjects {
                0: folder.fold_drop_objects_statement(binding0),
            }
        }
        Statement::DropOwned {
            0: binding0,
        } => {
            Statement::DropOwned {
                0: folder.fold_drop_owned_statement(binding0),
            }
        }
        Statement::SetVariable {
            0: binding0,
        } => {
            Statement::SetVariable {
                0: folder.fold_set_variable_statement(binding0),
            }
        }
        Statement::ResetVariable {
            0: binding0,
        } => {
            Statement::ResetVariable {
                0: folder.fold_reset_variable_statement(binding0),
            }
        }
        Statement::Show {
            0: binding0,
        } => {
            Statement::Show {
                0: folder.fold_show_statement(binding0),
            }
        }
        Statement::StartTransaction {
            0: binding0,
        } => {
            Statement::StartTransaction {
                0: folder.fold_start_transaction_statement(binding0),
            }
        }
        Statement::SetTransaction {
            0: binding0,
        } => {
            Statement::SetTransaction {
                0: folder.fold_set_transaction_statement(binding0),
            }
        }
        Statement::Commit {
            0: binding0,
        } => {
            Statement::Commit {
                0: folder.fold_commit_statement(binding0),
            }
        }
        Statement::Rollback {
            0: binding0,
        } => {
            Statement::Rollback {
                0: folder.fold_rollback_statement(binding0),
            }
        }
        Statement::Subscribe {
            0: binding0,
        } => {
            Statement::Subscribe {
                0: folder.fold_subscribe_statement(binding0),
            }
        }
        Statement::ExplainPlan {
            0: binding0,
        } => {
            Statement::ExplainPlan {
                0: folder.fold_explain_plan_statement(binding0),
            }
        }
        Statement::ExplainPushdown {
            0: binding0,
        } => {
            Statement::ExplainPushdown {
                0: folder.fold_explain_pushdown_statement(binding0),
            }
        }
        Statement::ExplainTimestamp {
            0: binding0,
        } => {
            Statement::ExplainTimestamp {
                0: folder.fold_explain_timestamp_statement(binding0),
            }
        }
        Statement::ExplainSinkSchema {
            0: binding0,
        } => {
            Statement::ExplainSinkSchema {
                0: folder.fold_explain_sink_schema_statement(binding0),
            }
        }
        Statement::Declare {
            0: binding0,
        } => {
            Statement::Declare {
                0: folder.fold_declare_statement(binding0),
            }
        }
        Statement::Fetch {
            0: binding0,
        } => {
            Statement::Fetch {
                0: folder.fold_fetch_statement(binding0),
            }
        }
        Statement::Close {
            0: binding0,
        } => {
            Statement::Close {
                0: folder.fold_close_statement(binding0),
            }
        }
        Statement::Prepare {
            0: binding0,
        } => {
            Statement::Prepare {
                0: folder.fold_prepare_statement(binding0),
            }
        }
        Statement::Execute {
            0: binding0,
        } => {
            Statement::Execute {
                0: folder.fold_execute_statement(binding0),
            }
        }
        Statement::Deallocate {
            0: binding0,
        } => {
            Statement::Deallocate {
                0: folder.fold_deallocate_statement(binding0),
            }
        }
        Statement::Raise {
            0: binding0,
        } => {
            Statement::Raise {
                0: folder.fold_raise_statement(binding0),
            }
        }
        Statement::GrantRole {
            0: binding0,
        } => {
            Statement::GrantRole {
                0: folder.fold_grant_role_statement(binding0),
            }
        }
        Statement::RevokeRole {
            0: binding0,
        } => {
            Statement::RevokeRole {
                0: folder.fold_revoke_role_statement(binding0),
            }
        }
        Statement::GrantPrivileges {
            0: binding0,
        } => {
            Statement::GrantPrivileges {
                0: folder.fold_grant_privileges_statement(binding0),
            }
        }
        Statement::RevokePrivileges {
            0: binding0,
        } => {
            Statement::RevokePrivileges {
                0: folder.fold_revoke_privileges_statement(binding0),
            }
        }
        Statement::AlterDefaultPrivileges {
            0: binding0,
        } => {
            Statement::AlterDefaultPrivileges {
                0: folder.fold_alter_default_privileges_statement(binding0),
            }
        }
        Statement::ReassignOwned {
            0: binding0,
        } => {
            Statement::ReassignOwned {
                0: folder.fold_reassign_owned_statement(binding0),
            }
        }
        Statement::ValidateConnection {
            0: binding0,
        } => {
            Statement::ValidateConnection {
                0: folder.fold_validate_connection_statement(binding0),
            }
        }
        Statement::Comment {
            0: binding0,
        } => {
            Statement::Comment {
                0: folder.fold_comment_statement(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeOption<T> {
    type Folded = SubscribeOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_subscribe_option(self)
    }
}
pub fn fold_subscribe_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeOption<T>) -> SubscribeOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    SubscribeOption {
        name: folder.fold_subscribe_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeOptionName {
    type Folded = SubscribeOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_subscribe_option_name(self)
    }
}
pub fn fold_subscribe_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeOptionName) -> SubscribeOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SubscribeOptionName::Snapshot {
        } => {
            SubscribeOptionName::Snapshot {
            }
        }
        SubscribeOptionName::Progress {
        } => {
            SubscribeOptionName::Progress {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeOutput<T> {
    type Folded = SubscribeOutput<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_subscribe_output(self)
    }
}
pub fn fold_subscribe_output<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeOutput<T>) -> SubscribeOutput<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SubscribeOutput::Diffs {
        } => {
            SubscribeOutput::Diffs {
            }
        }
        SubscribeOutput::WithinTimestampOrderBy {
            order_by: binding0,
        } => {
            SubscribeOutput::WithinTimestampOrderBy {
                order_by: binding0.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
            }
        }
        SubscribeOutput::EnvelopeUpsert {
            key_columns: binding0,
        } => {
            SubscribeOutput::EnvelopeUpsert {
                key_columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        SubscribeOutput::EnvelopeDebezium {
            key_columns: binding0,
        } => {
            SubscribeOutput::EnvelopeDebezium {
                key_columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeRelation<T> {
    type Folded = SubscribeRelation<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_subscribe_relation(self)
    }
}
pub fn fold_subscribe_relation<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeRelation<T>) -> SubscribeRelation<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SubscribeRelation::Name {
            0: binding0,
        } => {
            SubscribeRelation::Name {
                0: folder.fold_item_name(binding0),
            }
        }
        SubscribeRelation::Query {
            0: binding0,
        } => {
            SubscribeRelation::Query {
                0: folder.fold_query(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeStatement<T> {
    type Folded = SubscribeStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_subscribe_statement(self)
    }
}
pub fn fold_subscribe_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeStatement<T>) -> SubscribeStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    SubscribeStatement {
        relation: folder.fold_subscribe_relation(node.relation),
        options: node.options.into_iter().map(|v| folder.fold_subscribe_option(v)).collect(),
        as_of: node.as_of.map(|v| folder.fold_as_of(v)),
        up_to: node.up_to.map(|v| folder.fold_expr(v)),
        output: folder.fold_subscribe_output(node.output),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscriptPosition<T> {
    type Folded = SubscriptPosition<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_subscript_position(self)
    }
}
pub fn fold_subscript_position<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscriptPosition<T>) -> SubscriptPosition<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    SubscriptPosition {
        start: node.start.map(|v| folder.fold_expr(v)),
        end: node.end.map(|v| folder.fold_expr(v)),
        explicit_slice: node.explicit_slice,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SystemObjectType {
    type Folded = SystemObjectType;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_system_object_type(self)
    }
}
pub fn fold_system_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SystemObjectType) -> SystemObjectType
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        SystemObjectType::System {
        } => {
            SystemObjectType::System {
            }
        }
        SystemObjectType::Object {
            0: binding0,
        } => {
            SystemObjectType::Object {
                0: folder.fold_object_type(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableAlias {
    type Folded = TableAlias;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_table_alias(self)
    }
}
pub fn fold_table_alias<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableAlias) -> TableAlias
where
    F: Fold<T, T2, > + ?Sized,
{
    TableAlias {
        name: folder.fold_ident(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
        strict: node.strict,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableConstraint<T> {
    type Folded = TableConstraint<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_table_constraint(self)
    }
}
pub fn fold_table_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableConstraint<T>) -> TableConstraint<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TableConstraint::Unique {
            name: binding0,
            columns: binding1,
            is_primary: binding2,
            nulls_not_distinct: binding3,
        } => {
            TableConstraint::Unique {
                name: binding0.map(|v| folder.fold_ident(v)),
                columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
                is_primary: binding2,
                nulls_not_distinct: binding3,
            }
        }
        TableConstraint::ForeignKey {
            name: binding0,
            columns: binding1,
            foreign_table: binding2,
            referred_columns: binding3,
        } => {
            TableConstraint::ForeignKey {
                name: binding0.map(|v| folder.fold_ident(v)),
                columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
                foreign_table: folder.fold_item_name(binding2),
                referred_columns: binding3.into_iter().map(|v| folder.fold_ident(v)).collect(),
            }
        }
        TableConstraint::Check {
            name: binding0,
            expr: binding1,
        } => {
            TableConstraint::Check {
                name: binding0.map(|v| folder.fold_ident(v)),
                expr: Box::new(folder.fold_expr(*binding1)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableFactor<T> {
    type Folded = TableFactor<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_table_factor(self)
    }
}
pub fn fold_table_factor<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableFactor<T>) -> TableFactor<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TableFactor::Table {
            name: binding0,
            alias: binding1,
        } => {
            TableFactor::Table {
                name: folder.fold_item_name(binding0),
                alias: binding1.map(|v| folder.fold_table_alias(v)),
            }
        }
        TableFactor::Function {
            function: binding0,
            alias: binding1,
            with_ordinality: binding2,
        } => {
            TableFactor::Function {
                function: folder.fold_function(binding0),
                alias: binding1.map(|v| folder.fold_table_alias(v)),
                with_ordinality: binding2,
            }
        }
        TableFactor::RowsFrom {
            functions: binding0,
            alias: binding1,
            with_ordinality: binding2,
        } => {
            TableFactor::RowsFrom {
                functions: binding0.into_iter().map(|v| folder.fold_function(v)).collect(),
                alias: binding1.map(|v| folder.fold_table_alias(v)),
                with_ordinality: binding2,
            }
        }
        TableFactor::Derived {
            lateral: binding0,
            subquery: binding1,
            alias: binding2,
        } => {
            TableFactor::Derived {
                lateral: binding0,
                subquery: Box::new(folder.fold_query(*binding1)),
                alias: binding2.map(|v| folder.fold_table_alias(v)),
            }
        }
        TableFactor::NestedJoin {
            join: binding0,
            alias: binding1,
        } => {
            TableFactor::NestedJoin {
                join: Box::new(folder.fold_table_with_joins(*binding0)),
                alias: binding1.map(|v| folder.fold_table_alias(v)),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableOption<T> {
    type Folded = TableOption<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_table_option(self)
    }
}
pub fn fold_table_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableOption<T>) -> TableOption<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    TableOption {
        name: folder.fold_table_option_name(node.name),
        value: node.value.map(|v| folder.fold_with_option_value(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableOptionName {
    type Folded = TableOptionName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_table_option_name(self)
    }
}
pub fn fold_table_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableOptionName) -> TableOptionName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TableOptionName::RetainHistory {
        } => {
            TableOptionName::RetainHistory {
            }
        }
        TableOptionName::RedactedTest {
        } => {
            TableOptionName::RedactedTest {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableWithJoins<T> {
    type Folded = TableWithJoins<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_table_with_joins(self)
    }
}
pub fn fold_table_with_joins<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableWithJoins<T>) -> TableWithJoins<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    TableWithJoins {
        relation: folder.fold_table_factor(node.relation),
        joins: node.joins.into_iter().map(|v| folder.fold_join(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TargetRoleSpecification<T> {
    type Folded = TargetRoleSpecification<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_target_role_specification(self)
    }
}
pub fn fold_target_role_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TargetRoleSpecification<T>) -> TargetRoleSpecification<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TargetRoleSpecification::Roles {
            0: binding0,
        } => {
            TargetRoleSpecification::Roles {
                0: binding0.into_iter().map(|v| folder.fold_role_name(v)).collect(),
            }
        }
        TargetRoleSpecification::AllRoles {
        } => {
            TargetRoleSpecification::AllRoles {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TransactionAccessMode {
    type Folded = TransactionAccessMode;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_transaction_access_mode(self)
    }
}
pub fn fold_transaction_access_mode<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionAccessMode) -> TransactionAccessMode
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TransactionAccessMode::ReadOnly {
        } => {
            TransactionAccessMode::ReadOnly {
            }
        }
        TransactionAccessMode::ReadWrite {
        } => {
            TransactionAccessMode::ReadWrite {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TransactionIsolationLevel {
    type Folded = TransactionIsolationLevel;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_transaction_isolation_level(self)
    }
}
pub fn fold_transaction_isolation_level<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionIsolationLevel) -> TransactionIsolationLevel
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TransactionIsolationLevel::ReadUncommitted {
        } => {
            TransactionIsolationLevel::ReadUncommitted {
            }
        }
        TransactionIsolationLevel::ReadCommitted {
        } => {
            TransactionIsolationLevel::ReadCommitted {
            }
        }
        TransactionIsolationLevel::RepeatableRead {
        } => {
            TransactionIsolationLevel::RepeatableRead {
            }
        }
        TransactionIsolationLevel::Serializable {
        } => {
            TransactionIsolationLevel::Serializable {
            }
        }
        TransactionIsolationLevel::StrongSessionSerializable {
        } => {
            TransactionIsolationLevel::StrongSessionSerializable {
            }
        }
        TransactionIsolationLevel::StrictSerializable {
        } => {
            TransactionIsolationLevel::StrictSerializable {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TransactionMode {
    type Folded = TransactionMode;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_transaction_mode(self)
    }
}
pub fn fold_transaction_mode<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionMode) -> TransactionMode
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        TransactionMode::AccessMode {
            0: binding0,
        } => {
            TransactionMode::AccessMode {
                0: folder.fold_transaction_access_mode(binding0),
            }
        }
        TransactionMode::IsolationLevel {
            0: binding0,
        } => {
            TransactionMode::IsolationLevel {
                0: folder.fold_transaction_isolation_level(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedDatabaseName {
    type Folded = UnresolvedDatabaseName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_unresolved_database_name(self)
    }
}
pub fn fold_unresolved_database_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedDatabaseName) -> UnresolvedDatabaseName
where
    F: Fold<T, T2, > + ?Sized,
{
    UnresolvedDatabaseName {
        0: folder.fold_ident(node.0),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedItemName {
    type Folded = UnresolvedItemName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_unresolved_item_name(self)
    }
}
pub fn fold_unresolved_item_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedItemName) -> UnresolvedItemName
where
    F: Fold<T, T2, > + ?Sized,
{
    UnresolvedItemName {
        0: node.0.into_iter().map(|v| folder.fold_ident(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedObjectName {
    type Folded = UnresolvedObjectName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_unresolved_object_name(self)
    }
}
pub fn fold_unresolved_object_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedObjectName) -> UnresolvedObjectName
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        UnresolvedObjectName::Cluster {
            0: binding0,
        } => {
            UnresolvedObjectName::Cluster {
                0: folder.fold_ident(binding0),
            }
        }
        UnresolvedObjectName::ClusterReplica {
            0: binding0,
        } => {
            UnresolvedObjectName::ClusterReplica {
                0: folder.fold_qualified_replica(binding0),
            }
        }
        UnresolvedObjectName::Database {
            0: binding0,
        } => {
            UnresolvedObjectName::Database {
                0: folder.fold_unresolved_database_name(binding0),
            }
        }
        UnresolvedObjectName::Schema {
            0: binding0,
        } => {
            UnresolvedObjectName::Schema {
                0: folder.fold_unresolved_schema_name(binding0),
            }
        }
        UnresolvedObjectName::Role {
            0: binding0,
        } => {
            UnresolvedObjectName::Role {
                0: folder.fold_ident(binding0),
            }
        }
        UnresolvedObjectName::Item {
            0: binding0,
        } => {
            UnresolvedObjectName::Item {
                0: folder.fold_unresolved_item_name(binding0),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedSchemaName {
    type Folded = UnresolvedSchemaName;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_unresolved_schema_name(self)
    }
}
pub fn fold_unresolved_schema_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedSchemaName) -> UnresolvedSchemaName
where
    F: Fold<T, T2, > + ?Sized,
{
    UnresolvedSchemaName {
        0: node.0.into_iter().map(|v| folder.fold_ident(v)).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UpdateStatement<T> {
    type Folded = UpdateStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_update_statement(self)
    }
}
pub fn fold_update_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UpdateStatement<T>) -> UpdateStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    UpdateStatement {
        table_name: folder.fold_item_name(node.table_name),
        alias: node.alias.map(|v| folder.fold_table_alias(v)),
        assignments: node.assignments.into_iter().map(|v| folder.fold_assignment(v)).collect(),
        selection: node.selection.map(|v| folder.fold_expr(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ValidateConnectionStatement<T> {
    type Folded = ValidateConnectionStatement<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_validate_connection_statement(self)
    }
}
pub fn fold_validate_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ValidateConnectionStatement<T>) -> ValidateConnectionStatement<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ValidateConnectionStatement {
        name: folder.fold_item_name(node.name),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Value {
    type Folded = Value;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_value(self)
    }
}
pub fn fold_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Value) -> Value
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        Value::Number {
            0: binding0,
        } => {
            Value::Number {
                0: binding0,
            }
        }
        Value::String {
            0: binding0,
        } => {
            Value::String {
                0: binding0,
            }
        }
        Value::HexString {
            0: binding0,
        } => {
            Value::HexString {
                0: binding0,
            }
        }
        Value::Boolean {
            0: binding0,
        } => {
            Value::Boolean {
                0: binding0,
            }
        }
        Value::Interval {
            0: binding0,
        } => {
            Value::Interval {
                0: folder.fold_interval_value(binding0),
            }
        }
        Value::Null {
        } => {
            Value::Null {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ValueError {
    type Folded = ValueError;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_value_error(self)
    }
}
pub fn fold_value_error<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ValueError) -> ValueError
where
    F: Fold<T, T2, > + ?Sized,
{
    ValueError {
        0: node.0,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Values<T> {
    type Folded = Values<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_values(self)
    }
}
pub fn fold_values<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Values<T>) -> Values<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    Values {
        0: node.0.into_iter().map(|v| v.into_iter().map(|v| folder.fold_expr(v)).collect()).collect(),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ViewDefinition<T> {
    type Folded = ViewDefinition<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_view_definition(self)
    }
}
pub fn fold_view_definition<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ViewDefinition<T>) -> ViewDefinition<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    ViewDefinition {
        name: folder.fold_unresolved_item_name(node.name),
        columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
        query: folder.fold_query(node.query),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowFrame {
    type Folded = WindowFrame;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_window_frame(self)
    }
}
pub fn fold_window_frame<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrame) -> WindowFrame
where
    F: Fold<T, T2, > + ?Sized,
{
    WindowFrame {
        units: folder.fold_window_frame_units(node.units),
        start_bound: folder.fold_window_frame_bound(node.start_bound),
        end_bound: node.end_bound.map(|v| folder.fold_window_frame_bound(v)),
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowFrameBound {
    type Folded = WindowFrameBound;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_window_frame_bound(self)
    }
}
pub fn fold_window_frame_bound<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrameBound) -> WindowFrameBound
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        WindowFrameBound::CurrentRow {
        } => {
            WindowFrameBound::CurrentRow {
            }
        }
        WindowFrameBound::Preceding {
            0: binding0,
        } => {
            WindowFrameBound::Preceding {
                0: binding0.map(|v| v),
            }
        }
        WindowFrameBound::Following {
            0: binding0,
        } => {
            WindowFrameBound::Following {
                0: binding0.map(|v| v),
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowFrameUnits {
    type Folded = WindowFrameUnits;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_window_frame_units(self)
    }
}
pub fn fold_window_frame_units<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrameUnits) -> WindowFrameUnits
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        WindowFrameUnits::Rows {
        } => {
            WindowFrameUnits::Rows {
            }
        }
        WindowFrameUnits::Range {
        } => {
            WindowFrameUnits::Range {
            }
        }
        WindowFrameUnits::Groups {
        } => {
            WindowFrameUnits::Groups {
            }
        }
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowSpec<T> {
    type Folded = WindowSpec<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_window_spec(self)
    }
}
pub fn fold_window_spec<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowSpec<T>) -> WindowSpec<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    WindowSpec {
        partition_by: node.partition_by.into_iter().map(|v| folder.fold_expr(v)).collect(),
        order_by: node.order_by.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
        window_frame: node.window_frame.map(|v| folder.fold_window_frame(v)),
        ignore_nulls: node.ignore_nulls,
        respect_nulls: node.respect_nulls,
    }
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WithOptionValue<T> {
    type Folded = WithOptionValue<T2>;
    fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
        folder.fold_with_option_value(self)
    }
}
pub fn fold_with_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WithOptionValue<T>) -> WithOptionValue<T2>
where
    F: Fold<T, T2, > + ?Sized,
{
    match node {
        WithOptionValue::Value {
            0: binding0,
        } => {
            WithOptionValue::Value {
                0: folder.fold_value(binding0),
            }
        }
        WithOptionValue::DataType {
            0: binding0,
        } => {
            WithOptionValue::DataType {
                0: folder.fold_data_type(binding0),
            }
        }
        WithOptionValue::Secret {
            0: binding0,
        } => {
            WithOptionValue::Secret {
                0: folder.fold_item_name(binding0),
            }
        }
        WithOptionValue::Item {
            0: binding0,
        } => {
            WithOptionValue::Item {
                0: folder.fold_item_name(binding0),
            }
        }
        WithOptionValue::UnresolvedItemName {
            0: binding0,
        } => {
            WithOptionValue::UnresolvedItemName {
                0: folder.fold_unresolved_item_name(binding0),
            }
        }
        WithOptionValue::Ident {
            0: binding0,
        } => {
            WithOptionValue::Ident {
                0: folder.fold_ident(binding0),
            }
        }
        WithOptionValue::Sequence {
            0: binding0,
        } => {
            WithOptionValue::Sequence {
                0: binding0.into_iter().map(|v| folder.fold_with_option_value(v)).collect(),
            }
        }
        WithOptionValue::Map {
            0: binding0,
        } => {
            WithOptionValue::Map {
                0: { std::collections::BTreeMap::from_iter(binding0.into_iter().map(|(k, v)| {(k.to_owned(), folder.fold_with_option_value(v).to_owned()) }) )},
            }
        }
        WithOptionValue::ClusterReplicas {
            0: binding0,
        } => {
            WithOptionValue::ClusterReplicas {
                0: binding0.into_iter().map(|v| folder.fold_replica_definition(v)).collect(),
            }
        }
        WithOptionValue::ConnectionKafkaBroker {
            0: binding0,
        } => {
            WithOptionValue::ConnectionKafkaBroker {
                0: folder.fold_kafka_broker(binding0),
            }
        }
        WithOptionValue::ConnectionAwsPrivatelink {
            0: binding0,
        } => {
            WithOptionValue::ConnectionAwsPrivatelink {
                0: folder.fold_connection_default_aws_privatelink(binding0),
            }
        }
        WithOptionValue::RetainHistoryFor {
            0: binding0,
        } => {
            WithOptionValue::RetainHistoryFor {
                0: folder.fold_value(binding0),
            }
        }
        WithOptionValue::Refresh {
            0: binding0,
        } => {
            WithOptionValue::Refresh {
                0: folder.fold_refresh_option_value(binding0),
            }
        }
        WithOptionValue::ClusterScheduleOptionValue {
            0: binding0,
        } => {
            WithOptionValue::ClusterScheduleOptionValue {
                0: folder.fold_cluster_schedule_option_value(binding0),
            }
        }
        WithOptionValue::ClusterAlterStrategy {
            0: binding0,
        } => {
            WithOptionValue::ClusterAlterStrategy {
                0: folder.fold_cluster_alter_option_value(binding0),
            }
        }
    }
}