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_source_subsource(&mut self, node: CreateSourceSubsource) -> CreateSourceSubsource {
fold_create_source_subsource(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_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_referenced_subsources(&mut self, node: ReferencedSubsources) -> ReferencedSubsources {
fold_referenced_subsources(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 {
subsources: binding0,
options: binding1,
} => {
AlterSourceAction::AddSubsources {
subsources: binding0.into_iter().map(|v| folder.fold_create_source_subsource(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 {
}
}
}
}
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::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 {
}
}
}
}
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(),
referenced_subsources: node.referenced_subsources.map(|v| folder.fold_referenced_subsources(v)),
progress_subsource: node.progress_subsource.map(|v| folder.fold_deferred_item_name(v)),
}
}
impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceSubsource {
type Folded = CreateSourceSubsource;
fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
folder.fold_create_source_subsource(self)
}
}
pub fn fold_create_source_subsource<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceSubsource) -> CreateSourceSubsource
where
F: Fold<T, T2, > + ?Sized,
{
CreateSourceSubsource {
reference: folder.fold_unresolved_item_name(node.reference),
subsource: node.subsource.map(|v| folder.fold_unresolved_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 {
}
}
}
}
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 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::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::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 ReferencedSubsources {
type Folded = ReferencedSubsources;
fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
folder.fold_referenced_subsources(self)
}
}
pub fn fold_referenced_subsources<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReferencedSubsources) -> ReferencedSubsources
where
F: Fold<T, T2, > + ?Sized,
{
match node {
ReferencedSubsources::SubsetTables {
0: binding0,
} => {
ReferencedSubsources::SubsetTables {
0: binding0.into_iter().map(|v| folder.fold_create_source_subsource(v)).collect(),
}
}
ReferencedSubsources::SubsetSchemas {
0: binding0,
} => {
ReferencedSubsources::SubsetSchemas {
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
}
}
ReferencedSubsources::All {
} => {
ReferencedSubsources::All {
}
}
}
}
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::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),
}
}
}
}