mz_sql_parser/mnt/build/debug/build/mz-sql-parser-7203726a42a9e8e4/out/

visit_mut.rs

pub trait VisitMut<'ast, T: AstInfo, > {
    fn visit_abbreviated_grant_or_revoke_statement_mut(&mut self, node: &'ast mut AbbreviatedGrantOrRevokeStatement<T>) {
        visit_abbreviated_grant_or_revoke_statement_mut(self, node)
    }
    fn visit_abbreviated_grant_statement_mut(&mut self, node: &'ast mut AbbreviatedGrantStatement<T>) {
        visit_abbreviated_grant_statement_mut(self, node)
    }
    fn visit_abbreviated_revoke_statement_mut(&mut self, node: &'ast mut AbbreviatedRevokeStatement<T>) {
        visit_abbreviated_revoke_statement_mut(self, node)
    }
    fn visit_alter_cluster_action_mut(&mut self, node: &'ast mut AlterClusterAction<T>) {
        visit_alter_cluster_action_mut(self, node)
    }
    fn visit_alter_cluster_statement_mut(&mut self, node: &'ast mut AlterClusterStatement<T>) {
        visit_alter_cluster_statement_mut(self, node)
    }
    fn visit_alter_connection_action_mut(&mut self, node: &'ast mut AlterConnectionAction<T>) {
        visit_alter_connection_action_mut(self, node)
    }
    fn visit_alter_connection_option_mut(&mut self, node: &'ast mut AlterConnectionOption<T>) {
        visit_alter_connection_option_mut(self, node)
    }
    fn visit_alter_connection_option_name_mut(&mut self, node: &'ast mut AlterConnectionOptionName) {
        visit_alter_connection_option_name_mut(self, node)
    }
    fn visit_alter_connection_statement_mut(&mut self, node: &'ast mut AlterConnectionStatement<T>) {
        visit_alter_connection_statement_mut(self, node)
    }
    fn visit_alter_default_privileges_statement_mut(&mut self, node: &'ast mut AlterDefaultPrivilegesStatement<T>) {
        visit_alter_default_privileges_statement_mut(self, node)
    }
    fn visit_alter_index_action_mut(&mut self, node: &'ast mut AlterIndexAction<T>) {
        visit_alter_index_action_mut(self, node)
    }
    fn visit_alter_index_statement_mut(&mut self, node: &'ast mut AlterIndexStatement<T>) {
        visit_alter_index_statement_mut(self, node)
    }
    fn visit_alter_network_policy_statement_mut(&mut self, node: &'ast mut AlterNetworkPolicyStatement<T>) {
        visit_alter_network_policy_statement_mut(self, node)
    }
    fn visit_alter_object_rename_statement_mut(&mut self, node: &'ast mut AlterObjectRenameStatement) {
        visit_alter_object_rename_statement_mut(self, node)
    }
    fn visit_alter_object_swap_statement_mut(&mut self, node: &'ast mut AlterObjectSwapStatement) {
        visit_alter_object_swap_statement_mut(self, node)
    }
    fn visit_alter_owner_statement_mut(&mut self, node: &'ast mut AlterOwnerStatement<T>) {
        visit_alter_owner_statement_mut(self, node)
    }
    fn visit_alter_retain_history_statement_mut(&mut self, node: &'ast mut AlterRetainHistoryStatement<T>) {
        visit_alter_retain_history_statement_mut(self, node)
    }
    fn visit_alter_role_option_mut(&mut self, node: &'ast mut AlterRoleOption) {
        visit_alter_role_option_mut(self, node)
    }
    fn visit_alter_role_statement_mut(&mut self, node: &'ast mut AlterRoleStatement<T>) {
        visit_alter_role_statement_mut(self, node)
    }
    fn visit_alter_secret_statement_mut(&mut self, node: &'ast mut AlterSecretStatement<T>) {
        visit_alter_secret_statement_mut(self, node)
    }
    fn visit_alter_set_cluster_statement_mut(&mut self, node: &'ast mut AlterSetClusterStatement<T>) {
        visit_alter_set_cluster_statement_mut(self, node)
    }
    fn visit_alter_sink_action_mut(&mut self, node: &'ast mut AlterSinkAction<T>) {
        visit_alter_sink_action_mut(self, node)
    }
    fn visit_alter_sink_statement_mut(&mut self, node: &'ast mut AlterSinkStatement<T>) {
        visit_alter_sink_statement_mut(self, node)
    }
    fn visit_alter_source_action_mut(&mut self, node: &'ast mut AlterSourceAction<T>) {
        visit_alter_source_action_mut(self, node)
    }
    fn visit_alter_source_add_subsource_option_mut(&mut self, node: &'ast mut AlterSourceAddSubsourceOption<T>) {
        visit_alter_source_add_subsource_option_mut(self, node)
    }
    fn visit_alter_source_add_subsource_option_name_mut(&mut self, node: &'ast mut AlterSourceAddSubsourceOptionName) {
        visit_alter_source_add_subsource_option_name_mut(self, node)
    }
    fn visit_alter_source_statement_mut(&mut self, node: &'ast mut AlterSourceStatement<T>) {
        visit_alter_source_statement_mut(self, node)
    }
    fn visit_alter_system_reset_all_statement_mut(&mut self, node: &'ast mut AlterSystemResetAllStatement) {
        visit_alter_system_reset_all_statement_mut(self, node)
    }
    fn visit_alter_system_reset_statement_mut(&mut self, node: &'ast mut AlterSystemResetStatement) {
        visit_alter_system_reset_statement_mut(self, node)
    }
    fn visit_alter_system_set_statement_mut(&mut self, node: &'ast mut AlterSystemSetStatement) {
        visit_alter_system_set_statement_mut(self, node)
    }
    fn visit_alter_table_add_column_statement_mut(&mut self, node: &'ast mut AlterTableAddColumnStatement<T>) {
        visit_alter_table_add_column_statement_mut(self, node)
    }
    fn visit_as_of_mut(&mut self, node: &'ast mut AsOf<T>) {
        visit_as_of_mut(self, node)
    }
    fn visit_assignment_mut(&mut self, node: &'ast mut Assignment<T>) {
        visit_assignment_mut(self, node)
    }
    fn visit_avro_doc_on_mut(&mut self, node: &'ast mut AvroDocOn<T>) {
        visit_avro_doc_on_mut(self, node)
    }
    fn visit_avro_schema_mut(&mut self, node: &'ast mut AvroSchema<T>) {
        visit_avro_schema_mut(self, node)
    }
    fn visit_avro_schema_option_mut(&mut self, node: &'ast mut AvroSchemaOption<T>) {
        visit_avro_schema_option_mut(self, node)
    }
    fn visit_avro_schema_option_name_mut(&mut self, node: &'ast mut AvroSchemaOptionName) {
        visit_avro_schema_option_name_mut(self, node)
    }
    fn visit_catalog_name_mut(&mut self, node: &'ast mut CatalogName) {
        visit_catalog_name_mut(self, node)
    }
    fn visit_close_statement_mut(&mut self, node: &'ast mut CloseStatement) {
        visit_close_statement_mut(self, node)
    }
    fn visit_cluster_alter_option_mut(&mut self, node: &'ast mut ClusterAlterOption<T>) {
        visit_cluster_alter_option_mut(self, node)
    }
    fn visit_cluster_alter_option_name_mut(&mut self, node: &'ast mut ClusterAlterOptionName) {
        visit_cluster_alter_option_name_mut(self, node)
    }
    fn visit_cluster_alter_option_value_mut(&mut self, node: &'ast mut ClusterAlterOptionValue<T>) {
        visit_cluster_alter_option_value_mut(self, node)
    }
    fn visit_cluster_alter_until_ready_option_mut(&mut self, node: &'ast mut ClusterAlterUntilReadyOption<T>) {
        visit_cluster_alter_until_ready_option_mut(self, node)
    }
    fn visit_cluster_alter_until_ready_option_name_mut(&mut self, node: &'ast mut ClusterAlterUntilReadyOptionName) {
        visit_cluster_alter_until_ready_option_name_mut(self, node)
    }
    fn visit_cluster_feature_mut(&mut self, node: &'ast mut ClusterFeature<T>) {
        visit_cluster_feature_mut(self, node)
    }
    fn visit_cluster_feature_name_mut(&mut self, node: &'ast mut ClusterFeatureName) {
        visit_cluster_feature_name_mut(self, node)
    }
    fn visit_cluster_option_mut(&mut self, node: &'ast mut ClusterOption<T>) {
        visit_cluster_option_mut(self, node)
    }
    fn visit_cluster_option_name_mut(&mut self, node: &'ast mut ClusterOptionName) {
        visit_cluster_option_name_mut(self, node)
    }
    fn visit_cluster_schedule_option_value_mut(&mut self, node: &'ast mut ClusterScheduleOptionValue) {
        visit_cluster_schedule_option_value_mut(self, node)
    }
    fn visit_column_def_mut(&mut self, node: &'ast mut ColumnDef<T>) {
        visit_column_def_mut(self, node)
    }
    fn visit_column_name_mut(&mut self, node: &'ast mut ColumnName<T>) {
        visit_column_name_mut(self, node)
    }
    fn visit_column_option_mut(&mut self, node: &'ast mut ColumnOption<T>) {
        visit_column_option_mut(self, node)
    }
    fn visit_column_option_def_mut(&mut self, node: &'ast mut ColumnOptionDef<T>) {
        visit_column_option_def_mut(self, node)
    }
    fn visit_column_versioned_mut(&mut self, node: &'ast mut ColumnVersioned) {
        visit_column_versioned_mut(self, node)
    }
    fn visit_comment_object_type_mut(&mut self, node: &'ast mut CommentObjectType<T>) {
        visit_comment_object_type_mut(self, node)
    }
    fn visit_comment_statement_mut(&mut self, node: &'ast mut CommentStatement<T>) {
        visit_comment_statement_mut(self, node)
    }
    fn visit_commit_statement_mut(&mut self, node: &'ast mut CommitStatement) {
        visit_commit_statement_mut(self, node)
    }
    fn visit_connection_default_aws_privatelink_mut(&mut self, node: &'ast mut ConnectionDefaultAwsPrivatelink<T>) {
        visit_connection_default_aws_privatelink_mut(self, node)
    }
    fn visit_connection_option_mut(&mut self, node: &'ast mut ConnectionOption<T>) {
        visit_connection_option_mut(self, node)
    }
    fn visit_connection_option_name_mut(&mut self, node: &'ast mut ConnectionOptionName) {
        visit_connection_option_name_mut(self, node)
    }
    fn visit_continual_task_option_mut(&mut self, node: &'ast mut ContinualTaskOption<T>) {
        visit_continual_task_option_mut(self, node)
    }
    fn visit_continual_task_option_name_mut(&mut self, node: &'ast mut ContinualTaskOptionName) {
        visit_continual_task_option_name_mut(self, node)
    }
    fn visit_continual_task_stmt_mut(&mut self, node: &'ast mut ContinualTaskStmt<T>) {
        visit_continual_task_stmt_mut(self, node)
    }
    fn visit_copy_direction_mut(&mut self, node: &'ast mut CopyDirection) {
        visit_copy_direction_mut(self, node)
    }
    fn visit_copy_option_mut(&mut self, node: &'ast mut CopyOption<T>) {
        visit_copy_option_mut(self, node)
    }
    fn visit_copy_option_name_mut(&mut self, node: &'ast mut CopyOptionName) {
        visit_copy_option_name_mut(self, node)
    }
    fn visit_copy_relation_mut(&mut self, node: &'ast mut CopyRelation<T>) {
        visit_copy_relation_mut(self, node)
    }
    fn visit_copy_statement_mut(&mut self, node: &'ast mut CopyStatement<T>) {
        visit_copy_statement_mut(self, node)
    }
    fn visit_copy_target_mut(&mut self, node: &'ast mut CopyTarget<T>) {
        visit_copy_target_mut(self, node)
    }
    fn visit_create_cluster_replica_statement_mut(&mut self, node: &'ast mut CreateClusterReplicaStatement<T>) {
        visit_create_cluster_replica_statement_mut(self, node)
    }
    fn visit_create_cluster_statement_mut(&mut self, node: &'ast mut CreateClusterStatement<T>) {
        visit_create_cluster_statement_mut(self, node)
    }
    fn visit_create_connection_option_mut(&mut self, node: &'ast mut CreateConnectionOption<T>) {
        visit_create_connection_option_mut(self, node)
    }
    fn visit_create_connection_option_name_mut(&mut self, node: &'ast mut CreateConnectionOptionName) {
        visit_create_connection_option_name_mut(self, node)
    }
    fn visit_create_connection_statement_mut(&mut self, node: &'ast mut CreateConnectionStatement<T>) {
        visit_create_connection_statement_mut(self, node)
    }
    fn visit_create_connection_type_mut(&mut self, node: &'ast mut CreateConnectionType) {
        visit_create_connection_type_mut(self, node)
    }
    fn visit_create_continual_task_statement_mut(&mut self, node: &'ast mut CreateContinualTaskStatement<T>) {
        visit_create_continual_task_statement_mut(self, node)
    }
    fn visit_create_continual_task_sugar_mut(&mut self, node: &'ast mut CreateContinualTaskSugar<T>) {
        visit_create_continual_task_sugar_mut(self, node)
    }
    fn visit_create_database_statement_mut(&mut self, node: &'ast mut CreateDatabaseStatement) {
        visit_create_database_statement_mut(self, node)
    }
    fn visit_create_index_statement_mut(&mut self, node: &'ast mut CreateIndexStatement<T>) {
        visit_create_index_statement_mut(self, node)
    }
    fn visit_create_materialized_view_statement_mut(&mut self, node: &'ast mut CreateMaterializedViewStatement<T>) {
        visit_create_materialized_view_statement_mut(self, node)
    }
    fn visit_create_network_policy_statement_mut(&mut self, node: &'ast mut CreateNetworkPolicyStatement<T>) {
        visit_create_network_policy_statement_mut(self, node)
    }
    fn visit_create_role_statement_mut(&mut self, node: &'ast mut CreateRoleStatement) {
        visit_create_role_statement_mut(self, node)
    }
    fn visit_create_schema_statement_mut(&mut self, node: &'ast mut CreateSchemaStatement) {
        visit_create_schema_statement_mut(self, node)
    }
    fn visit_create_secret_statement_mut(&mut self, node: &'ast mut CreateSecretStatement<T>) {
        visit_create_secret_statement_mut(self, node)
    }
    fn visit_create_sink_connection_mut(&mut self, node: &'ast mut CreateSinkConnection<T>) {
        visit_create_sink_connection_mut(self, node)
    }
    fn visit_create_sink_option_mut(&mut self, node: &'ast mut CreateSinkOption<T>) {
        visit_create_sink_option_mut(self, node)
    }
    fn visit_create_sink_option_name_mut(&mut self, node: &'ast mut CreateSinkOptionName) {
        visit_create_sink_option_name_mut(self, node)
    }
    fn visit_create_sink_statement_mut(&mut self, node: &'ast mut CreateSinkStatement<T>) {
        visit_create_sink_statement_mut(self, node)
    }
    fn visit_create_source_connection_mut(&mut self, node: &'ast mut CreateSourceConnection<T>) {
        visit_create_source_connection_mut(self, node)
    }
    fn visit_create_source_option_mut(&mut self, node: &'ast mut CreateSourceOption<T>) {
        visit_create_source_option_mut(self, node)
    }
    fn visit_create_source_option_name_mut(&mut self, node: &'ast mut CreateSourceOptionName) {
        visit_create_source_option_name_mut(self, node)
    }
    fn visit_create_source_statement_mut(&mut self, node: &'ast mut CreateSourceStatement<T>) {
        visit_create_source_statement_mut(self, node)
    }
    fn visit_create_subsource_option_mut(&mut self, node: &'ast mut CreateSubsourceOption<T>) {
        visit_create_subsource_option_mut(self, node)
    }
    fn visit_create_subsource_option_name_mut(&mut self, node: &'ast mut CreateSubsourceOptionName) {
        visit_create_subsource_option_name_mut(self, node)
    }
    fn visit_create_subsource_statement_mut(&mut self, node: &'ast mut CreateSubsourceStatement<T>) {
        visit_create_subsource_statement_mut(self, node)
    }
    fn visit_create_table_from_source_statement_mut(&mut self, node: &'ast mut CreateTableFromSourceStatement<T>) {
        visit_create_table_from_source_statement_mut(self, node)
    }
    fn visit_create_table_statement_mut(&mut self, node: &'ast mut CreateTableStatement<T>) {
        visit_create_table_statement_mut(self, node)
    }
    fn visit_create_type_as_mut(&mut self, node: &'ast mut CreateTypeAs<T>) {
        visit_create_type_as_mut(self, node)
    }
    fn visit_create_type_list_option_mut(&mut self, node: &'ast mut CreateTypeListOption<T>) {
        visit_create_type_list_option_mut(self, node)
    }
    fn visit_create_type_list_option_name_mut(&mut self, node: &'ast mut CreateTypeListOptionName) {
        visit_create_type_list_option_name_mut(self, node)
    }
    fn visit_create_type_map_option_mut(&mut self, node: &'ast mut CreateTypeMapOption<T>) {
        visit_create_type_map_option_mut(self, node)
    }
    fn visit_create_type_map_option_name_mut(&mut self, node: &'ast mut CreateTypeMapOptionName) {
        visit_create_type_map_option_name_mut(self, node)
    }
    fn visit_create_type_statement_mut(&mut self, node: &'ast mut CreateTypeStatement<T>) {
        visit_create_type_statement_mut(self, node)
    }
    fn visit_create_view_statement_mut(&mut self, node: &'ast mut CreateViewStatement<T>) {
        visit_create_view_statement_mut(self, node)
    }
    fn visit_create_webhook_source_body_mut(&mut self, node: &'ast mut CreateWebhookSourceBody) {
        visit_create_webhook_source_body_mut(self, node)
    }
    fn visit_create_webhook_source_check_mut(&mut self, node: &'ast mut CreateWebhookSourceCheck<T>) {
        visit_create_webhook_source_check_mut(self, node)
    }
    fn visit_create_webhook_source_check_options_mut(&mut self, node: &'ast mut CreateWebhookSourceCheckOptions<T>) {
        visit_create_webhook_source_check_options_mut(self, node)
    }
    fn visit_create_webhook_source_filter_header_mut(&mut self, node: &'ast mut CreateWebhookSourceFilterHeader) {
        visit_create_webhook_source_filter_header_mut(self, node)
    }
    fn visit_create_webhook_source_header_mut(&mut self, node: &'ast mut CreateWebhookSourceHeader) {
        visit_create_webhook_source_header_mut(self, node)
    }
    fn visit_create_webhook_source_include_headers_mut(&mut self, node: &'ast mut CreateWebhookSourceIncludeHeaders) {
        visit_create_webhook_source_include_headers_mut(self, node)
    }
    fn visit_create_webhook_source_map_header_mut(&mut self, node: &'ast mut CreateWebhookSourceMapHeader) {
        visit_create_webhook_source_map_header_mut(self, node)
    }
    fn visit_create_webhook_source_secret_mut(&mut self, node: &'ast mut CreateWebhookSourceSecret<T>) {
        visit_create_webhook_source_secret_mut(self, node)
    }
    fn visit_create_webhook_source_statement_mut(&mut self, node: &'ast mut CreateWebhookSourceStatement<T>) {
        visit_create_webhook_source_statement_mut(self, node)
    }
    fn visit_csr_config_option_mut(&mut self, node: &'ast mut CsrConfigOption<T>) {
        visit_csr_config_option_mut(self, node)
    }
    fn visit_csr_config_option_name_mut(&mut self, node: &'ast mut CsrConfigOptionName<T>) {
        visit_csr_config_option_name_mut(self, node)
    }
    fn visit_csr_connection_mut(&mut self, node: &'ast mut CsrConnection<T>) {
        visit_csr_connection_mut(self, node)
    }
    fn visit_csr_connection_avro_mut(&mut self, node: &'ast mut CsrConnectionAvro<T>) {
        visit_csr_connection_avro_mut(self, node)
    }
    fn visit_csr_connection_protobuf_mut(&mut self, node: &'ast mut CsrConnectionProtobuf<T>) {
        visit_csr_connection_protobuf_mut(self, node)
    }
    fn visit_csr_seed_avro_mut(&mut self, node: &'ast mut CsrSeedAvro) {
        visit_csr_seed_avro_mut(self, node)
    }
    fn visit_csr_seed_protobuf_mut(&mut self, node: &'ast mut CsrSeedProtobuf) {
        visit_csr_seed_protobuf_mut(self, node)
    }
    fn visit_csr_seed_protobuf_schema_mut(&mut self, node: &'ast mut CsrSeedProtobufSchema) {
        visit_csr_seed_protobuf_schema_mut(self, node)
    }
    fn visit_csv_columns_mut(&mut self, node: &'ast mut CsvColumns) {
        visit_csv_columns_mut(self, node)
    }
    fn visit_cte_mut(&mut self, node: &'ast mut Cte<T>) {
        visit_cte_mut(self, node)
    }
    fn visit_cte_block_mut(&mut self, node: &'ast mut CteBlock<T>) {
        visit_cte_block_mut(self, node)
    }
    fn visit_cte_mut_rec_mut(&mut self, node: &'ast mut CteMutRec<T>) {
        visit_cte_mut_rec_mut(self, node)
    }
    fn visit_cte_mut_rec_column_def_mut(&mut self, node: &'ast mut CteMutRecColumnDef<T>) {
        visit_cte_mut_rec_column_def_mut(self, node)
    }
    fn visit_date_time_field_mut(&mut self, node: &'ast mut DateTimeField) {
        visit_date_time_field_mut(self, node)
    }
    fn visit_deallocate_statement_mut(&mut self, node: &'ast mut DeallocateStatement) {
        visit_deallocate_statement_mut(self, node)
    }
    fn visit_declare_statement_mut(&mut self, node: &'ast mut DeclareStatement<T>) {
        visit_declare_statement_mut(self, node)
    }
    fn visit_deferred_item_name_mut(&mut self, node: &'ast mut DeferredItemName<T>) {
        visit_deferred_item_name_mut(self, node)
    }
    fn visit_delete_statement_mut(&mut self, node: &'ast mut DeleteStatement<T>) {
        visit_delete_statement_mut(self, node)
    }
    fn visit_discard_statement_mut(&mut self, node: &'ast mut DiscardStatement) {
        visit_discard_statement_mut(self, node)
    }
    fn visit_discard_target_mut(&mut self, node: &'ast mut DiscardTarget) {
        visit_discard_target_mut(self, node)
    }
    fn visit_distinct_mut(&mut self, node: &'ast mut Distinct<T>) {
        visit_distinct_mut(self, node)
    }
    fn visit_doc_on_identifier_mut(&mut self, node: &'ast mut DocOnIdentifier<T>) {
        visit_doc_on_identifier_mut(self, node)
    }
    fn visit_doc_on_schema_mut(&mut self, node: &'ast mut DocOnSchema) {
        visit_doc_on_schema_mut(self, node)
    }
    fn visit_drop_objects_statement_mut(&mut self, node: &'ast mut DropObjectsStatement) {
        visit_drop_objects_statement_mut(self, node)
    }
    fn visit_drop_owned_statement_mut(&mut self, node: &'ast mut DropOwnedStatement<T>) {
        visit_drop_owned_statement_mut(self, node)
    }
    fn visit_execute_statement_mut(&mut self, node: &'ast mut ExecuteStatement<T>) {
        visit_execute_statement_mut(self, node)
    }
    fn visit_explain_format_mut(&mut self, node: &'ast mut ExplainFormat) {
        visit_explain_format_mut(self, node)
    }
    fn visit_explain_plan_option_mut(&mut self, node: &'ast mut ExplainPlanOption<T>) {
        visit_explain_plan_option_mut(self, node)
    }
    fn visit_explain_plan_option_name_mut(&mut self, node: &'ast mut ExplainPlanOptionName) {
        visit_explain_plan_option_name_mut(self, node)
    }
    fn visit_explain_plan_statement_mut(&mut self, node: &'ast mut ExplainPlanStatement<T>) {
        visit_explain_plan_statement_mut(self, node)
    }
    fn visit_explain_pushdown_statement_mut(&mut self, node: &'ast mut ExplainPushdownStatement<T>) {
        visit_explain_pushdown_statement_mut(self, node)
    }
    fn visit_explain_sink_schema_for_mut(&mut self, node: &'ast mut ExplainSinkSchemaFor) {
        visit_explain_sink_schema_for_mut(self, node)
    }
    fn visit_explain_sink_schema_statement_mut(&mut self, node: &'ast mut ExplainSinkSchemaStatement<T>) {
        visit_explain_sink_schema_statement_mut(self, node)
    }
    fn visit_explain_stage_mut(&mut self, node: &'ast mut ExplainStage) {
        visit_explain_stage_mut(self, node)
    }
    fn visit_explain_timestamp_statement_mut(&mut self, node: &'ast mut ExplainTimestampStatement<T>) {
        visit_explain_timestamp_statement_mut(self, node)
    }
    fn visit_explainee_mut(&mut self, node: &'ast mut Explainee<T>) {
        visit_explainee_mut(self, node)
    }
    fn visit_expr_mut(&mut self, node: &'ast mut Expr<T>) {
        visit_expr_mut(self, node)
    }
    fn visit_external_reference_export_mut(&mut self, node: &'ast mut ExternalReferenceExport) {
        visit_external_reference_export_mut(self, node)
    }
    fn visit_external_references_mut(&mut self, node: &'ast mut ExternalReferences) {
        visit_external_references_mut(self, node)
    }
    fn visit_fetch_direction_mut(&mut self, node: &'ast mut FetchDirection) {
        visit_fetch_direction_mut(self, node)
    }
    fn visit_fetch_option_mut(&mut self, node: &'ast mut FetchOption<T>) {
        visit_fetch_option_mut(self, node)
    }
    fn visit_fetch_option_name_mut(&mut self, node: &'ast mut FetchOptionName) {
        visit_fetch_option_name_mut(self, node)
    }
    fn visit_fetch_statement_mut(&mut self, node: &'ast mut FetchStatement<T>) {
        visit_fetch_statement_mut(self, node)
    }
    fn visit_format_mut(&mut self, node: &'ast mut Format<T>) {
        visit_format_mut(self, node)
    }
    fn visit_format_specifier_mut(&mut self, node: &'ast mut FormatSpecifier<T>) {
        visit_format_specifier_mut(self, node)
    }
    fn visit_function_mut(&mut self, node: &'ast mut Function<T>) {
        visit_function_mut(self, node)
    }
    fn visit_function_args_mut(&mut self, node: &'ast mut FunctionArgs<T>) {
        visit_function_args_mut(self, node)
    }
    fn visit_grant_privileges_statement_mut(&mut self, node: &'ast mut GrantPrivilegesStatement<T>) {
        visit_grant_privileges_statement_mut(self, node)
    }
    fn visit_grant_role_statement_mut(&mut self, node: &'ast mut GrantRoleStatement<T>) {
        visit_grant_role_statement_mut(self, node)
    }
    fn visit_grant_target_all_specification_mut(&mut self, node: &'ast mut GrantTargetAllSpecification<T>) {
        visit_grant_target_all_specification_mut(self, node)
    }
    fn visit_grant_target_specification_mut(&mut self, node: &'ast mut GrantTargetSpecification<T>) {
        visit_grant_target_specification_mut(self, node)
    }
    fn visit_grant_target_specification_inner_mut(&mut self, node: &'ast mut GrantTargetSpecificationInner<T>) {
        visit_grant_target_specification_inner_mut(self, node)
    }
    fn visit_homogenizing_function_mut(&mut self, node: &'ast mut HomogenizingFunction) {
        visit_homogenizing_function_mut(self, node)
    }
    fn visit_ident_mut(&mut self, node: &'ast mut Ident) {
        visit_ident_mut(self, node)
    }
    fn visit_ident_error_mut(&mut self, node: &'ast mut IdentError) {
        visit_ident_error_mut(self, node)
    }
    fn visit_if_exists_behavior_mut(&mut self, node: &'ast mut IfExistsBehavior) {
        visit_if_exists_behavior_mut(self, node)
    }
    fn visit_index_option_mut(&mut self, node: &'ast mut IndexOption<T>) {
        visit_index_option_mut(self, node)
    }
    fn visit_index_option_name_mut(&mut self, node: &'ast mut IndexOptionName) {
        visit_index_option_name_mut(self, node)
    }
    fn visit_insert_source_mut(&mut self, node: &'ast mut InsertSource<T>) {
        visit_insert_source_mut(self, node)
    }
    fn visit_insert_statement_mut(&mut self, node: &'ast mut InsertStatement<T>) {
        visit_insert_statement_mut(self, node)
    }
    fn visit_inspect_shard_statement_mut(&mut self, node: &'ast mut InspectShardStatement) {
        visit_inspect_shard_statement_mut(self, node)
    }
    fn visit_interval_value_mut(&mut self, node: &'ast mut IntervalValue) {
        visit_interval_value_mut(self, node)
    }
    fn visit_is_expr_construct_mut(&mut self, node: &'ast mut IsExprConstruct<T>) {
        visit_is_expr_construct_mut(self, node)
    }
    fn visit_join_mut(&mut self, node: &'ast mut Join<T>) {
        visit_join_mut(self, node)
    }
    fn visit_join_constraint_mut(&mut self, node: &'ast mut JoinConstraint<T>) {
        visit_join_constraint_mut(self, node)
    }
    fn visit_join_operator_mut(&mut self, node: &'ast mut JoinOperator<T>) {
        visit_join_operator_mut(self, node)
    }
    fn visit_kafka_broker_mut(&mut self, node: &'ast mut KafkaBroker<T>) {
        visit_kafka_broker_mut(self, node)
    }
    fn visit_kafka_broker_aws_privatelink_mut(&mut self, node: &'ast mut KafkaBrokerAwsPrivatelink<T>) {
        visit_kafka_broker_aws_privatelink_mut(self, node)
    }
    fn visit_kafka_broker_aws_privatelink_option_mut(&mut self, node: &'ast mut KafkaBrokerAwsPrivatelinkOption<T>) {
        visit_kafka_broker_aws_privatelink_option_mut(self, node)
    }
    fn visit_kafka_broker_aws_privatelink_option_name_mut(&mut self, node: &'ast mut KafkaBrokerAwsPrivatelinkOptionName) {
        visit_kafka_broker_aws_privatelink_option_name_mut(self, node)
    }
    fn visit_kafka_broker_tunnel_mut(&mut self, node: &'ast mut KafkaBrokerTunnel<T>) {
        visit_kafka_broker_tunnel_mut(self, node)
    }
    fn visit_kafka_sink_config_option_mut(&mut self, node: &'ast mut KafkaSinkConfigOption<T>) {
        visit_kafka_sink_config_option_mut(self, node)
    }
    fn visit_kafka_sink_config_option_name_mut(&mut self, node: &'ast mut KafkaSinkConfigOptionName) {
        visit_kafka_sink_config_option_name_mut(self, node)
    }
    fn visit_kafka_sink_key_mut(&mut self, node: &'ast mut KafkaSinkKey) {
        visit_kafka_sink_key_mut(self, node)
    }
    fn visit_kafka_source_config_option_mut(&mut self, node: &'ast mut KafkaSourceConfigOption<T>) {
        visit_kafka_source_config_option_mut(self, node)
    }
    fn visit_kafka_source_config_option_name_mut(&mut self, node: &'ast mut KafkaSourceConfigOptionName) {
        visit_kafka_source_config_option_name_mut(self, node)
    }
    fn visit_key_constraint_mut(&mut self, node: &'ast mut KeyConstraint) {
        visit_key_constraint_mut(self, node)
    }
    fn visit_limit_mut(&mut self, node: &'ast mut Limit<T>) {
        visit_limit_mut(self, node)
    }
    fn visit_load_generator_mut(&mut self, node: &'ast mut LoadGenerator) {
        visit_load_generator_mut(self, node)
    }
    fn visit_load_generator_option_mut(&mut self, node: &'ast mut LoadGeneratorOption<T>) {
        visit_load_generator_option_mut(self, node)
    }
    fn visit_load_generator_option_name_mut(&mut self, node: &'ast mut LoadGeneratorOptionName) {
        visit_load_generator_option_name_mut(self, node)
    }
    fn visit_map_entry_mut(&mut self, node: &'ast mut MapEntry<T>) {
        visit_map_entry_mut(self, node)
    }
    fn visit_materialized_view_option_mut(&mut self, node: &'ast mut MaterializedViewOption<T>) {
        visit_materialized_view_option_mut(self, node)
    }
    fn visit_materialized_view_option_name_mut(&mut self, node: &'ast mut MaterializedViewOptionName) {
        visit_materialized_view_option_name_mut(self, node)
    }
    fn visit_mut_rec_block_mut(&mut self, node: &'ast mut MutRecBlock<T>) {
        visit_mut_rec_block_mut(self, node)
    }
    fn visit_mut_rec_block_option_mut(&mut self, node: &'ast mut MutRecBlockOption<T>) {
        visit_mut_rec_block_option_mut(self, node)
    }
    fn visit_mut_rec_block_option_name_mut(&mut self, node: &'ast mut MutRecBlockOptionName) {
        visit_mut_rec_block_option_name_mut(self, node)
    }
    fn visit_my_sql_config_option_mut(&mut self, node: &'ast mut MySqlConfigOption<T>) {
        visit_my_sql_config_option_mut(self, node)
    }
    fn visit_my_sql_config_option_name_mut(&mut self, node: &'ast mut MySqlConfigOptionName) {
        visit_my_sql_config_option_name_mut(self, node)
    }
    fn visit_named_plan_mut(&mut self, node: &'ast mut NamedPlan) {
        visit_named_plan_mut(self, node)
    }
    fn visit_network_policy_option_mut(&mut self, node: &'ast mut NetworkPolicyOption<T>) {
        visit_network_policy_option_mut(self, node)
    }
    fn visit_network_policy_option_name_mut(&mut self, node: &'ast mut NetworkPolicyOptionName) {
        visit_network_policy_option_name_mut(self, node)
    }
    fn visit_network_policy_rule_definition_mut(&mut self, node: &'ast mut NetworkPolicyRuleDefinition<T>) {
        visit_network_policy_rule_definition_mut(self, node)
    }
    fn visit_network_policy_rule_option_mut(&mut self, node: &'ast mut NetworkPolicyRuleOption<T>) {
        visit_network_policy_rule_option_mut(self, node)
    }
    fn visit_network_policy_rule_option_name_mut(&mut self, node: &'ast mut NetworkPolicyRuleOptionName) {
        visit_network_policy_rule_option_name_mut(self, node)
    }
    fn visit_notice_severity_mut(&mut self, node: &'ast mut NoticeSeverity) {
        visit_notice_severity_mut(self, node)
    }
    fn visit_object_type_mut(&mut self, node: &'ast mut ObjectType) {
        visit_object_type_mut(self, node)
    }
    fn visit_op_mut(&mut self, node: &'ast mut Op) {
        visit_op_mut(self, node)
    }
    fn visit_order_by_expr_mut(&mut self, node: &'ast mut OrderByExpr<T>) {
        visit_order_by_expr_mut(self, node)
    }
    fn visit_pg_config_option_mut(&mut self, node: &'ast mut PgConfigOption<T>) {
        visit_pg_config_option_mut(self, node)
    }
    fn visit_pg_config_option_name_mut(&mut self, node: &'ast mut PgConfigOptionName) {
        visit_pg_config_option_name_mut(self, node)
    }
    fn visit_prepare_statement_mut(&mut self, node: &'ast mut PrepareStatement<T>) {
        visit_prepare_statement_mut(self, node)
    }
    fn visit_privilege_mut(&mut self, node: &'ast mut Privilege) {
        visit_privilege_mut(self, node)
    }
    fn visit_privilege_specification_mut(&mut self, node: &'ast mut PrivilegeSpecification) {
        visit_privilege_specification_mut(self, node)
    }
    fn visit_protobuf_schema_mut(&mut self, node: &'ast mut ProtobufSchema<T>) {
        visit_protobuf_schema_mut(self, node)
    }
    fn visit_qualified_replica_mut(&mut self, node: &'ast mut QualifiedReplica) {
        visit_qualified_replica_mut(self, node)
    }
    fn visit_query_mut(&mut self, node: &'ast mut Query<T>) {
        visit_query_mut(self, node)
    }
    fn visit_raise_statement_mut(&mut self, node: &'ast mut RaiseStatement) {
        visit_raise_statement_mut(self, node)
    }
    fn visit_reader_schema_selection_strategy_mut(&mut self, node: &'ast mut ReaderSchemaSelectionStrategy) {
        visit_reader_schema_selection_strategy_mut(self, node)
    }
    fn visit_reassign_owned_statement_mut(&mut self, node: &'ast mut ReassignOwnedStatement<T>) {
        visit_reassign_owned_statement_mut(self, node)
    }
    fn visit_refresh_at_option_value_mut(&mut self, node: &'ast mut RefreshAtOptionValue<T>) {
        visit_refresh_at_option_value_mut(self, node)
    }
    fn visit_refresh_every_option_value_mut(&mut self, node: &'ast mut RefreshEveryOptionValue<T>) {
        visit_refresh_every_option_value_mut(self, node)
    }
    fn visit_refresh_option_value_mut(&mut self, node: &'ast mut RefreshOptionValue<T>) {
        visit_refresh_option_value_mut(self, node)
    }
    fn visit_replica_definition_mut(&mut self, node: &'ast mut ReplicaDefinition<T>) {
        visit_replica_definition_mut(self, node)
    }
    fn visit_replica_option_mut(&mut self, node: &'ast mut ReplicaOption<T>) {
        visit_replica_option_mut(self, node)
    }
    fn visit_replica_option_name_mut(&mut self, node: &'ast mut ReplicaOptionName) {
        visit_replica_option_name_mut(self, node)
    }
    fn visit_reset_variable_statement_mut(&mut self, node: &'ast mut ResetVariableStatement) {
        visit_reset_variable_statement_mut(self, node)
    }
    fn visit_revoke_privileges_statement_mut(&mut self, node: &'ast mut RevokePrivilegesStatement<T>) {
        visit_revoke_privileges_statement_mut(self, node)
    }
    fn visit_revoke_role_statement_mut(&mut self, node: &'ast mut RevokeRoleStatement<T>) {
        visit_revoke_role_statement_mut(self, node)
    }
    fn visit_role_attribute_mut(&mut self, node: &'ast mut RoleAttribute) {
        visit_role_attribute_mut(self, node)
    }
    fn visit_rollback_statement_mut(&mut self, node: &'ast mut RollbackStatement) {
        visit_rollback_statement_mut(self, node)
    }
    fn visit_schema_mut(&mut self, node: &'ast mut Schema) {
        visit_schema_mut(self, node)
    }
    fn visit_select_mut(&mut self, node: &'ast mut Select<T>) {
        visit_select_mut(self, node)
    }
    fn visit_select_item_mut(&mut self, node: &'ast mut SelectItem<T>) {
        visit_select_item_mut(self, node)
    }
    fn visit_select_option_mut(&mut self, node: &'ast mut SelectOption<T>) {
        visit_select_option_mut(self, node)
    }
    fn visit_select_option_name_mut(&mut self, node: &'ast mut SelectOptionName) {
        visit_select_option_name_mut(self, node)
    }
    fn visit_select_statement_mut(&mut self, node: &'ast mut SelectStatement<T>) {
        visit_select_statement_mut(self, node)
    }
    fn visit_set_expr_mut(&mut self, node: &'ast mut SetExpr<T>) {
        visit_set_expr_mut(self, node)
    }
    fn visit_set_operator_mut(&mut self, node: &'ast mut SetOperator) {
        visit_set_operator_mut(self, node)
    }
    fn visit_set_role_var_mut(&mut self, node: &'ast mut SetRoleVar) {
        visit_set_role_var_mut(self, node)
    }
    fn visit_set_transaction_statement_mut(&mut self, node: &'ast mut SetTransactionStatement) {
        visit_set_transaction_statement_mut(self, node)
    }
    fn visit_set_variable_statement_mut(&mut self, node: &'ast mut SetVariableStatement) {
        visit_set_variable_statement_mut(self, node)
    }
    fn visit_set_variable_to_mut(&mut self, node: &'ast mut SetVariableTo) {
        visit_set_variable_to_mut(self, node)
    }
    fn visit_set_variable_value_mut(&mut self, node: &'ast mut SetVariableValue) {
        visit_set_variable_value_mut(self, node)
    }
    fn visit_show_columns_statement_mut(&mut self, node: &'ast mut ShowColumnsStatement<T>) {
        visit_show_columns_statement_mut(self, node)
    }
    fn visit_show_create_cluster_statement_mut(&mut self, node: &'ast mut ShowCreateClusterStatement<T>) {
        visit_show_create_cluster_statement_mut(self, node)
    }
    fn visit_show_create_connection_statement_mut(&mut self, node: &'ast mut ShowCreateConnectionStatement<T>) {
        visit_show_create_connection_statement_mut(self, node)
    }
    fn visit_show_create_index_statement_mut(&mut self, node: &'ast mut ShowCreateIndexStatement<T>) {
        visit_show_create_index_statement_mut(self, node)
    }
    fn visit_show_create_materialized_view_statement_mut(&mut self, node: &'ast mut ShowCreateMaterializedViewStatement<T>) {
        visit_show_create_materialized_view_statement_mut(self, node)
    }
    fn visit_show_create_sink_statement_mut(&mut self, node: &'ast mut ShowCreateSinkStatement<T>) {
        visit_show_create_sink_statement_mut(self, node)
    }
    fn visit_show_create_source_statement_mut(&mut self, node: &'ast mut ShowCreateSourceStatement<T>) {
        visit_show_create_source_statement_mut(self, node)
    }
    fn visit_show_create_table_statement_mut(&mut self, node: &'ast mut ShowCreateTableStatement<T>) {
        visit_show_create_table_statement_mut(self, node)
    }
    fn visit_show_create_view_statement_mut(&mut self, node: &'ast mut ShowCreateViewStatement<T>) {
        visit_show_create_view_statement_mut(self, node)
    }
    fn visit_show_object_type_mut(&mut self, node: &'ast mut ShowObjectType<T>) {
        visit_show_object_type_mut(self, node)
    }
    fn visit_show_objects_statement_mut(&mut self, node: &'ast mut ShowObjectsStatement<T>) {
        visit_show_objects_statement_mut(self, node)
    }
    fn visit_show_statement_mut(&mut self, node: &'ast mut ShowStatement<T>) {
        visit_show_statement_mut(self, node)
    }
    fn visit_show_statement_filter_mut(&mut self, node: &'ast mut ShowStatementFilter<T>) {
        visit_show_statement_filter_mut(self, node)
    }
    fn visit_show_variable_statement_mut(&mut self, node: &'ast mut ShowVariableStatement) {
        visit_show_variable_statement_mut(self, node)
    }
    fn visit_sink_envelope_mut(&mut self, node: &'ast mut SinkEnvelope) {
        visit_sink_envelope_mut(self, node)
    }
    fn visit_source_envelope_mut(&mut self, node: &'ast mut SourceEnvelope) {
        visit_source_envelope_mut(self, node)
    }
    fn visit_source_error_policy_mut(&mut self, node: &'ast mut SourceErrorPolicy) {
        visit_source_error_policy_mut(self, node)
    }
    fn visit_source_include_metadata_mut(&mut self, node: &'ast mut SourceIncludeMetadata) {
        visit_source_include_metadata_mut(self, node)
    }
    fn visit_sql_server_config_option_mut(&mut self, node: &'ast mut SqlServerConfigOption<T>) {
        visit_sql_server_config_option_mut(self, node)
    }
    fn visit_sql_server_config_option_name_mut(&mut self, node: &'ast mut SqlServerConfigOptionName) {
        visit_sql_server_config_option_name_mut(self, node)
    }
    fn visit_start_transaction_statement_mut(&mut self, node: &'ast mut StartTransactionStatement) {
        visit_start_transaction_statement_mut(self, node)
    }
    fn visit_statement_mut(&mut self, node: &'ast mut Statement<T>) {
        visit_statement_mut(self, node)
    }
    fn visit_subscribe_option_mut(&mut self, node: &'ast mut SubscribeOption<T>) {
        visit_subscribe_option_mut(self, node)
    }
    fn visit_subscribe_option_name_mut(&mut self, node: &'ast mut SubscribeOptionName) {
        visit_subscribe_option_name_mut(self, node)
    }
    fn visit_subscribe_output_mut(&mut self, node: &'ast mut SubscribeOutput<T>) {
        visit_subscribe_output_mut(self, node)
    }
    fn visit_subscribe_relation_mut(&mut self, node: &'ast mut SubscribeRelation<T>) {
        visit_subscribe_relation_mut(self, node)
    }
    fn visit_subscribe_statement_mut(&mut self, node: &'ast mut SubscribeStatement<T>) {
        visit_subscribe_statement_mut(self, node)
    }
    fn visit_subscript_position_mut(&mut self, node: &'ast mut SubscriptPosition<T>) {
        visit_subscript_position_mut(self, node)
    }
    fn visit_system_object_type_mut(&mut self, node: &'ast mut SystemObjectType) {
        visit_system_object_type_mut(self, node)
    }
    fn visit_cluster_name_mut(&mut self, node: &'ast mut T::ClusterName) {
        visit_cluster_name_mut(self, node)
    }
    fn visit_column_reference_mut(&mut self, node: &'ast mut T::ColumnReference) {
        visit_column_reference_mut(self, node)
    }
    fn visit_cte_id_mut(&mut self, node: &'ast mut T::CteId) {
        visit_cte_id_mut(self, node)
    }
    fn visit_data_type_mut(&mut self, node: &'ast mut T::DataType) {
        visit_data_type_mut(self, node)
    }
    fn visit_database_name_mut(&mut self, node: &'ast mut T::DatabaseName) {
        visit_database_name_mut(self, node)
    }
    fn visit_item_name_mut(&mut self, node: &'ast mut T::ItemName) {
        visit_item_name_mut(self, node)
    }
    fn visit_nested_statement_mut(&mut self, node: &'ast mut T::NestedStatement) {
        visit_nested_statement_mut(self, node)
    }
    fn visit_network_policy_name_mut(&mut self, node: &'ast mut T::NetworkPolicyName) {
        visit_network_policy_name_mut(self, node)
    }
    fn visit_object_name_mut(&mut self, node: &'ast mut T::ObjectName) {
        visit_object_name_mut(self, node)
    }
    fn visit_role_name_mut(&mut self, node: &'ast mut T::RoleName) {
        visit_role_name_mut(self, node)
    }
    fn visit_schema_name_mut(&mut self, node: &'ast mut T::SchemaName) {
        visit_schema_name_mut(self, node)
    }
    fn visit_table_alias_mut(&mut self, node: &'ast mut TableAlias) {
        visit_table_alias_mut(self, node)
    }
    fn visit_table_constraint_mut(&mut self, node: &'ast mut TableConstraint<T>) {
        visit_table_constraint_mut(self, node)
    }
    fn visit_table_factor_mut(&mut self, node: &'ast mut TableFactor<T>) {
        visit_table_factor_mut(self, node)
    }
    fn visit_table_from_source_columns_mut(&mut self, node: &'ast mut TableFromSourceColumns<T>) {
        visit_table_from_source_columns_mut(self, node)
    }
    fn visit_table_from_source_option_mut(&mut self, node: &'ast mut TableFromSourceOption<T>) {
        visit_table_from_source_option_mut(self, node)
    }
    fn visit_table_from_source_option_name_mut(&mut self, node: &'ast mut TableFromSourceOptionName) {
        visit_table_from_source_option_name_mut(self, node)
    }
    fn visit_table_option_mut(&mut self, node: &'ast mut TableOption<T>) {
        visit_table_option_mut(self, node)
    }
    fn visit_table_option_name_mut(&mut self, node: &'ast mut TableOptionName) {
        visit_table_option_name_mut(self, node)
    }
    fn visit_table_with_joins_mut(&mut self, node: &'ast mut TableWithJoins<T>) {
        visit_table_with_joins_mut(self, node)
    }
    fn visit_target_role_specification_mut(&mut self, node: &'ast mut TargetRoleSpecification<T>) {
        visit_target_role_specification_mut(self, node)
    }
    fn visit_transaction_access_mode_mut(&mut self, node: &'ast mut TransactionAccessMode) {
        visit_transaction_access_mode_mut(self, node)
    }
    fn visit_transaction_isolation_level_mut(&mut self, node: &'ast mut TransactionIsolationLevel) {
        visit_transaction_isolation_level_mut(self, node)
    }
    fn visit_transaction_mode_mut(&mut self, node: &'ast mut TransactionMode) {
        visit_transaction_mode_mut(self, node)
    }
    fn visit_unresolved_database_name_mut(&mut self, node: &'ast mut UnresolvedDatabaseName) {
        visit_unresolved_database_name_mut(self, node)
    }
    fn visit_unresolved_item_name_mut(&mut self, node: &'ast mut UnresolvedItemName) {
        visit_unresolved_item_name_mut(self, node)
    }
    fn visit_unresolved_object_name_mut(&mut self, node: &'ast mut UnresolvedObjectName) {
        visit_unresolved_object_name_mut(self, node)
    }
    fn visit_unresolved_schema_name_mut(&mut self, node: &'ast mut UnresolvedSchemaName) {
        visit_unresolved_schema_name_mut(self, node)
    }
    fn visit_update_statement_mut(&mut self, node: &'ast mut UpdateStatement<T>) {
        visit_update_statement_mut(self, node)
    }
    fn visit_validate_connection_statement_mut(&mut self, node: &'ast mut ValidateConnectionStatement<T>) {
        visit_validate_connection_statement_mut(self, node)
    }
    fn visit_value_mut(&mut self, node: &'ast mut Value) {
        visit_value_mut(self, node)
    }
    fn visit_value_error_mut(&mut self, node: &'ast mut ValueError) {
        visit_value_error_mut(self, node)
    }
    fn visit_values_mut(&mut self, node: &'ast mut Values<T>) {
        visit_values_mut(self, node)
    }
    fn visit_version_mut(&mut self, node: &'ast mut Version) {
        visit_version_mut(self, node)
    }
    fn visit_view_definition_mut(&mut self, node: &'ast mut ViewDefinition<T>) {
        visit_view_definition_mut(self, node)
    }
    fn visit_window_frame_mut(&mut self, node: &'ast mut WindowFrame) {
        visit_window_frame_mut(self, node)
    }
    fn visit_window_frame_bound_mut(&mut self, node: &'ast mut WindowFrameBound) {
        visit_window_frame_bound_mut(self, node)
    }
    fn visit_window_frame_units_mut(&mut self, node: &'ast mut WindowFrameUnits) {
        visit_window_frame_units_mut(self, node)
    }
    fn visit_window_spec_mut(&mut self, node: &'ast mut WindowSpec<T>) {
        visit_window_spec_mut(self, node)
    }
    fn visit_with_option_value_mut(&mut self, node: &'ast mut WithOptionValue<T>) {
        visit_with_option_value_mut(self, node)
    }
}
pub trait VisitMutNode<'ast, T: AstInfo, > {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AbbreviatedGrantOrRevokeStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_abbreviated_grant_or_revoke_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_abbreviated_grant_or_revoke_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AbbreviatedGrantOrRevokeStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AbbreviatedGrantOrRevokeStatement::Grant {
            0: binding0,
        } => {
            visitor.visit_abbreviated_grant_statement_mut(binding0);
        }
        AbbreviatedGrantOrRevokeStatement::Revoke {
            0: binding0,
        } => {
            visitor.visit_abbreviated_revoke_statement_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AbbreviatedGrantStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_abbreviated_grant_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_abbreviated_grant_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AbbreviatedGrantStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification_mut(&mut node.privileges);
    visitor.visit_object_type_mut(&mut node.object_type);
    for v in &mut node.grantees {
        visitor.visit_role_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AbbreviatedRevokeStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_abbreviated_revoke_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_abbreviated_revoke_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AbbreviatedRevokeStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification_mut(&mut node.privileges);
    visitor.visit_object_type_mut(&mut node.object_type);
    for v in &mut node.revokees {
        visitor.visit_role_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterClusterAction<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_cluster_action_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_cluster_action_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterClusterAction<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterClusterAction::SetOptions {
            options: binding0,
            with_options: binding1,
        } => {
            for v in binding0 {
                visitor.visit_cluster_option_mut(v);
            }
            for v in binding1 {
                visitor.visit_cluster_alter_option_mut(v);
            }
        }
        AlterClusterAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_cluster_option_name_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterClusterStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_cluster_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_cluster_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterClusterStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    visitor.visit_alter_cluster_action_mut(&mut node.action);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterConnectionAction<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_connection_action_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_connection_action_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterConnectionAction<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterConnectionAction::RotateKeys {
        } => {
        }
        AlterConnectionAction::SetOption {
            0: binding0,
        } => {
            visitor.visit_connection_option_mut(binding0);
        }
        AlterConnectionAction::DropOption {
            0: binding0,
        } => {
            visitor.visit_connection_option_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterConnectionOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_connection_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_connection_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterConnectionOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_alter_connection_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterConnectionOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_connection_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_connection_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterConnectionOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterConnectionOptionName::Validate {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterConnectionStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_connection_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_connection_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterConnectionStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    for v in &mut node.actions {
        visitor.visit_alter_connection_action_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_alter_connection_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterDefaultPrivilegesStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_default_privileges_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_default_privileges_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterDefaultPrivilegesStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_target_role_specification_mut(&mut node.target_roles);
    visitor.visit_grant_target_all_specification_mut(&mut node.target_objects);
    visitor.visit_abbreviated_grant_or_revoke_statement_mut(&mut node.grant_or_revoke);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterIndexAction<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_index_action_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_index_action_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterIndexAction<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterIndexAction::SetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_index_option_mut(v);
            }
        }
        AlterIndexAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_index_option_name_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterIndexStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_index_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_index_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterIndexStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.index_name);
    visitor.visit_alter_index_action_mut(&mut node.action);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterNetworkPolicyStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_network_policy_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_network_policy_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterNetworkPolicyStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.options {
        visitor.visit_network_policy_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterObjectRenameStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_object_rename_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_object_rename_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterObjectRenameStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_object_type_mut(&mut node.object_type);
    visitor.visit_unresolved_object_name_mut(&mut node.name);
    visitor.visit_ident_mut(&mut node.to_item_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterObjectSwapStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_object_swap_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_object_swap_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterObjectSwapStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_object_type_mut(&mut node.object_type);
    visitor.visit_unresolved_object_name_mut(&mut node.name_a);
    visitor.visit_ident_mut(&mut node.name_b);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterOwnerStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_owner_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_owner_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterOwnerStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_object_type_mut(&mut node.object_type);
    visitor.visit_unresolved_object_name_mut(&mut node.name);
    visitor.visit_role_name_mut(&mut node.new_owner);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterRetainHistoryStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_retain_history_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_retain_history_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterRetainHistoryStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_object_type_mut(&mut node.object_type);
    visitor.visit_unresolved_object_name_mut(&mut node.name);
    if let Some(v) = &mut node.history {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterRoleOption {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_role_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_role_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterRoleOption)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterRoleOption::Attributes {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_role_attribute_mut(v);
            }
        }
        AlterRoleOption::Variable {
            0: binding0,
        } => {
            visitor.visit_set_role_var_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterRoleStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_role_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_role_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterRoleStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_role_name_mut(&mut node.name);
    visitor.visit_alter_role_option_mut(&mut node.option);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSecretStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_secret_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_secret_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSecretStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_expr_mut(&mut node.value);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSetClusterStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_set_cluster_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_set_cluster_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSetClusterStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_object_type_mut(&mut node.object_type);
    visitor.visit_cluster_name_mut(&mut node.set_cluster);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSinkAction<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_sink_action_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_sink_action_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSinkAction<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterSinkAction::SetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_sink_option_mut(v);
            }
        }
        AlterSinkAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_sink_option_name_mut(v);
            }
        }
        AlterSinkAction::ChangeRelation {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSinkStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_sink_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_sink_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSinkStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.sink_name);
    visitor.visit_alter_sink_action_mut(&mut node.action);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSourceAction<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_source_action_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_source_action_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSourceAction<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterSourceAction::SetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_source_option_mut(v);
            }
        }
        AlterSourceAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_source_option_name_mut(v);
            }
        }
        AlterSourceAction::AddSubsources {
            external_references: binding0,
            options: binding1,
        } => {
            for v in binding0 {
                visitor.visit_external_reference_export_mut(v);
            }
            for v in binding1 {
                visitor.visit_alter_source_add_subsource_option_mut(v);
            }
        }
        AlterSourceAction::DropSubsources {
            if_exists: binding0,
            cascade: binding1,
            names: binding2,
        } => {
            for v in binding2 {
                visitor.visit_unresolved_item_name_mut(v);
            }
        }
        AlterSourceAction::RefreshReferences {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSourceAddSubsourceOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_source_add_subsource_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_source_add_subsource_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSourceAddSubsourceOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_alter_source_add_subsource_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSourceAddSubsourceOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_source_add_subsource_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_source_add_subsource_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSourceAddSubsourceOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AlterSourceAddSubsourceOptionName::TextColumns {
        } => {
        }
        AlterSourceAddSubsourceOptionName::ExcludeColumns {
        } => {
        }
        AlterSourceAddSubsourceOptionName::Details {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSourceStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_source_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_source_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSourceStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.source_name);
    visitor.visit_alter_source_action_mut(&mut node.action);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSystemResetAllStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_system_reset_all_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_system_reset_all_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSystemResetAllStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSystemResetStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_system_reset_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_system_reset_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSystemResetStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterSystemSetStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_system_set_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_system_set_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterSystemSetStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    visitor.visit_set_variable_to_mut(&mut node.to);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AlterTableAddColumnStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_alter_table_add_column_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_alter_table_add_column_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AlterTableAddColumnStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_ident_mut(&mut node.column_name);
    visitor.visit_data_type_mut(&mut node.data_type);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AsOf<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_as_of_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_as_of_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AsOf<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AsOf::At {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
        AsOf::AtLeast {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Assignment<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_assignment_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_assignment_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Assignment<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.id);
    visitor.visit_expr_mut(&mut node.value);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AvroDocOn<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_avro_doc_on_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_avro_doc_on_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AvroDocOn<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_doc_on_identifier_mut(&mut node.identifier);
    visitor.visit_doc_on_schema_mut(&mut node.for_schema);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AvroSchema<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_avro_schema_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_avro_schema_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AvroSchema<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AvroSchema::Csr {
            csr_connection: binding0,
        } => {
            visitor.visit_csr_connection_avro_mut(binding0);
        }
        AvroSchema::InlineSchema {
            schema: binding0,
            with_options: binding1,
        } => {
            visitor.visit_schema_mut(binding0);
            for v in binding1 {
                visitor.visit_avro_schema_option_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AvroSchemaOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_avro_schema_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_avro_schema_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AvroSchemaOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_avro_schema_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for AvroSchemaOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_avro_schema_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_avro_schema_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut AvroSchemaOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        AvroSchemaOptionName::ConfluentWireFormat {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CatalogName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_catalog_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_catalog_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CatalogName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CatalogName::ItemName {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        CatalogName::FuncName {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CloseStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_close_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_close_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CloseStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterAlterOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_alter_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_alter_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterAlterOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_alter_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterAlterOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_alter_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_alter_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterAlterOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ClusterAlterOptionName::Wait {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterAlterOptionValue<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_alter_option_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_alter_option_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterAlterOptionValue<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ClusterAlterOptionValue::For {
            0: binding0,
        } => {
            visitor.visit_value_mut(binding0);
        }
        ClusterAlterOptionValue::UntilReady {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_cluster_alter_until_ready_option_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterAlterUntilReadyOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_alter_until_ready_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_alter_until_ready_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterAlterUntilReadyOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_alter_until_ready_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterAlterUntilReadyOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_alter_until_ready_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_alter_until_ready_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterAlterUntilReadyOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ClusterAlterUntilReadyOptionName::Timeout {
        } => {
        }
        ClusterAlterUntilReadyOptionName::OnTimeout {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterFeature<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_feature_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_feature_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterFeature<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_feature_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterFeatureName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_feature_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_feature_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterFeatureName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ClusterFeatureName::ReoptimizeImportedViews {
        } => {
        }
        ClusterFeatureName::EnableNewOuterJoinLowering {
        } => {
        }
        ClusterFeatureName::EnableEagerDeltaJoins {
        } => {
        }
        ClusterFeatureName::EnableVariadicLeftJoinLowering {
        } => {
        }
        ClusterFeatureName::EnableLetrecFixpointAnalysis {
        } => {
        }
        ClusterFeatureName::EnableJoinPrioritizeArranged {
        } => {
        }
        ClusterFeatureName::EnableProjectionPushdownAfterRelationCse {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ClusterOptionName::AvailabilityZones {
        } => {
        }
        ClusterOptionName::Disk {
        } => {
        }
        ClusterOptionName::IntrospectionInterval {
        } => {
        }
        ClusterOptionName::IntrospectionDebugging {
        } => {
        }
        ClusterOptionName::Managed {
        } => {
        }
        ClusterOptionName::Replicas {
        } => {
        }
        ClusterOptionName::ReplicationFactor {
        } => {
        }
        ClusterOptionName::Size {
        } => {
        }
        ClusterOptionName::Schedule {
        } => {
        }
        ClusterOptionName::WorkloadClass {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ClusterScheduleOptionValue {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cluster_schedule_option_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_schedule_option_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ClusterScheduleOptionValue)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ClusterScheduleOptionValue::Manual {
        } => {
        }
        ClusterScheduleOptionValue::Refresh {
            hydration_time_estimate: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_interval_value_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ColumnDef<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_column_def_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_column_def_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ColumnDef<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    visitor.visit_data_type_mut(&mut node.data_type);
    if let Some(v) = &mut node.collation {
        visitor.visit_unresolved_item_name_mut(v);
    }
    for v in &mut node.options {
        visitor.visit_column_option_def_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ColumnName<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_column_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_column_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ColumnName<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.relation);
    visitor.visit_column_reference_mut(&mut node.column);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ColumnOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_column_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_column_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ColumnOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ColumnOption::Null {
        } => {
        }
        ColumnOption::NotNull {
        } => {
        }
        ColumnOption::Default {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
        ColumnOption::Unique {
            is_primary: binding0,
        } => {
        }
        ColumnOption::ForeignKey {
            foreign_table: binding0,
            referred_columns: binding1,
        } => {
            visitor.visit_unresolved_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_ident_mut(v);
            }
        }
        ColumnOption::Check {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
        ColumnOption::Versioned {
            action: binding0,
            version: binding1,
        } => {
            visitor.visit_column_versioned_mut(binding0);
            visitor.visit_version_mut(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ColumnOptionDef<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_column_option_def_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_column_option_def_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ColumnOptionDef<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.name {
        visitor.visit_ident_mut(v);
    }
    visitor.visit_column_option_mut(&mut node.option);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ColumnVersioned {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_column_versioned_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_column_versioned_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ColumnVersioned)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ColumnVersioned::Added {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CommentObjectType<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_comment_object_type_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_comment_object_type_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CommentObjectType<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CommentObjectType::Table {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::View {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Column {
            name: binding0,
        } => {
            visitor.visit_column_name_mut(binding0);
        }
        CommentObjectType::MaterializedView {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Source {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Sink {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Index {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Func {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Connection {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Type {
            ty: binding0,
        } => {
            visitor.visit_data_type_mut(binding0);
        }
        CommentObjectType::Secret {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::Role {
            name: binding0,
        } => {
            visitor.visit_role_name_mut(binding0);
        }
        CommentObjectType::Database {
            name: binding0,
        } => {
            visitor.visit_database_name_mut(binding0);
        }
        CommentObjectType::Schema {
            name: binding0,
        } => {
            visitor.visit_schema_name_mut(binding0);
        }
        CommentObjectType::Cluster {
            name: binding0,
        } => {
            visitor.visit_cluster_name_mut(binding0);
        }
        CommentObjectType::ClusterReplica {
            name: binding0,
        } => {
            visitor.visit_qualified_replica_mut(binding0);
        }
        CommentObjectType::ContinualTask {
            name: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        CommentObjectType::NetworkPolicy {
            name: binding0,
        } => {
            visitor.visit_network_policy_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CommentStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_comment_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_comment_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CommentStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_comment_object_type_mut(&mut node.object);
    if let Some(v) = &mut node.comment {
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CommitStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_commit_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_commit_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CommitStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ConnectionDefaultAwsPrivatelink<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_connection_default_aws_privatelink_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_connection_default_aws_privatelink_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ConnectionDefaultAwsPrivatelink<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.connection);
    if let Some(v) = &mut node.port {
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ConnectionOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_connection_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_connection_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ConnectionOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_connection_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ConnectionOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_connection_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_connection_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ConnectionOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ConnectionOptionName::AccessKeyId {
        } => {
        }
        ConnectionOptionName::AssumeRoleArn {
        } => {
        }
        ConnectionOptionName::AssumeRoleSessionName {
        } => {
        }
        ConnectionOptionName::AvailabilityZones {
        } => {
        }
        ConnectionOptionName::AwsConnection {
        } => {
        }
        ConnectionOptionName::AwsPrivatelink {
        } => {
        }
        ConnectionOptionName::Broker {
        } => {
        }
        ConnectionOptionName::Brokers {
        } => {
        }
        ConnectionOptionName::Database {
        } => {
        }
        ConnectionOptionName::Endpoint {
        } => {
        }
        ConnectionOptionName::Host {
        } => {
        }
        ConnectionOptionName::Password {
        } => {
        }
        ConnectionOptionName::Port {
        } => {
        }
        ConnectionOptionName::ProgressTopic {
        } => {
        }
        ConnectionOptionName::ProgressTopicReplicationFactor {
        } => {
        }
        ConnectionOptionName::PublicKey1 {
        } => {
        }
        ConnectionOptionName::PublicKey2 {
        } => {
        }
        ConnectionOptionName::Region {
        } => {
        }
        ConnectionOptionName::SaslMechanisms {
        } => {
        }
        ConnectionOptionName::SaslPassword {
        } => {
        }
        ConnectionOptionName::SaslUsername {
        } => {
        }
        ConnectionOptionName::SecretAccessKey {
        } => {
        }
        ConnectionOptionName::SecurityProtocol {
        } => {
        }
        ConnectionOptionName::ServiceName {
        } => {
        }
        ConnectionOptionName::SshTunnel {
        } => {
        }
        ConnectionOptionName::SslCertificate {
        } => {
        }
        ConnectionOptionName::SslCertificateAuthority {
        } => {
        }
        ConnectionOptionName::SslKey {
        } => {
        }
        ConnectionOptionName::SslMode {
        } => {
        }
        ConnectionOptionName::SessionToken {
        } => {
        }
        ConnectionOptionName::Url {
        } => {
        }
        ConnectionOptionName::User {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ContinualTaskOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_continual_task_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_continual_task_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ContinualTaskOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_continual_task_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ContinualTaskOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_continual_task_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_continual_task_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ContinualTaskOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ContinualTaskOptionName::Snapshot {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ContinualTaskStmt<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_continual_task_stmt_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_continual_task_stmt_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ContinualTaskStmt<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ContinualTaskStmt::Delete {
            0: binding0,
        } => {
            visitor.visit_delete_statement_mut(binding0);
        }
        ContinualTaskStmt::Insert {
            0: binding0,
        } => {
            visitor.visit_insert_statement_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CopyDirection {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_copy_direction_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_copy_direction_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CopyDirection)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CopyDirection::To {
        } => {
        }
        CopyDirection::From {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CopyOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_copy_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_copy_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CopyOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_copy_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CopyOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_copy_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_copy_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CopyOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CopyOptionName::Format {
        } => {
        }
        CopyOptionName::Delimiter {
        } => {
        }
        CopyOptionName::Null {
        } => {
        }
        CopyOptionName::Escape {
        } => {
        }
        CopyOptionName::Quote {
        } => {
        }
        CopyOptionName::Header {
        } => {
        }
        CopyOptionName::AwsConnection {
        } => {
        }
        CopyOptionName::MaxFileSize {
        } => {
        }
        CopyOptionName::Files {
        } => {
        }
        CopyOptionName::Pattern {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CopyRelation<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_copy_relation_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_copy_relation_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CopyRelation<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CopyRelation::Named {
            name: binding0,
            columns: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_ident_mut(v);
            }
        }
        CopyRelation::Select {
            0: binding0,
        } => {
            visitor.visit_select_statement_mut(binding0);
        }
        CopyRelation::Subscribe {
            0: binding0,
        } => {
            visitor.visit_subscribe_statement_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CopyStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_copy_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_copy_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CopyStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_copy_relation_mut(&mut node.relation);
    visitor.visit_copy_direction_mut(&mut node.direction);
    visitor.visit_copy_target_mut(&mut node.target);
    for v in &mut node.options {
        visitor.visit_copy_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CopyTarget<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_copy_target_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_copy_target_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CopyTarget<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CopyTarget::Stdin {
        } => {
        }
        CopyTarget::Stdout {
        } => {
        }
        CopyTarget::Expr {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateClusterReplicaStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_cluster_replica_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_cluster_replica_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateClusterReplicaStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.of_cluster);
    visitor.visit_replica_definition_mut(&mut node.definition);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateClusterStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_cluster_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_cluster_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateClusterStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.options {
        visitor.visit_cluster_option_mut(v);
    }
    for v in &mut node.features {
        visitor.visit_cluster_feature_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateConnectionOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_connection_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_connection_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateConnectionOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_create_connection_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateConnectionOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_connection_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_connection_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateConnectionOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateConnectionOptionName::Validate {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateConnectionStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_connection_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_connection_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateConnectionStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_create_connection_type_mut(&mut node.connection_type);
    for v in &mut node.values {
        visitor.visit_connection_option_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_create_connection_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateConnectionType {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_connection_type_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_connection_type_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateConnectionType)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateConnectionType::Aws {
        } => {
        }
        CreateConnectionType::AwsPrivatelink {
        } => {
        }
        CreateConnectionType::Kafka {
        } => {
        }
        CreateConnectionType::Csr {
        } => {
        }
        CreateConnectionType::Postgres {
        } => {
        }
        CreateConnectionType::Ssh {
        } => {
        }
        CreateConnectionType::SqlServer {
        } => {
        }
        CreateConnectionType::MySql {
        } => {
        }
        CreateConnectionType::Yugabyte {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateContinualTaskStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_continual_task_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_continual_task_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateContinualTaskStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.name);
    if let Some(v) = &mut node.columns {
        for v in v {
            visitor.visit_cte_mut_rec_column_def_mut(v);
        }
    }
    if let Some(v) = &mut node.in_cluster {
        visitor.visit_cluster_name_mut(v);
    }
    if let Some(v) = &mut node.as_of {
    }
    for v in &mut node.with_options {
        visitor.visit_continual_task_option_mut(v);
    }
    visitor.visit_item_name_mut(&mut node.input);
    for v in &mut node.stmts {
        visitor.visit_continual_task_stmt_mut(v);
    }
    if let Some(v) = &mut node.sugar {
        visitor.visit_create_continual_task_sugar_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateContinualTaskSugar<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_continual_task_sugar_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_continual_task_sugar_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateContinualTaskSugar<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateContinualTaskSugar::Transform {
            transform: binding0,
        } => {
            visitor.visit_query_mut(binding0);
        }
        CreateContinualTaskSugar::Retain {
            retain: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateDatabaseStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_database_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_database_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateDatabaseStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_database_name_mut(&mut node.name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateIndexStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_index_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_index_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateIndexStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.name {
        visitor.visit_ident_mut(v);
    }
    if let Some(v) = &mut node.in_cluster {
        visitor.visit_cluster_name_mut(v);
    }
    visitor.visit_item_name_mut(&mut node.on_name);
    if let Some(v) = &mut node.key_parts {
        for v in v {
            visitor.visit_expr_mut(v);
        }
    }
    for v in &mut node.with_options {
        visitor.visit_index_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateMaterializedViewStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_materialized_view_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_materialized_view_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateMaterializedViewStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_if_exists_behavior_mut(&mut node.if_exists);
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    for v in &mut node.columns {
        visitor.visit_ident_mut(v);
    }
    if let Some(v) = &mut node.in_cluster {
        visitor.visit_cluster_name_mut(v);
    }
    visitor.visit_query_mut(&mut node.query);
    if let Some(v) = &mut node.as_of {
    }
    for v in &mut node.with_options {
        visitor.visit_materialized_view_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateNetworkPolicyStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_network_policy_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_network_policy_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateNetworkPolicyStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.options {
        visitor.visit_network_policy_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateRoleStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_role_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_role_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateRoleStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.options {
        visitor.visit_role_attribute_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSchemaStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_schema_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_schema_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSchemaStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_schema_name_mut(&mut node.name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSecretStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_secret_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_secret_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSecretStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_expr_mut(&mut node.value);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSinkConnection<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_sink_connection_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_sink_connection_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSinkConnection<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateSinkConnection::Kafka {
            connection: binding0,
            options: binding1,
            key: binding2,
            headers: binding3,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_kafka_sink_config_option_mut(v);
            }
            if let Some(v) = binding2 {
                visitor.visit_kafka_sink_key_mut(v);
            }
            if let Some(v) = binding3 {
                visitor.visit_ident_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSinkOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_sink_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_sink_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSinkOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_create_sink_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSinkOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_sink_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_sink_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSinkOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateSinkOptionName::Snapshot {
        } => {
        }
        CreateSinkOptionName::Version {
        } => {
        }
        CreateSinkOptionName::PartitionStrategy {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSinkStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_sink_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_sink_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSinkStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.name {
        visitor.visit_unresolved_item_name_mut(v);
    }
    if let Some(v) = &mut node.in_cluster {
        visitor.visit_cluster_name_mut(v);
    }
    visitor.visit_item_name_mut(&mut node.from);
    visitor.visit_create_sink_connection_mut(&mut node.connection);
    if let Some(v) = &mut node.format {
        visitor.visit_format_specifier_mut(v);
    }
    if let Some(v) = &mut node.envelope {
        visitor.visit_sink_envelope_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_create_sink_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSourceConnection<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_source_connection_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_source_connection_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSourceConnection<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateSourceConnection::Kafka {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_kafka_source_config_option_mut(v);
            }
        }
        CreateSourceConnection::Postgres {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_pg_config_option_mut(v);
            }
        }
        CreateSourceConnection::Yugabyte {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_pg_config_option_mut(v);
            }
        }
        CreateSourceConnection::SqlServer {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_sql_server_config_option_mut(v);
            }
        }
        CreateSourceConnection::MySql {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            for v in binding1 {
                visitor.visit_my_sql_config_option_mut(v);
            }
        }
        CreateSourceConnection::LoadGenerator {
            generator: binding0,
            options: binding1,
        } => {
            visitor.visit_load_generator_mut(binding0);
            for v in binding1 {
                visitor.visit_load_generator_option_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSourceOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_source_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_source_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSourceOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_create_source_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSourceOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_source_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_source_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSourceOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateSourceOptionName::TimestampInterval {
        } => {
        }
        CreateSourceOptionName::RetainHistory {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSourceStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_source_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_source_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSourceStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    if let Some(v) = &mut node.in_cluster {
        visitor.visit_cluster_name_mut(v);
    }
    for v in &mut node.col_names {
        visitor.visit_ident_mut(v);
    }
    visitor.visit_create_source_connection_mut(&mut node.connection);
    for v in &mut node.include_metadata {
        visitor.visit_source_include_metadata_mut(v);
    }
    if let Some(v) = &mut node.format {
        visitor.visit_format_specifier_mut(v);
    }
    if let Some(v) = &mut node.envelope {
        visitor.visit_source_envelope_mut(v);
    }
    if let Some(v) = &mut node.key_constraint {
        visitor.visit_key_constraint_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_create_source_option_mut(v);
    }
    if let Some(v) = &mut node.external_references {
        visitor.visit_external_references_mut(v);
    }
    if let Some(v) = &mut node.progress_subsource {
        visitor.visit_deferred_item_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSubsourceOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_subsource_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_subsource_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSubsourceOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_create_subsource_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSubsourceOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_subsource_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_subsource_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSubsourceOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateSubsourceOptionName::Progress {
        } => {
        }
        CreateSubsourceOptionName::ExternalReference {
        } => {
        }
        CreateSubsourceOptionName::TextColumns {
        } => {
        }
        CreateSubsourceOptionName::ExcludeColumns {
        } => {
        }
        CreateSubsourceOptionName::Details {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateSubsourceStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_subsource_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_subsource_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateSubsourceStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    for v in &mut node.columns {
        visitor.visit_column_def_mut(v);
    }
    if let Some(v) = &mut node.of_source {
        visitor.visit_item_name_mut(v);
    }
    for v in &mut node.constraints {
        visitor.visit_table_constraint_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_create_subsource_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTableFromSourceStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_table_from_source_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_table_from_source_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTableFromSourceStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_table_from_source_columns_mut(&mut node.columns);
    for v in &mut node.constraints {
        visitor.visit_table_constraint_mut(v);
    }
    visitor.visit_item_name_mut(&mut node.source);
    if let Some(v) = &mut node.external_reference {
        visitor.visit_unresolved_item_name_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_table_from_source_option_mut(v);
    }
    for v in &mut node.include_metadata {
        visitor.visit_source_include_metadata_mut(v);
    }
    if let Some(v) = &mut node.format {
        visitor.visit_format_specifier_mut(v);
    }
    if let Some(v) = &mut node.envelope {
        visitor.visit_source_envelope_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTableStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_table_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_table_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTableStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    for v in &mut node.columns {
        visitor.visit_column_def_mut(v);
    }
    for v in &mut node.constraints {
        visitor.visit_table_constraint_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_table_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTypeAs<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_type_as_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_type_as_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTypeAs<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateTypeAs::List {
            options: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_type_list_option_mut(v);
            }
        }
        CreateTypeAs::Map {
            options: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_type_map_option_mut(v);
            }
        }
        CreateTypeAs::Record {
            column_defs: binding0,
        } => {
            for v in binding0 {
                visitor.visit_column_def_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTypeListOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_type_list_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_type_list_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTypeListOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_create_type_list_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTypeListOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_type_list_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_type_list_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTypeListOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateTypeListOptionName::ElementType {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTypeMapOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_type_map_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_type_map_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTypeMapOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_create_type_map_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTypeMapOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_type_map_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_type_map_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTypeMapOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CreateTypeMapOptionName::KeyType {
        } => {
        }
        CreateTypeMapOptionName::ValueType {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateTypeStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_type_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_type_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateTypeStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_create_type_as_mut(&mut node.as_type);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateViewStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_view_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_view_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateViewStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_if_exists_behavior_mut(&mut node.if_exists);
    visitor.visit_view_definition_mut(&mut node.definition);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceBody {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_body_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_body_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceBody)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.alias {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceCheck<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_check_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_check_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceCheck<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.options {
        visitor.visit_create_webhook_source_check_options_mut(v);
    }
    visitor.visit_expr_mut(&mut node.using);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceCheckOptions<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_check_options_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_check_options_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceCheckOptions<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.secrets {
        visitor.visit_create_webhook_source_secret_mut(v);
    }
    for v in &mut node.headers {
        visitor.visit_create_webhook_source_header_mut(v);
    }
    for v in &mut node.bodies {
        visitor.visit_create_webhook_source_body_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceFilterHeader {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_filter_header_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_filter_header_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceFilterHeader)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceHeader {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_header_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_header_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceHeader)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.alias {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceIncludeHeaders {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_include_headers_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_include_headers_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceIncludeHeaders)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.mappings {
        visitor.visit_create_webhook_source_map_header_mut(v);
    }
    if let Some(v) = &mut node.column {
        for v in v {
            visitor.visit_create_webhook_source_filter_header_mut(v);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceMapHeader {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_map_header_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_map_header_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceMapHeader)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.column_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceSecret<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_secret_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_secret_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceSecret<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.secret);
    if let Some(v) = &mut node.alias {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CreateWebhookSourceStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_create_webhook_source_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_create_webhook_source_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CreateWebhookSourceStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    visitor.visit_format_mut(&mut node.body_format);
    visitor.visit_create_webhook_source_include_headers_mut(&mut node.include_headers);
    if let Some(v) = &mut node.validate_using {
        visitor.visit_create_webhook_source_check_mut(v);
    }
    if let Some(v) = &mut node.in_cluster {
        visitor.visit_cluster_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrConfigOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_config_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_config_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrConfigOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_csr_config_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrConfigOptionName<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_config_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_config_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrConfigOptionName<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CsrConfigOptionName::AvroKeyFullname {
        } => {
        }
        CsrConfigOptionName::AvroValueFullname {
        } => {
        }
        CsrConfigOptionName::NullDefaults {
        } => {
        }
        CsrConfigOptionName::AvroDocOn {
            0: binding0,
        } => {
            visitor.visit_avro_doc_on_mut(binding0);
        }
        CsrConfigOptionName::KeyCompatibilityLevel {
        } => {
        }
        CsrConfigOptionName::ValueCompatibilityLevel {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrConnection<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_connection_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_connection_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrConnection<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.connection);
    for v in &mut node.options {
        visitor.visit_csr_config_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrConnectionAvro<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_connection_avro_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_connection_avro_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrConnectionAvro<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_csr_connection_mut(&mut node.connection);
    if let Some(v) = &mut node.key_strategy {
        visitor.visit_reader_schema_selection_strategy_mut(v);
    }
    if let Some(v) = &mut node.value_strategy {
        visitor.visit_reader_schema_selection_strategy_mut(v);
    }
    if let Some(v) = &mut node.seed {
        visitor.visit_csr_seed_avro_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrConnectionProtobuf<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_connection_protobuf_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_connection_protobuf_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrConnectionProtobuf<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_csr_connection_mut(&mut node.connection);
    if let Some(v) = &mut node.seed {
        visitor.visit_csr_seed_protobuf_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrSeedAvro {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_seed_avro_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_seed_avro_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrSeedAvro)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.key_schema {
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrSeedProtobuf {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_seed_protobuf_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_seed_protobuf_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrSeedProtobuf)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.key {
        visitor.visit_csr_seed_protobuf_schema_mut(v);
    }
    visitor.visit_csr_seed_protobuf_schema_mut(&mut node.value);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsrSeedProtobufSchema {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csr_seed_protobuf_schema_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csr_seed_protobuf_schema_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsrSeedProtobufSchema)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CsvColumns {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_csv_columns_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_csv_columns_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CsvColumns)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CsvColumns::Count {
            0: binding0,
        } => {
        }
        CsvColumns::Header {
            names: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Cte<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cte_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cte_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Cte<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_table_alias_mut(&mut node.alias);
    visitor.visit_cte_id_mut(&mut node.id);
    visitor.visit_query_mut(&mut node.query);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CteBlock<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cte_block_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cte_block_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CteBlock<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        CteBlock::Simple {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_cte_mut(v);
            }
        }
        CteBlock::MutuallyRecursive {
            0: binding0,
        } => {
            visitor.visit_mut_rec_block_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CteMutRec<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cte_mut_rec_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cte_mut_rec_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CteMutRec<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.columns {
        visitor.visit_cte_mut_rec_column_def_mut(v);
    }
    visitor.visit_cte_id_mut(&mut node.id);
    visitor.visit_query_mut(&mut node.query);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for CteMutRecColumnDef<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_cte_mut_rec_column_def_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cte_mut_rec_column_def_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut CteMutRecColumnDef<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    visitor.visit_data_type_mut(&mut node.data_type);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DateTimeField {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_date_time_field_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_date_time_field_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DateTimeField)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        DateTimeField::Millennium {
        } => {
        }
        DateTimeField::Century {
        } => {
        }
        DateTimeField::Decade {
        } => {
        }
        DateTimeField::Year {
        } => {
        }
        DateTimeField::Month {
        } => {
        }
        DateTimeField::Day {
        } => {
        }
        DateTimeField::Hour {
        } => {
        }
        DateTimeField::Minute {
        } => {
        }
        DateTimeField::Second {
        } => {
        }
        DateTimeField::Milliseconds {
        } => {
        }
        DateTimeField::Microseconds {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DeallocateStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_deallocate_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_deallocate_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DeallocateStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.name {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DeclareStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_declare_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_declare_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DeclareStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    visitor.visit_nested_statement_mut(&mut *&mut node.stmt);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DeferredItemName<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_deferred_item_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_deferred_item_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DeferredItemName<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        DeferredItemName::Named {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        DeferredItemName::Deferred {
            0: binding0,
        } => {
            visitor.visit_unresolved_item_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DeleteStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_delete_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_delete_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DeleteStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.table_name);
    if let Some(v) = &mut node.alias {
        visitor.visit_table_alias_mut(v);
    }
    for v in &mut node.using {
        visitor.visit_table_with_joins_mut(v);
    }
    if let Some(v) = &mut node.selection {
        visitor.visit_expr_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DiscardStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_discard_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_discard_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DiscardStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_discard_target_mut(&mut node.target);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DiscardTarget {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_discard_target_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_discard_target_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DiscardTarget)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        DiscardTarget::Plans {
        } => {
        }
        DiscardTarget::Sequences {
        } => {
        }
        DiscardTarget::Temp {
        } => {
        }
        DiscardTarget::All {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Distinct<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_distinct_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_distinct_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Distinct<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Distinct::EntireRow {
        } => {
        }
        Distinct::On {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DocOnIdentifier<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_doc_on_identifier_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_doc_on_identifier_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DocOnIdentifier<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        DocOnIdentifier::Column {
            0: binding0,
        } => {
            visitor.visit_column_name_mut(binding0);
        }
        DocOnIdentifier::Type {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DocOnSchema {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_doc_on_schema_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_doc_on_schema_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DocOnSchema)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        DocOnSchema::KeyOnly {
        } => {
        }
        DocOnSchema::ValueOnly {
        } => {
        }
        DocOnSchema::All {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DropObjectsStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_drop_objects_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_drop_objects_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DropObjectsStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_object_type_mut(&mut node.object_type);
    for v in &mut node.names {
        visitor.visit_unresolved_object_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for DropOwnedStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_drop_owned_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_drop_owned_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut DropOwnedStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.role_names {
        visitor.visit_role_name_mut(v);
    }
    if let Some(v) = &mut node.cascade {
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExecuteStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_execute_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_execute_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExecuteStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.params {
        visitor.visit_expr_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainFormat {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_format_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_format_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainFormat)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ExplainFormat::Text {
        } => {
        }
        ExplainFormat::VerboseText {
        } => {
        }
        ExplainFormat::Json {
        } => {
        }
        ExplainFormat::Dot {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainPlanOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_plan_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_plan_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainPlanOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_explain_plan_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainPlanOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_plan_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_plan_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainPlanOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ExplainPlanOptionName::Arity {
        } => {
        }
        ExplainPlanOptionName::Cardinality {
        } => {
        }
        ExplainPlanOptionName::ColumnNames {
        } => {
        }
        ExplainPlanOptionName::FilterPushdown {
        } => {
        }
        ExplainPlanOptionName::HumanizedExpressions {
        } => {
        }
        ExplainPlanOptionName::JoinImplementations {
        } => {
        }
        ExplainPlanOptionName::Keys {
        } => {
        }
        ExplainPlanOptionName::LinearChains {
        } => {
        }
        ExplainPlanOptionName::NonNegative {
        } => {
        }
        ExplainPlanOptionName::NoFastPath {
        } => {
        }
        ExplainPlanOptionName::NoNotices {
        } => {
        }
        ExplainPlanOptionName::NodeIdentifiers {
        } => {
        }
        ExplainPlanOptionName::RawPlans {
        } => {
        }
        ExplainPlanOptionName::RawSyntax {
        } => {
        }
        ExplainPlanOptionName::Raw {
        } => {
        }
        ExplainPlanOptionName::Redacted {
        } => {
        }
        ExplainPlanOptionName::SubtreeSize {
        } => {
        }
        ExplainPlanOptionName::Timing {
        } => {
        }
        ExplainPlanOptionName::Types {
        } => {
        }
        ExplainPlanOptionName::Equivalences {
        } => {
        }
        ExplainPlanOptionName::ReoptimizeImportedViews {
        } => {
        }
        ExplainPlanOptionName::EnableNewOuterJoinLowering {
        } => {
        }
        ExplainPlanOptionName::EnableEagerDeltaJoins {
        } => {
        }
        ExplainPlanOptionName::EnableVariadicLeftJoinLowering {
        } => {
        }
        ExplainPlanOptionName::EnableLetrecFixpointAnalysis {
        } => {
        }
        ExplainPlanOptionName::EnableJoinPrioritizeArranged {
        } => {
        }
        ExplainPlanOptionName::EnableProjectionPushdownAfterRelationCse {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainPlanStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_plan_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_plan_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainPlanStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.stage {
        visitor.visit_explain_stage_mut(v);
    }
    for v in &mut node.with_options {
        visitor.visit_explain_plan_option_mut(v);
    }
    if let Some(v) = &mut node.format {
        visitor.visit_explain_format_mut(v);
    }
    visitor.visit_explainee_mut(&mut node.explainee);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainPushdownStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_pushdown_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_pushdown_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainPushdownStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_explainee_mut(&mut node.explainee);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainSinkSchemaFor {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_sink_schema_for_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_sink_schema_for_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainSinkSchemaFor)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ExplainSinkSchemaFor::Key {
        } => {
        }
        ExplainSinkSchemaFor::Value {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainSinkSchemaStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_sink_schema_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_sink_schema_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainSinkSchemaStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_explain_sink_schema_for_mut(&mut node.schema_for);
    if let Some(v) = &mut node.format {
        visitor.visit_explain_format_mut(v);
    }
    visitor.visit_create_sink_statement_mut(&mut node.statement);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainStage {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_stage_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_stage_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainStage)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ExplainStage::RawPlan {
        } => {
        }
        ExplainStage::DecorrelatedPlan {
        } => {
        }
        ExplainStage::LocalPlan {
        } => {
        }
        ExplainStage::GlobalPlan {
        } => {
        }
        ExplainStage::PhysicalPlan {
        } => {
        }
        ExplainStage::Trace {
        } => {
        }
        ExplainStage::PlanInsights {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExplainTimestampStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explain_timestamp_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explain_timestamp_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExplainTimestampStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.format {
        visitor.visit_explain_format_mut(v);
    }
    visitor.visit_select_statement_mut(&mut node.select);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Explainee<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_explainee_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_explainee_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Explainee<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Explainee::View {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        Explainee::MaterializedView {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        Explainee::Index {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        Explainee::ReplanView {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        Explainee::ReplanMaterializedView {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        Explainee::ReplanIndex {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        Explainee::Select {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_select_statement_mut(&mut *binding0);
        }
        Explainee::CreateView {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_create_view_statement_mut(&mut *binding0);
        }
        Explainee::CreateMaterializedView {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_create_materialized_view_statement_mut(&mut *binding0);
        }
        Explainee::CreateIndex {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_create_index_statement_mut(&mut *binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Expr<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_expr_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_expr_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Expr<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Expr::Identifier {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        Expr::QualifiedWildcard {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        Expr::FieldAccess {
            expr: binding0,
            field: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_ident_mut(binding1);
        }
        Expr::WildcardAccess {
            0: binding0,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
        }
        Expr::Parameter {
            0: binding0,
        } => {
        }
        Expr::Not {
            expr: binding0,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
        }
        Expr::And {
            left: binding0,
            right: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_expr_mut(&mut *binding1);
        }
        Expr::Or {
            left: binding0,
            right: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_expr_mut(&mut *binding1);
        }
        Expr::IsExpr {
            expr: binding0,
            construct: binding1,
            negated: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_is_expr_construct_mut(binding1);
        }
        Expr::InList {
            expr: binding0,
            list: binding1,
            negated: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            for v in binding1 {
                visitor.visit_expr_mut(v);
            }
        }
        Expr::InSubquery {
            expr: binding0,
            subquery: binding1,
            negated: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_query_mut(&mut *binding1);
        }
        Expr::Like {
            expr: binding0,
            pattern: binding1,
            escape: binding2,
            case_insensitive: binding3,
            negated: binding4,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_expr_mut(&mut *binding1);
            if let Some(v) = binding2 {
                visitor.visit_expr_mut(&mut *v);
            }
        }
        Expr::Between {
            expr: binding0,
            negated: binding1,
            low: binding2,
            high: binding3,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_expr_mut(&mut *binding2);
            visitor.visit_expr_mut(&mut *binding3);
        }
        Expr::Op {
            op: binding0,
            expr1: binding1,
            expr2: binding2,
        } => {
            visitor.visit_op_mut(binding0);
            visitor.visit_expr_mut(&mut *binding1);
            if let Some(v) = binding2 {
                visitor.visit_expr_mut(&mut *v);
            }
        }
        Expr::Cast {
            expr: binding0,
            data_type: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_data_type_mut(binding1);
        }
        Expr::Collate {
            expr: binding0,
            collation: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_unresolved_item_name_mut(binding1);
        }
        Expr::HomogenizingFunction {
            function: binding0,
            exprs: binding1,
        } => {
            visitor.visit_homogenizing_function_mut(binding0);
            for v in binding1 {
                visitor.visit_expr_mut(v);
            }
        }
        Expr::NullIf {
            l_expr: binding0,
            r_expr: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_expr_mut(&mut *binding1);
        }
        Expr::Nested {
            0: binding0,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
        }
        Expr::Row {
            exprs: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr_mut(v);
            }
        }
        Expr::Value {
            0: binding0,
        } => {
            visitor.visit_value_mut(binding0);
        }
        Expr::Function {
            0: binding0,
        } => {
            visitor.visit_function_mut(binding0);
        }
        Expr::Case {
            operand: binding0,
            conditions: binding1,
            results: binding2,
            else_result: binding3,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_expr_mut(&mut *v);
            }
            for v in binding1 {
                visitor.visit_expr_mut(v);
            }
            for v in binding2 {
                visitor.visit_expr_mut(v);
            }
            if let Some(v) = binding3 {
                visitor.visit_expr_mut(&mut *v);
            }
        }
        Expr::Exists {
            0: binding0,
        } => {
            visitor.visit_query_mut(&mut *binding0);
        }
        Expr::Subquery {
            0: binding0,
        } => {
            visitor.visit_query_mut(&mut *binding0);
        }
        Expr::AnySubquery {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_op_mut(binding1);
            visitor.visit_query_mut(&mut *binding2);
        }
        Expr::AnyExpr {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_op_mut(binding1);
            visitor.visit_expr_mut(&mut *binding2);
        }
        Expr::AllSubquery {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_op_mut(binding1);
            visitor.visit_query_mut(&mut *binding2);
        }
        Expr::AllExpr {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            visitor.visit_op_mut(binding1);
            visitor.visit_expr_mut(&mut *binding2);
        }
        Expr::Array {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr_mut(v);
            }
        }
        Expr::ArraySubquery {
            0: binding0,
        } => {
            visitor.visit_query_mut(&mut *binding0);
        }
        Expr::List {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr_mut(v);
            }
        }
        Expr::ListSubquery {
            0: binding0,
        } => {
            visitor.visit_query_mut(&mut *binding0);
        }
        Expr::Map {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_map_entry_mut(v);
            }
        }
        Expr::MapSubquery {
            0: binding0,
        } => {
            visitor.visit_query_mut(&mut *binding0);
        }
        Expr::Subscript {
            expr: binding0,
            positions: binding1,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
            for v in binding1 {
                visitor.visit_subscript_position_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExternalReferenceExport {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_external_reference_export_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_external_reference_export_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExternalReferenceExport)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.reference);
    if let Some(v) = &mut node.alias {
        visitor.visit_unresolved_item_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ExternalReferences {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_external_references_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_external_references_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ExternalReferences)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ExternalReferences::SubsetTables {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_external_reference_export_mut(v);
            }
        }
        ExternalReferences::SubsetSchemas {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        ExternalReferences::All {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for FetchDirection {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_fetch_direction_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_fetch_direction_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut FetchDirection)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        FetchDirection::ForwardAll {
        } => {
        }
        FetchDirection::ForwardCount {
            0: binding0,
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for FetchOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_fetch_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_fetch_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut FetchOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_fetch_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for FetchOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_fetch_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_fetch_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut FetchOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        FetchOptionName::Timeout {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for FetchStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_fetch_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_fetch_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut FetchStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    if let Some(v) = &mut node.count {
        visitor.visit_fetch_direction_mut(v);
    }
    for v in &mut node.options {
        visitor.visit_fetch_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Format<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_format_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_format_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Format<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Format::Bytes {
        } => {
        }
        Format::Avro {
            0: binding0,
        } => {
            visitor.visit_avro_schema_mut(binding0);
        }
        Format::Protobuf {
            0: binding0,
        } => {
            visitor.visit_protobuf_schema_mut(binding0);
        }
        Format::Regex {
            0: binding0,
        } => {
        }
        Format::Csv {
            columns: binding0,
            delimiter: binding1,
        } => {
            visitor.visit_csv_columns_mut(binding0);
        }
        Format::Json {
            array: binding0,
        } => {
        }
        Format::Text {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for FormatSpecifier<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_format_specifier_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_format_specifier_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut FormatSpecifier<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        FormatSpecifier::Bare {
            0: binding0,
        } => {
            visitor.visit_format_mut(binding0);
        }
        FormatSpecifier::KeyValue {
            key: binding0,
            value: binding1,
        } => {
            visitor.visit_format_mut(binding0);
            visitor.visit_format_mut(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Function<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_function_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_function_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Function<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.name);
    visitor.visit_function_args_mut(&mut node.args);
    if let Some(v) = &mut node.filter {
        visitor.visit_expr_mut(&mut *v);
    }
    if let Some(v) = &mut node.over {
        visitor.visit_window_spec_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for FunctionArgs<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_function_args_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_function_args_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut FunctionArgs<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        FunctionArgs::Star {
        } => {
        }
        FunctionArgs::Args {
            args: binding0,
            order_by: binding1,
        } => {
            for v in binding0 {
                visitor.visit_expr_mut(v);
            }
            for v in binding1 {
                visitor.visit_order_by_expr_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for GrantPrivilegesStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_grant_privileges_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_grant_privileges_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut GrantPrivilegesStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification_mut(&mut node.privileges);
    visitor.visit_grant_target_specification_mut(&mut node.target);
    for v in &mut node.roles {
        visitor.visit_role_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for GrantRoleStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_grant_role_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_grant_role_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut GrantRoleStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.role_names {
        visitor.visit_role_name_mut(v);
    }
    for v in &mut node.member_names {
        visitor.visit_role_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for GrantTargetAllSpecification<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_grant_target_all_specification_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_grant_target_all_specification_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut GrantTargetAllSpecification<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        GrantTargetAllSpecification::All {
        } => {
        }
        GrantTargetAllSpecification::AllDatabases {
            databases: binding0,
        } => {
            for v in binding0 {
                visitor.visit_database_name_mut(v);
            }
        }
        GrantTargetAllSpecification::AllSchemas {
            schemas: binding0,
        } => {
            for v in binding0 {
                visitor.visit_schema_name_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for GrantTargetSpecification<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_grant_target_specification_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_grant_target_specification_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut GrantTargetSpecification<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        GrantTargetSpecification::Object {
            object_type: binding0,
            object_spec_inner: binding1,
        } => {
            visitor.visit_object_type_mut(binding0);
            visitor.visit_grant_target_specification_inner_mut(binding1);
        }
        GrantTargetSpecification::System {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for GrantTargetSpecificationInner<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_grant_target_specification_inner_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_grant_target_specification_inner_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut GrantTargetSpecificationInner<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        GrantTargetSpecificationInner::All {
            0: binding0,
        } => {
            visitor.visit_grant_target_all_specification_mut(binding0);
        }
        GrantTargetSpecificationInner::Objects {
            names: binding0,
        } => {
            for v in binding0 {
                visitor.visit_object_name_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for HomogenizingFunction {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_homogenizing_function_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_homogenizing_function_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut HomogenizingFunction)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        HomogenizingFunction::Coalesce {
        } => {
        }
        HomogenizingFunction::Greatest {
        } => {
        }
        HomogenizingFunction::Least {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Ident {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_ident_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_ident_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Ident)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for IdentError {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_ident_error_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_ident_error_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut IdentError)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        IdentError::TooLong {
            0: binding0,
        } => {
        }
        IdentError::FailedToGenerate {
            prefix: binding0,
            suffix: binding1,
            attempts: binding2,
        } => {
        }
        IdentError::Invalid {
            0: binding0,
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for IfExistsBehavior {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_if_exists_behavior_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_if_exists_behavior_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut IfExistsBehavior)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        IfExistsBehavior::Error {
        } => {
        }
        IfExistsBehavior::Skip {
        } => {
        }
        IfExistsBehavior::Replace {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for IndexOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_index_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_index_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut IndexOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_index_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for IndexOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_index_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_index_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut IndexOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        IndexOptionName::RetainHistory {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for InsertSource<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_insert_source_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_insert_source_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut InsertSource<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        InsertSource::Query {
            0: binding0,
        } => {
            visitor.visit_query_mut(binding0);
        }
        InsertSource::DefaultValues {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for InsertStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_insert_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_insert_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut InsertStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.table_name);
    for v in &mut node.columns {
        visitor.visit_ident_mut(v);
    }
    visitor.visit_insert_source_mut(&mut node.source);
    for v in &mut node.returning {
        visitor.visit_select_item_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for InspectShardStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_inspect_shard_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_inspect_shard_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut InspectShardStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for IntervalValue {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_interval_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_interval_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut IntervalValue)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_date_time_field_mut(&mut node.precision_high);
    visitor.visit_date_time_field_mut(&mut node.precision_low);
    if let Some(v) = &mut node.fsec_max_precision {
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for IsExprConstruct<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_is_expr_construct_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_is_expr_construct_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut IsExprConstruct<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        IsExprConstruct::Null {
        } => {
        }
        IsExprConstruct::True {
        } => {
        }
        IsExprConstruct::False {
        } => {
        }
        IsExprConstruct::Unknown {
        } => {
        }
        IsExprConstruct::DistinctFrom {
            0: binding0,
        } => {
            visitor.visit_expr_mut(&mut *binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Join<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_join_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_join_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Join<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_table_factor_mut(&mut node.relation);
    visitor.visit_join_operator_mut(&mut node.join_operator);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for JoinConstraint<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_join_constraint_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_join_constraint_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut JoinConstraint<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        JoinConstraint::On {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
        JoinConstraint::Using {
            columns: binding0,
            alias: binding1,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_ident_mut(v);
            }
        }
        JoinConstraint::Natural {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for JoinOperator<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_join_operator_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_join_operator_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut JoinOperator<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        JoinOperator::Inner {
            0: binding0,
        } => {
            visitor.visit_join_constraint_mut(binding0);
        }
        JoinOperator::LeftOuter {
            0: binding0,
        } => {
            visitor.visit_join_constraint_mut(binding0);
        }
        JoinOperator::RightOuter {
            0: binding0,
        } => {
            visitor.visit_join_constraint_mut(binding0);
        }
        JoinOperator::FullOuter {
            0: binding0,
        } => {
            visitor.visit_join_constraint_mut(binding0);
        }
        JoinOperator::CrossJoin {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaBroker<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_broker_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_broker_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaBroker<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_broker_tunnel_mut(&mut node.tunnel);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaBrokerAwsPrivatelink<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_broker_aws_privatelink_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_broker_aws_privatelink_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaBrokerAwsPrivatelink<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.connection);
    for v in &mut node.options {
        visitor.visit_kafka_broker_aws_privatelink_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaBrokerAwsPrivatelinkOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_broker_aws_privatelink_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_broker_aws_privatelink_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaBrokerAwsPrivatelinkOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_broker_aws_privatelink_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaBrokerAwsPrivatelinkOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_broker_aws_privatelink_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_broker_aws_privatelink_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaBrokerAwsPrivatelinkOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone {
        } => {
        }
        KafkaBrokerAwsPrivatelinkOptionName::Port {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaBrokerTunnel<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_broker_tunnel_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_broker_tunnel_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaBrokerTunnel<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        KafkaBrokerTunnel::Direct {
        } => {
        }
        KafkaBrokerTunnel::AwsPrivatelink {
            0: binding0,
        } => {
            visitor.visit_kafka_broker_aws_privatelink_mut(binding0);
        }
        KafkaBrokerTunnel::SshTunnel {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaSinkConfigOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_sink_config_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_sink_config_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaSinkConfigOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_sink_config_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaSinkConfigOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_sink_config_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_sink_config_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaSinkConfigOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        KafkaSinkConfigOptionName::CompressionType {
        } => {
        }
        KafkaSinkConfigOptionName::PartitionBy {
        } => {
        }
        KafkaSinkConfigOptionName::ProgressGroupIdPrefix {
        } => {
        }
        KafkaSinkConfigOptionName::Topic {
        } => {
        }
        KafkaSinkConfigOptionName::TransactionalIdPrefix {
        } => {
        }
        KafkaSinkConfigOptionName::LegacyIds {
        } => {
        }
        KafkaSinkConfigOptionName::TopicConfig {
        } => {
        }
        KafkaSinkConfigOptionName::TopicMetadataRefreshInterval {
        } => {
        }
        KafkaSinkConfigOptionName::TopicPartitionCount {
        } => {
        }
        KafkaSinkConfigOptionName::TopicReplicationFactor {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaSinkKey {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_sink_key_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_sink_key_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaSinkKey)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.key_columns {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaSourceConfigOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_source_config_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_source_config_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaSourceConfigOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_source_config_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KafkaSourceConfigOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_kafka_source_config_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_kafka_source_config_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KafkaSourceConfigOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        KafkaSourceConfigOptionName::GroupIdPrefix {
        } => {
        }
        KafkaSourceConfigOptionName::Topic {
        } => {
        }
        KafkaSourceConfigOptionName::TopicMetadataRefreshInterval {
        } => {
        }
        KafkaSourceConfigOptionName::StartTimestamp {
        } => {
        }
        KafkaSourceConfigOptionName::StartOffset {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for KeyConstraint {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_key_constraint_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_key_constraint_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut KeyConstraint)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        KeyConstraint::PrimaryKeyNotEnforced {
            columns: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Limit<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_limit_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_limit_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Limit<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_expr_mut(&mut node.quantity);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for LoadGenerator {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_load_generator_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_load_generator_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut LoadGenerator)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        LoadGenerator::Clock {
        } => {
        }
        LoadGenerator::Counter {
        } => {
        }
        LoadGenerator::Marketing {
        } => {
        }
        LoadGenerator::Auction {
        } => {
        }
        LoadGenerator::Datums {
        } => {
        }
        LoadGenerator::Tpch {
        } => {
        }
        LoadGenerator::KeyValue {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for LoadGeneratorOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_load_generator_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_load_generator_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut LoadGeneratorOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_load_generator_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for LoadGeneratorOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_load_generator_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_load_generator_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut LoadGeneratorOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        LoadGeneratorOptionName::ScaleFactor {
        } => {
        }
        LoadGeneratorOptionName::TickInterval {
        } => {
        }
        LoadGeneratorOptionName::AsOf {
        } => {
        }
        LoadGeneratorOptionName::UpTo {
        } => {
        }
        LoadGeneratorOptionName::MaxCardinality {
        } => {
        }
        LoadGeneratorOptionName::Keys {
        } => {
        }
        LoadGeneratorOptionName::SnapshotRounds {
        } => {
        }
        LoadGeneratorOptionName::TransactionalSnapshot {
        } => {
        }
        LoadGeneratorOptionName::ValueSize {
        } => {
        }
        LoadGeneratorOptionName::Seed {
        } => {
        }
        LoadGeneratorOptionName::Partitions {
        } => {
        }
        LoadGeneratorOptionName::BatchSize {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MapEntry<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_map_entry_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_map_entry_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MapEntry<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_expr_mut(&mut node.key);
    visitor.visit_expr_mut(&mut node.value);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MaterializedViewOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_materialized_view_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_materialized_view_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MaterializedViewOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_materialized_view_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MaterializedViewOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_materialized_view_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_materialized_view_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MaterializedViewOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        MaterializedViewOptionName::AssertNotNull {
        } => {
        }
        MaterializedViewOptionName::PartitionBy {
        } => {
        }
        MaterializedViewOptionName::RetainHistory {
        } => {
        }
        MaterializedViewOptionName::Refresh {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MutRecBlock<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_mut_rec_block_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_mut_rec_block_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MutRecBlock<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.options {
        visitor.visit_mut_rec_block_option_mut(v);
    }
    for v in &mut node.ctes {
        visitor.visit_cte_mut_rec_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MutRecBlockOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_mut_rec_block_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_mut_rec_block_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MutRecBlockOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_mut_rec_block_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MutRecBlockOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_mut_rec_block_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_mut_rec_block_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MutRecBlockOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        MutRecBlockOptionName::RecursionLimit {
        } => {
        }
        MutRecBlockOptionName::ErrorAtRecursionLimit {
        } => {
        }
        MutRecBlockOptionName::ReturnAtRecursionLimit {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MySqlConfigOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_my_sql_config_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_my_sql_config_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MySqlConfigOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_my_sql_config_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for MySqlConfigOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_my_sql_config_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_my_sql_config_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut MySqlConfigOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        MySqlConfigOptionName::Details {
        } => {
        }
        MySqlConfigOptionName::TextColumns {
        } => {
        }
        MySqlConfigOptionName::ExcludeColumns {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NamedPlan {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_named_plan_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_named_plan_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NamedPlan)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        NamedPlan::Raw {
        } => {
        }
        NamedPlan::Decorrelated {
        } => {
        }
        NamedPlan::Local {
        } => {
        }
        NamedPlan::Global {
        } => {
        }
        NamedPlan::Physical {
        } => {
        }
        NamedPlan::FastPath {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NetworkPolicyOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_network_policy_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_network_policy_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NetworkPolicyOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_network_policy_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NetworkPolicyOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_network_policy_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_network_policy_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NetworkPolicyOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        NetworkPolicyOptionName::Rules {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NetworkPolicyRuleDefinition<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_network_policy_rule_definition_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_network_policy_rule_definition_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NetworkPolicyRuleDefinition<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.options {
        visitor.visit_network_policy_rule_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NetworkPolicyRuleOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_network_policy_rule_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_network_policy_rule_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NetworkPolicyRuleOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_network_policy_rule_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NetworkPolicyRuleOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_network_policy_rule_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_network_policy_rule_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NetworkPolicyRuleOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        NetworkPolicyRuleOptionName::Direction {
        } => {
        }
        NetworkPolicyRuleOptionName::Action {
        } => {
        }
        NetworkPolicyRuleOptionName::Address {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for NoticeSeverity {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_notice_severity_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_notice_severity_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut NoticeSeverity)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        NoticeSeverity::Debug {
        } => {
        }
        NoticeSeverity::Info {
        } => {
        }
        NoticeSeverity::Log {
        } => {
        }
        NoticeSeverity::Notice {
        } => {
        }
        NoticeSeverity::Warning {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ObjectType {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_object_type_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_object_type_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ObjectType)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ObjectType::Table {
        } => {
        }
        ObjectType::View {
        } => {
        }
        ObjectType::MaterializedView {
        } => {
        }
        ObjectType::Source {
        } => {
        }
        ObjectType::Sink {
        } => {
        }
        ObjectType::Index {
        } => {
        }
        ObjectType::Type {
        } => {
        }
        ObjectType::Role {
        } => {
        }
        ObjectType::Cluster {
        } => {
        }
        ObjectType::ClusterReplica {
        } => {
        }
        ObjectType::Secret {
        } => {
        }
        ObjectType::Connection {
        } => {
        }
        ObjectType::Database {
        } => {
        }
        ObjectType::Schema {
        } => {
        }
        ObjectType::Func {
        } => {
        }
        ObjectType::Subsource {
        } => {
        }
        ObjectType::ContinualTask {
        } => {
        }
        ObjectType::NetworkPolicy {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Op {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_op_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_op_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Op)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.namespace {
        for v in v {
            visitor.visit_ident_mut(v);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for OrderByExpr<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_order_by_expr_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_order_by_expr_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut OrderByExpr<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_expr_mut(&mut node.expr);
    if let Some(v) = &mut node.asc {
    }
    if let Some(v) = &mut node.nulls_last {
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for PgConfigOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_pg_config_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_pg_config_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut PgConfigOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_pg_config_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for PgConfigOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_pg_config_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_pg_config_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut PgConfigOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        PgConfigOptionName::Details {
        } => {
        }
        PgConfigOptionName::Publication {
        } => {
        }
        PgConfigOptionName::TextColumns {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for PrepareStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_prepare_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_prepare_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut PrepareStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    visitor.visit_nested_statement_mut(&mut *&mut node.stmt);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Privilege {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_privilege_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_privilege_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Privilege)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Privilege::SELECT {
        } => {
        }
        Privilege::INSERT {
        } => {
        }
        Privilege::UPDATE {
        } => {
        }
        Privilege::DELETE {
        } => {
        }
        Privilege::USAGE {
        } => {
        }
        Privilege::CREATE {
        } => {
        }
        Privilege::CREATEROLE {
        } => {
        }
        Privilege::CREATEDB {
        } => {
        }
        Privilege::CREATECLUSTER {
        } => {
        }
        Privilege::CREATENETWORKPOLICY {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for PrivilegeSpecification {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_privilege_specification_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_privilege_specification_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut PrivilegeSpecification)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        PrivilegeSpecification::All {
        } => {
        }
        PrivilegeSpecification::Privileges {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_privilege_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ProtobufSchema<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_protobuf_schema_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_protobuf_schema_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ProtobufSchema<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ProtobufSchema::Csr {
            csr_connection: binding0,
        } => {
            visitor.visit_csr_connection_protobuf_mut(binding0);
        }
        ProtobufSchema::InlineSchema {
            message_name: binding0,
            schema: binding1,
        } => {
            visitor.visit_schema_mut(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for QualifiedReplica {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_qualified_replica_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_qualified_replica_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut QualifiedReplica)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.cluster);
    visitor.visit_ident_mut(&mut node.replica);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Query<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_query_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_query_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Query<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_cte_block_mut(&mut node.ctes);
    visitor.visit_set_expr_mut(&mut node.body);
    for v in &mut node.order_by {
        visitor.visit_order_by_expr_mut(v);
    }
    if let Some(v) = &mut node.limit {
        visitor.visit_limit_mut(v);
    }
    if let Some(v) = &mut node.offset {
        visitor.visit_expr_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RaiseStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_raise_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_raise_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RaiseStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_notice_severity_mut(&mut node.severity);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ReaderSchemaSelectionStrategy {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_reader_schema_selection_strategy_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_reader_schema_selection_strategy_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ReaderSchemaSelectionStrategy)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ReaderSchemaSelectionStrategy::Latest {
        } => {
        }
        ReaderSchemaSelectionStrategy::Inline {
            0: binding0,
        } => {
        }
        ReaderSchemaSelectionStrategy::ById {
            0: binding0,
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ReassignOwnedStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_reassign_owned_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_reassign_owned_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ReassignOwnedStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.old_roles {
        visitor.visit_role_name_mut(v);
    }
    visitor.visit_role_name_mut(&mut node.new_role);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RefreshAtOptionValue<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_refresh_at_option_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_refresh_at_option_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RefreshAtOptionValue<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_expr_mut(&mut node.time);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RefreshEveryOptionValue<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_refresh_every_option_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_refresh_every_option_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RefreshEveryOptionValue<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_interval_value_mut(&mut node.interval);
    if let Some(v) = &mut node.aligned_to {
        visitor.visit_expr_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RefreshOptionValue<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_refresh_option_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_refresh_option_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RefreshOptionValue<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        RefreshOptionValue::OnCommit {
        } => {
        }
        RefreshOptionValue::AtCreation {
        } => {
        }
        RefreshOptionValue::At {
            0: binding0,
        } => {
            visitor.visit_refresh_at_option_value_mut(binding0);
        }
        RefreshOptionValue::Every {
            0: binding0,
        } => {
            visitor.visit_refresh_every_option_value_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ReplicaDefinition<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_replica_definition_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_replica_definition_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ReplicaDefinition<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.options {
        visitor.visit_replica_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ReplicaOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_replica_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_replica_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ReplicaOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_replica_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ReplicaOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_replica_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_replica_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ReplicaOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ReplicaOptionName::BilledAs {
        } => {
        }
        ReplicaOptionName::Size {
        } => {
        }
        ReplicaOptionName::AvailabilityZone {
        } => {
        }
        ReplicaOptionName::StorageAddresses {
        } => {
        }
        ReplicaOptionName::StoragectlAddresses {
        } => {
        }
        ReplicaOptionName::ComputectlAddresses {
        } => {
        }
        ReplicaOptionName::ComputeAddresses {
        } => {
        }
        ReplicaOptionName::Workers {
        } => {
        }
        ReplicaOptionName::Internal {
        } => {
        }
        ReplicaOptionName::IntrospectionInterval {
        } => {
        }
        ReplicaOptionName::IntrospectionDebugging {
        } => {
        }
        ReplicaOptionName::Disk {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ResetVariableStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_reset_variable_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_reset_variable_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ResetVariableStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.variable);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RevokePrivilegesStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_revoke_privileges_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_revoke_privileges_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RevokePrivilegesStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification_mut(&mut node.privileges);
    visitor.visit_grant_target_specification_mut(&mut node.target);
    for v in &mut node.roles {
        visitor.visit_role_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RevokeRoleStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_revoke_role_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_revoke_role_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RevokeRoleStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.role_names {
        visitor.visit_role_name_mut(v);
    }
    for v in &mut node.member_names {
        visitor.visit_role_name_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RoleAttribute {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_role_attribute_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_role_attribute_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RoleAttribute)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        RoleAttribute::Inherit {
        } => {
        }
        RoleAttribute::NoInherit {
        } => {
        }
        RoleAttribute::Password {
            0: binding0,
        } => {
            if let Some(v) = binding0 {
            }
        }
        RoleAttribute::Login {
        } => {
        }
        RoleAttribute::NoLogin {
        } => {
        }
        RoleAttribute::SuperUser {
        } => {
        }
        RoleAttribute::NoSuperUser {
        } => {
        }
        RoleAttribute::CreateCluster {
        } => {
        }
        RoleAttribute::NoCreateCluster {
        } => {
        }
        RoleAttribute::CreateDB {
        } => {
        }
        RoleAttribute::NoCreateDB {
        } => {
        }
        RoleAttribute::CreateRole {
        } => {
        }
        RoleAttribute::NoCreateRole {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for RollbackStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_rollback_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_rollback_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut RollbackStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Schema {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_schema_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_schema_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Schema)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Select<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_select_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_select_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Select<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.distinct {
        visitor.visit_distinct_mut(v);
    }
    for v in &mut node.projection {
        visitor.visit_select_item_mut(v);
    }
    for v in &mut node.from {
        visitor.visit_table_with_joins_mut(v);
    }
    if let Some(v) = &mut node.selection {
        visitor.visit_expr_mut(v);
    }
    for v in &mut node.group_by {
        visitor.visit_expr_mut(v);
    }
    if let Some(v) = &mut node.having {
        visitor.visit_expr_mut(v);
    }
    if let Some(v) = &mut node.qualify {
        visitor.visit_expr_mut(v);
    }
    for v in &mut node.options {
        visitor.visit_select_option_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SelectItem<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_select_item_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_select_item_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SelectItem<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SelectItem::Expr {
            expr: binding0,
            alias: binding1,
        } => {
            visitor.visit_expr_mut(binding0);
            if let Some(v) = binding1 {
                visitor.visit_ident_mut(v);
            }
        }
        SelectItem::Wildcard {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SelectOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_select_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_select_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SelectOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_select_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SelectOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_select_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_select_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SelectOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SelectOptionName::ExpectedGroupSize {
        } => {
        }
        SelectOptionName::AggregateInputGroupSize {
        } => {
        }
        SelectOptionName::DistinctOnInputGroupSize {
        } => {
        }
        SelectOptionName::LimitInputGroupSize {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SelectStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_select_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_select_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SelectStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_query_mut(&mut node.query);
    if let Some(v) = &mut node.as_of {
        visitor.visit_as_of_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetExpr<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_expr_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_expr_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetExpr<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SetExpr::Select {
            0: binding0,
        } => {
            visitor.visit_select_mut(&mut *binding0);
        }
        SetExpr::Query {
            0: binding0,
        } => {
            visitor.visit_query_mut(&mut *binding0);
        }
        SetExpr::SetOperation {
            op: binding0,
            all: binding1,
            left: binding2,
            right: binding3,
        } => {
            visitor.visit_set_operator_mut(binding0);
            visitor.visit_set_expr_mut(&mut *binding2);
            visitor.visit_set_expr_mut(&mut *binding3);
        }
        SetExpr::Values {
            0: binding0,
        } => {
            visitor.visit_values_mut(binding0);
        }
        SetExpr::Show {
            0: binding0,
        } => {
            visitor.visit_show_statement_mut(binding0);
        }
        SetExpr::Table {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetOperator {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_operator_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_operator_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetOperator)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SetOperator::Union {
        } => {
        }
        SetOperator::Except {
        } => {
        }
        SetOperator::Intersect {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetRoleVar {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_role_var_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_role_var_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetRoleVar)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SetRoleVar::Set {
            name: binding0,
            value: binding1,
        } => {
            visitor.visit_ident_mut(binding0);
            visitor.visit_set_variable_to_mut(binding1);
        }
        SetRoleVar::Reset {
            name: binding0,
        } => {
            visitor.visit_ident_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetTransactionStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_transaction_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_transaction_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetTransactionStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.modes {
        visitor.visit_transaction_mode_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetVariableStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_variable_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_variable_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetVariableStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.variable);
    visitor.visit_set_variable_to_mut(&mut node.to);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetVariableTo {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_variable_to_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_variable_to_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetVariableTo)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SetVariableTo::Default {
        } => {
        }
        SetVariableTo::Values {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_set_variable_value_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SetVariableValue {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_set_variable_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_set_variable_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SetVariableValue)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SetVariableValue::Ident {
            0: binding0,
        } => {
            visitor.visit_ident_mut(binding0);
        }
        SetVariableValue::Literal {
            0: binding0,
        } => {
            visitor.visit_value_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowColumnsStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_columns_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_columns_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowColumnsStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.table_name);
    if let Some(v) = &mut node.filter {
        visitor.visit_show_statement_filter_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateClusterStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_cluster_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_cluster_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateClusterStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_name_mut(&mut node.cluster_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateConnectionStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_connection_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_connection_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateConnectionStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.connection_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateIndexStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_index_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_index_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateIndexStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.index_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateMaterializedViewStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_materialized_view_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_materialized_view_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateMaterializedViewStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.materialized_view_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateSinkStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_sink_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_sink_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateSinkStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.sink_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateSourceStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_source_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_source_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateSourceStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.source_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateTableStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_table_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_table_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateTableStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.table_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowCreateViewStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_create_view_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_create_view_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowCreateViewStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.view_name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowObjectType<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_object_type_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_object_type_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowObjectType<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ShowObjectType::MaterializedView {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name_mut(v);
            }
        }
        ShowObjectType::Index {
            in_cluster: binding0,
            on_object: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name_mut(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_item_name_mut(v);
            }
        }
        ShowObjectType::Table {
            on_source: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_item_name_mut(v);
            }
        }
        ShowObjectType::View {
        } => {
        }
        ShowObjectType::Source {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name_mut(v);
            }
        }
        ShowObjectType::Sink {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name_mut(v);
            }
        }
        ShowObjectType::Type {
        } => {
        }
        ShowObjectType::Role {
        } => {
        }
        ShowObjectType::Cluster {
        } => {
        }
        ShowObjectType::ClusterReplica {
        } => {
        }
        ShowObjectType::Object {
        } => {
        }
        ShowObjectType::Secret {
        } => {
        }
        ShowObjectType::Connection {
        } => {
        }
        ShowObjectType::Database {
        } => {
        }
        ShowObjectType::Schema {
            from: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_database_name_mut(v);
            }
        }
        ShowObjectType::Subsource {
            on_source: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_item_name_mut(v);
            }
        }
        ShowObjectType::Privileges {
            object_type: binding0,
            role: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_system_object_type_mut(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_role_name_mut(v);
            }
        }
        ShowObjectType::DefaultPrivileges {
            object_type: binding0,
            role: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_object_type_mut(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_role_name_mut(v);
            }
        }
        ShowObjectType::RoleMembership {
            role: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_role_name_mut(v);
            }
        }
        ShowObjectType::ContinualTask {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name_mut(v);
            }
        }
        ShowObjectType::NetworkPolicy {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowObjectsStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_objects_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_objects_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowObjectsStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_show_object_type_mut(&mut node.object_type);
    if let Some(v) = &mut node.from {
        visitor.visit_schema_name_mut(v);
    }
    if let Some(v) = &mut node.filter {
        visitor.visit_show_statement_filter_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ShowStatement::ShowObjects {
            0: binding0,
        } => {
            visitor.visit_show_objects_statement_mut(binding0);
        }
        ShowStatement::ShowColumns {
            0: binding0,
        } => {
            visitor.visit_show_columns_statement_mut(binding0);
        }
        ShowStatement::ShowCreateView {
            0: binding0,
        } => {
            visitor.visit_show_create_view_statement_mut(binding0);
        }
        ShowStatement::ShowCreateMaterializedView {
            0: binding0,
        } => {
            visitor.visit_show_create_materialized_view_statement_mut(binding0);
        }
        ShowStatement::ShowCreateSource {
            0: binding0,
        } => {
            visitor.visit_show_create_source_statement_mut(binding0);
        }
        ShowStatement::ShowCreateTable {
            0: binding0,
        } => {
            visitor.visit_show_create_table_statement_mut(binding0);
        }
        ShowStatement::ShowCreateSink {
            0: binding0,
        } => {
            visitor.visit_show_create_sink_statement_mut(binding0);
        }
        ShowStatement::ShowCreateIndex {
            0: binding0,
        } => {
            visitor.visit_show_create_index_statement_mut(binding0);
        }
        ShowStatement::ShowCreateConnection {
            0: binding0,
        } => {
            visitor.visit_show_create_connection_statement_mut(binding0);
        }
        ShowStatement::ShowCreateCluster {
            0: binding0,
        } => {
            visitor.visit_show_create_cluster_statement_mut(binding0);
        }
        ShowStatement::ShowVariable {
            0: binding0,
        } => {
            visitor.visit_show_variable_statement_mut(binding0);
        }
        ShowStatement::InspectShard {
            0: binding0,
        } => {
            visitor.visit_inspect_shard_statement_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowStatementFilter<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_statement_filter_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_statement_filter_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowStatementFilter<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        ShowStatementFilter::Like {
            0: binding0,
        } => {
        }
        ShowStatementFilter::Where {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ShowVariableStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_show_variable_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_show_variable_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ShowVariableStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.variable);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SinkEnvelope {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_sink_envelope_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_sink_envelope_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SinkEnvelope)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SinkEnvelope::Debezium {
        } => {
        }
        SinkEnvelope::Upsert {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SourceEnvelope {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_source_envelope_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_source_envelope_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SourceEnvelope)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SourceEnvelope::None {
        } => {
        }
        SourceEnvelope::Debezium {
        } => {
        }
        SourceEnvelope::Upsert {
            value_decode_err_policy: binding0,
        } => {
            for v in binding0 {
                visitor.visit_source_error_policy_mut(v);
            }
        }
        SourceEnvelope::CdcV2 {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SourceErrorPolicy {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_source_error_policy_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_source_error_policy_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SourceErrorPolicy)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SourceErrorPolicy::Inline {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SourceIncludeMetadata {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_source_include_metadata_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_source_include_metadata_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SourceIncludeMetadata)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SourceIncludeMetadata::Key {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        SourceIncludeMetadata::Timestamp {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        SourceIncludeMetadata::Partition {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        SourceIncludeMetadata::Offset {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        SourceIncludeMetadata::Headers {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        SourceIncludeMetadata::Header {
            key: binding0,
            alias: binding1,
            use_bytes: binding2,
        } => {
            visitor.visit_ident_mut(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SqlServerConfigOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_sql_server_config_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_sql_server_config_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SqlServerConfigOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_sql_server_config_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SqlServerConfigOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_sql_server_config_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_sql_server_config_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SqlServerConfigOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SqlServerConfigOptionName::Details {
        } => {
        }
        SqlServerConfigOptionName::TextColumns {
        } => {
        }
        SqlServerConfigOptionName::ExcludeColumns {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for StartTransactionStatement {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_start_transaction_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_start_transaction_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut StartTransactionStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.modes {
        visitor.visit_transaction_mode_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Statement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Statement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Statement::Select {
            0: binding0,
        } => {
            visitor.visit_select_statement_mut(binding0);
        }
        Statement::Insert {
            0: binding0,
        } => {
            visitor.visit_insert_statement_mut(binding0);
        }
        Statement::Copy {
            0: binding0,
        } => {
            visitor.visit_copy_statement_mut(binding0);
        }
        Statement::Update {
            0: binding0,
        } => {
            visitor.visit_update_statement_mut(binding0);
        }
        Statement::Delete {
            0: binding0,
        } => {
            visitor.visit_delete_statement_mut(binding0);
        }
        Statement::CreateConnection {
            0: binding0,
        } => {
            visitor.visit_create_connection_statement_mut(binding0);
        }
        Statement::CreateDatabase {
            0: binding0,
        } => {
            visitor.visit_create_database_statement_mut(binding0);
        }
        Statement::CreateSchema {
            0: binding0,
        } => {
            visitor.visit_create_schema_statement_mut(binding0);
        }
        Statement::CreateWebhookSource {
            0: binding0,
        } => {
            visitor.visit_create_webhook_source_statement_mut(binding0);
        }
        Statement::CreateSource {
            0: binding0,
        } => {
            visitor.visit_create_source_statement_mut(binding0);
        }
        Statement::CreateSubsource {
            0: binding0,
        } => {
            visitor.visit_create_subsource_statement_mut(binding0);
        }
        Statement::CreateSink {
            0: binding0,
        } => {
            visitor.visit_create_sink_statement_mut(binding0);
        }
        Statement::CreateView {
            0: binding0,
        } => {
            visitor.visit_create_view_statement_mut(binding0);
        }
        Statement::CreateMaterializedView {
            0: binding0,
        } => {
            visitor.visit_create_materialized_view_statement_mut(binding0);
        }
        Statement::CreateContinualTask {
            0: binding0,
        } => {
            visitor.visit_create_continual_task_statement_mut(binding0);
        }
        Statement::CreateTable {
            0: binding0,
        } => {
            visitor.visit_create_table_statement_mut(binding0);
        }
        Statement::CreateTableFromSource {
            0: binding0,
        } => {
            visitor.visit_create_table_from_source_statement_mut(binding0);
        }
        Statement::CreateIndex {
            0: binding0,
        } => {
            visitor.visit_create_index_statement_mut(binding0);
        }
        Statement::CreateType {
            0: binding0,
        } => {
            visitor.visit_create_type_statement_mut(binding0);
        }
        Statement::CreateRole {
            0: binding0,
        } => {
            visitor.visit_create_role_statement_mut(binding0);
        }
        Statement::CreateCluster {
            0: binding0,
        } => {
            visitor.visit_create_cluster_statement_mut(binding0);
        }
        Statement::CreateClusterReplica {
            0: binding0,
        } => {
            visitor.visit_create_cluster_replica_statement_mut(binding0);
        }
        Statement::CreateSecret {
            0: binding0,
        } => {
            visitor.visit_create_secret_statement_mut(binding0);
        }
        Statement::CreateNetworkPolicy {
            0: binding0,
        } => {
            visitor.visit_create_network_policy_statement_mut(binding0);
        }
        Statement::AlterCluster {
            0: binding0,
        } => {
            visitor.visit_alter_cluster_statement_mut(binding0);
        }
        Statement::AlterOwner {
            0: binding0,
        } => {
            visitor.visit_alter_owner_statement_mut(binding0);
        }
        Statement::AlterObjectRename {
            0: binding0,
        } => {
            visitor.visit_alter_object_rename_statement_mut(binding0);
        }
        Statement::AlterObjectSwap {
            0: binding0,
        } => {
            visitor.visit_alter_object_swap_statement_mut(binding0);
        }
        Statement::AlterRetainHistory {
            0: binding0,
        } => {
            visitor.visit_alter_retain_history_statement_mut(binding0);
        }
        Statement::AlterIndex {
            0: binding0,
        } => {
            visitor.visit_alter_index_statement_mut(binding0);
        }
        Statement::AlterSecret {
            0: binding0,
        } => {
            visitor.visit_alter_secret_statement_mut(binding0);
        }
        Statement::AlterSetCluster {
            0: binding0,
        } => {
            visitor.visit_alter_set_cluster_statement_mut(binding0);
        }
        Statement::AlterSink {
            0: binding0,
        } => {
            visitor.visit_alter_sink_statement_mut(binding0);
        }
        Statement::AlterSource {
            0: binding0,
        } => {
            visitor.visit_alter_source_statement_mut(binding0);
        }
        Statement::AlterSystemSet {
            0: binding0,
        } => {
            visitor.visit_alter_system_set_statement_mut(binding0);
        }
        Statement::AlterSystemReset {
            0: binding0,
        } => {
            visitor.visit_alter_system_reset_statement_mut(binding0);
        }
        Statement::AlterSystemResetAll {
            0: binding0,
        } => {
            visitor.visit_alter_system_reset_all_statement_mut(binding0);
        }
        Statement::AlterConnection {
            0: binding0,
        } => {
            visitor.visit_alter_connection_statement_mut(binding0);
        }
        Statement::AlterNetworkPolicy {
            0: binding0,
        } => {
            visitor.visit_alter_network_policy_statement_mut(binding0);
        }
        Statement::AlterRole {
            0: binding0,
        } => {
            visitor.visit_alter_role_statement_mut(binding0);
        }
        Statement::AlterTableAddColumn {
            0: binding0,
        } => {
            visitor.visit_alter_table_add_column_statement_mut(binding0);
        }
        Statement::Discard {
            0: binding0,
        } => {
            visitor.visit_discard_statement_mut(binding0);
        }
        Statement::DropObjects {
            0: binding0,
        } => {
            visitor.visit_drop_objects_statement_mut(binding0);
        }
        Statement::DropOwned {
            0: binding0,
        } => {
            visitor.visit_drop_owned_statement_mut(binding0);
        }
        Statement::SetVariable {
            0: binding0,
        } => {
            visitor.visit_set_variable_statement_mut(binding0);
        }
        Statement::ResetVariable {
            0: binding0,
        } => {
            visitor.visit_reset_variable_statement_mut(binding0);
        }
        Statement::Show {
            0: binding0,
        } => {
            visitor.visit_show_statement_mut(binding0);
        }
        Statement::StartTransaction {
            0: binding0,
        } => {
            visitor.visit_start_transaction_statement_mut(binding0);
        }
        Statement::SetTransaction {
            0: binding0,
        } => {
            visitor.visit_set_transaction_statement_mut(binding0);
        }
        Statement::Commit {
            0: binding0,
        } => {
            visitor.visit_commit_statement_mut(binding0);
        }
        Statement::Rollback {
            0: binding0,
        } => {
            visitor.visit_rollback_statement_mut(binding0);
        }
        Statement::Subscribe {
            0: binding0,
        } => {
            visitor.visit_subscribe_statement_mut(binding0);
        }
        Statement::ExplainPlan {
            0: binding0,
        } => {
            visitor.visit_explain_plan_statement_mut(binding0);
        }
        Statement::ExplainPushdown {
            0: binding0,
        } => {
            visitor.visit_explain_pushdown_statement_mut(binding0);
        }
        Statement::ExplainTimestamp {
            0: binding0,
        } => {
            visitor.visit_explain_timestamp_statement_mut(binding0);
        }
        Statement::ExplainSinkSchema {
            0: binding0,
        } => {
            visitor.visit_explain_sink_schema_statement_mut(binding0);
        }
        Statement::Declare {
            0: binding0,
        } => {
            visitor.visit_declare_statement_mut(binding0);
        }
        Statement::Fetch {
            0: binding0,
        } => {
            visitor.visit_fetch_statement_mut(binding0);
        }
        Statement::Close {
            0: binding0,
        } => {
            visitor.visit_close_statement_mut(binding0);
        }
        Statement::Prepare {
            0: binding0,
        } => {
            visitor.visit_prepare_statement_mut(binding0);
        }
        Statement::Execute {
            0: binding0,
        } => {
            visitor.visit_execute_statement_mut(binding0);
        }
        Statement::Deallocate {
            0: binding0,
        } => {
            visitor.visit_deallocate_statement_mut(binding0);
        }
        Statement::Raise {
            0: binding0,
        } => {
            visitor.visit_raise_statement_mut(binding0);
        }
        Statement::GrantRole {
            0: binding0,
        } => {
            visitor.visit_grant_role_statement_mut(binding0);
        }
        Statement::RevokeRole {
            0: binding0,
        } => {
            visitor.visit_revoke_role_statement_mut(binding0);
        }
        Statement::GrantPrivileges {
            0: binding0,
        } => {
            visitor.visit_grant_privileges_statement_mut(binding0);
        }
        Statement::RevokePrivileges {
            0: binding0,
        } => {
            visitor.visit_revoke_privileges_statement_mut(binding0);
        }
        Statement::AlterDefaultPrivileges {
            0: binding0,
        } => {
            visitor.visit_alter_default_privileges_statement_mut(binding0);
        }
        Statement::ReassignOwned {
            0: binding0,
        } => {
            visitor.visit_reassign_owned_statement_mut(binding0);
        }
        Statement::ValidateConnection {
            0: binding0,
        } => {
            visitor.visit_validate_connection_statement_mut(binding0);
        }
        Statement::Comment {
            0: binding0,
        } => {
            visitor.visit_comment_statement_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SubscribeOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_subscribe_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_subscribe_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SubscribeOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_subscribe_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SubscribeOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_subscribe_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_subscribe_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SubscribeOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SubscribeOptionName::Snapshot {
        } => {
        }
        SubscribeOptionName::Progress {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SubscribeOutput<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_subscribe_output_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_subscribe_output_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SubscribeOutput<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SubscribeOutput::Diffs {
        } => {
        }
        SubscribeOutput::WithinTimestampOrderBy {
            order_by: binding0,
        } => {
            for v in binding0 {
                visitor.visit_order_by_expr_mut(v);
            }
        }
        SubscribeOutput::EnvelopeUpsert {
            key_columns: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        SubscribeOutput::EnvelopeDebezium {
            key_columns: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SubscribeRelation<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_subscribe_relation_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_subscribe_relation_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SubscribeRelation<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SubscribeRelation::Name {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        SubscribeRelation::Query {
            0: binding0,
        } => {
            visitor.visit_query_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SubscribeStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_subscribe_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_subscribe_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SubscribeStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_subscribe_relation_mut(&mut node.relation);
    for v in &mut node.options {
        visitor.visit_subscribe_option_mut(v);
    }
    if let Some(v) = &mut node.as_of {
        visitor.visit_as_of_mut(v);
    }
    if let Some(v) = &mut node.up_to {
        visitor.visit_expr_mut(v);
    }
    visitor.visit_subscribe_output_mut(&mut node.output);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SubscriptPosition<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_subscript_position_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_subscript_position_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SubscriptPosition<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    if let Some(v) = &mut node.start {
        visitor.visit_expr_mut(v);
    }
    if let Some(v) = &mut node.end {
        visitor.visit_expr_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for SystemObjectType {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_system_object_type_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_system_object_type_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut SystemObjectType)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        SystemObjectType::System {
        } => {
        }
        SystemObjectType::Object {
            0: binding0,
        } => {
            visitor.visit_object_type_mut(binding0);
        }
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cluster_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::ClusterName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_column_reference_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::ColumnReference)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_cte_id_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::CteId)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_data_type_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::DataType)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_database_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::DatabaseName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_item_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::ItemName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_nested_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::NestedStatement)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_network_policy_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::NetworkPolicyName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_object_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::ObjectName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_role_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::RoleName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_schema_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut T::SchemaName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableAlias {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_alias_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_alias_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableAlias)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.name);
    for v in &mut node.columns {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableConstraint<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_constraint_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_constraint_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableConstraint<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TableConstraint::Unique {
            name: binding0,
            columns: binding1,
            is_primary: binding2,
            nulls_not_distinct: binding3,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
            for v in binding1 {
                visitor.visit_ident_mut(v);
            }
        }
        TableConstraint::ForeignKey {
            name: binding0,
            columns: binding1,
            foreign_table: binding2,
            referred_columns: binding3,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
            for v in binding1 {
                visitor.visit_ident_mut(v);
            }
            visitor.visit_item_name_mut(binding2);
            for v in binding3 {
                visitor.visit_ident_mut(v);
            }
        }
        TableConstraint::Check {
            name: binding0,
            expr: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident_mut(v);
            }
            visitor.visit_expr_mut(&mut *binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableFactor<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_factor_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_factor_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableFactor<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TableFactor::Table {
            name: binding0,
            alias: binding1,
        } => {
            visitor.visit_item_name_mut(binding0);
            if let Some(v) = binding1 {
                visitor.visit_table_alias_mut(v);
            }
        }
        TableFactor::Function {
            function: binding0,
            alias: binding1,
            with_ordinality: binding2,
        } => {
            visitor.visit_function_mut(binding0);
            if let Some(v) = binding1 {
                visitor.visit_table_alias_mut(v);
            }
        }
        TableFactor::RowsFrom {
            functions: binding0,
            alias: binding1,
            with_ordinality: binding2,
        } => {
            for v in binding0 {
                visitor.visit_function_mut(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_table_alias_mut(v);
            }
        }
        TableFactor::Derived {
            lateral: binding0,
            subquery: binding1,
            alias: binding2,
        } => {
            visitor.visit_query_mut(&mut *binding1);
            if let Some(v) = binding2 {
                visitor.visit_table_alias_mut(v);
            }
        }
        TableFactor::NestedJoin {
            join: binding0,
            alias: binding1,
        } => {
            visitor.visit_table_with_joins_mut(&mut *binding0);
            if let Some(v) = binding1 {
                visitor.visit_table_alias_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableFromSourceColumns<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_from_source_columns_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_from_source_columns_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableFromSourceColumns<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TableFromSourceColumns::NotSpecified {
        } => {
        }
        TableFromSourceColumns::Named {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident_mut(v);
            }
        }
        TableFromSourceColumns::Defined {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_column_def_mut(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableFromSourceOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_from_source_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_from_source_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableFromSourceOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_table_from_source_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableFromSourceOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_from_source_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_from_source_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableFromSourceOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TableFromSourceOptionName::TextColumns {
        } => {
        }
        TableFromSourceOptionName::ExcludeColumns {
        } => {
        }
        TableFromSourceOptionName::Details {
        } => {
        }
        TableFromSourceOptionName::PartitionBy {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableOption<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_option_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_option_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableOption<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_table_option_name_mut(&mut node.name);
    if let Some(v) = &mut node.value {
        visitor.visit_with_option_value_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableOptionName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_option_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_option_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableOptionName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TableOptionName::PartitionBy {
        } => {
        }
        TableOptionName::RetainHistory {
        } => {
        }
        TableOptionName::RedactedTest {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TableWithJoins<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_table_with_joins_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_table_with_joins_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TableWithJoins<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_table_factor_mut(&mut node.relation);
    for v in &mut node.joins {
        visitor.visit_join_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TargetRoleSpecification<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_target_role_specification_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_target_role_specification_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TargetRoleSpecification<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TargetRoleSpecification::Roles {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_role_name_mut(v);
            }
        }
        TargetRoleSpecification::AllRoles {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TransactionAccessMode {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_transaction_access_mode_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_transaction_access_mode_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TransactionAccessMode)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TransactionAccessMode::ReadOnly {
        } => {
        }
        TransactionAccessMode::ReadWrite {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TransactionIsolationLevel {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_transaction_isolation_level_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_transaction_isolation_level_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TransactionIsolationLevel)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TransactionIsolationLevel::ReadUncommitted {
        } => {
        }
        TransactionIsolationLevel::ReadCommitted {
        } => {
        }
        TransactionIsolationLevel::RepeatableRead {
        } => {
        }
        TransactionIsolationLevel::Serializable {
        } => {
        }
        TransactionIsolationLevel::StrongSessionSerializable {
        } => {
        }
        TransactionIsolationLevel::StrictSerializable {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for TransactionMode {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_transaction_mode_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_transaction_mode_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut TransactionMode)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        TransactionMode::AccessMode {
            0: binding0,
        } => {
            visitor.visit_transaction_access_mode_mut(binding0);
        }
        TransactionMode::IsolationLevel {
            0: binding0,
        } => {
            visitor.visit_transaction_isolation_level_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for UnresolvedDatabaseName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_unresolved_database_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_unresolved_database_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut UnresolvedDatabaseName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_ident_mut(&mut node.0);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for UnresolvedItemName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_unresolved_item_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_unresolved_item_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut UnresolvedItemName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.0 {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for UnresolvedObjectName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_unresolved_object_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_unresolved_object_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut UnresolvedObjectName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        UnresolvedObjectName::Cluster {
            0: binding0,
        } => {
            visitor.visit_ident_mut(binding0);
        }
        UnresolvedObjectName::ClusterReplica {
            0: binding0,
        } => {
            visitor.visit_qualified_replica_mut(binding0);
        }
        UnresolvedObjectName::Database {
            0: binding0,
        } => {
            visitor.visit_unresolved_database_name_mut(binding0);
        }
        UnresolvedObjectName::Schema {
            0: binding0,
        } => {
            visitor.visit_unresolved_schema_name_mut(binding0);
        }
        UnresolvedObjectName::Role {
            0: binding0,
        } => {
            visitor.visit_ident_mut(binding0);
        }
        UnresolvedObjectName::Item {
            0: binding0,
        } => {
            visitor.visit_unresolved_item_name_mut(binding0);
        }
        UnresolvedObjectName::NetworkPolicy {
            0: binding0,
        } => {
            visitor.visit_ident_mut(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for UnresolvedSchemaName {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_unresolved_schema_name_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_unresolved_schema_name_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut UnresolvedSchemaName)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.0 {
        visitor.visit_ident_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for UpdateStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_update_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_update_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut UpdateStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.table_name);
    if let Some(v) = &mut node.alias {
        visitor.visit_table_alias_mut(v);
    }
    for v in &mut node.assignments {
        visitor.visit_assignment_mut(v);
    }
    if let Some(v) = &mut node.selection {
        visitor.visit_expr_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ValidateConnectionStatement<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_validate_connection_statement_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_validate_connection_statement_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ValidateConnectionStatement<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_item_name_mut(&mut node.name);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Value {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Value)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        Value::Number {
            0: binding0,
        } => {
        }
        Value::String {
            0: binding0,
        } => {
        }
        Value::HexString {
            0: binding0,
        } => {
        }
        Value::Boolean {
            0: binding0,
        } => {
        }
        Value::Interval {
            0: binding0,
        } => {
            visitor.visit_interval_value_mut(binding0);
        }
        Value::Null {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ValueError {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_value_error_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_value_error_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ValueError)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Values<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_values_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_values_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Values<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.0 {
        for v in v {
            visitor.visit_expr_mut(v);
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for Version {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_version_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_version_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut Version)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for ViewDefinition<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_view_definition_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_view_definition_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut ViewDefinition<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name_mut(&mut node.name);
    for v in &mut node.columns {
        visitor.visit_ident_mut(v);
    }
    visitor.visit_query_mut(&mut node.query);
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for WindowFrame {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_window_frame_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_window_frame_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut WindowFrame)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    visitor.visit_window_frame_units_mut(&mut node.units);
    visitor.visit_window_frame_bound_mut(&mut node.start_bound);
    if let Some(v) = &mut node.end_bound {
        visitor.visit_window_frame_bound_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for WindowFrameBound {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_window_frame_bound_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_window_frame_bound_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut WindowFrameBound)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        WindowFrameBound::CurrentRow {
        } => {
        }
        WindowFrameBound::Preceding {
            0: binding0,
        } => {
            if let Some(v) = binding0 {
            }
        }
        WindowFrameBound::Following {
            0: binding0,
        } => {
            if let Some(v) = binding0 {
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for WindowFrameUnits {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_window_frame_units_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_window_frame_units_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut WindowFrameUnits)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        WindowFrameUnits::Rows {
        } => {
        }
        WindowFrameUnits::Range {
        } => {
        }
        WindowFrameUnits::Groups {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for WindowSpec<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_window_spec_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_window_spec_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut WindowSpec<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    for v in &mut node.partition_by {
        visitor.visit_expr_mut(v);
    }
    for v in &mut node.order_by {
        visitor.visit_order_by_expr_mut(v);
    }
    if let Some(v) = &mut node.window_frame {
        visitor.visit_window_frame_mut(v);
    }
}
impl<'ast, T: AstInfo, > VisitMutNode<'ast, T, > for WithOptionValue<T> {
    fn visit_mut<V: VisitMut<'ast, T, >>(&'ast mut self, visitor: &mut V) {
        visitor.visit_with_option_value_mut(self)
    }
}
#[allow(clippy::needless_pass_by_ref_mut)]
pub fn visit_with_option_value_mut<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast mut WithOptionValue<T>)
where
    V: VisitMut<'ast, T, > + ?Sized,
{
    match node {
        WithOptionValue::Value {
            0: binding0,
        } => {
            visitor.visit_value_mut(binding0);
        }
        WithOptionValue::DataType {
            0: binding0,
        } => {
            visitor.visit_data_type_mut(binding0);
        }
        WithOptionValue::Secret {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        WithOptionValue::Item {
            0: binding0,
        } => {
            visitor.visit_item_name_mut(binding0);
        }
        WithOptionValue::UnresolvedItemName {
            0: binding0,
        } => {
            visitor.visit_unresolved_item_name_mut(binding0);
        }
        WithOptionValue::Ident {
            0: binding0,
        } => {
            visitor.visit_ident_mut(binding0);
        }
        WithOptionValue::Sequence {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_with_option_value_mut(v);
            }
        }
        WithOptionValue::Map {
            0: binding0,
        } => {
            for (_, value) in binding0 {
                visitor.visit_with_option_value_mut(value);
            }
        }
        WithOptionValue::Expr {
            0: binding0,
        } => {
            visitor.visit_expr_mut(binding0);
        }
        WithOptionValue::ClusterReplicas {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_replica_definition_mut(v);
            }
        }
        WithOptionValue::ConnectionKafkaBroker {
            0: binding0,
        } => {
            visitor.visit_kafka_broker_mut(binding0);
        }
        WithOptionValue::ConnectionAwsPrivatelink {
            0: binding0,
        } => {
            visitor.visit_connection_default_aws_privatelink_mut(binding0);
        }
        WithOptionValue::RetainHistoryFor {
            0: binding0,
        } => {
            visitor.visit_value_mut(binding0);
        }
        WithOptionValue::Refresh {
            0: binding0,
        } => {
            visitor.visit_refresh_option_value_mut(binding0);
        }
        WithOptionValue::ClusterScheduleOptionValue {
            0: binding0,
        } => {
            visitor.visit_cluster_schedule_option_value_mut(binding0);
        }
        WithOptionValue::ClusterAlterStrategy {
            0: binding0,
        } => {
            visitor.visit_cluster_alter_option_value_mut(binding0);
        }
        WithOptionValue::NetworkPolicyRules {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_network_policy_rule_definition_mut(v);
            }
        }
    }
}